Split Linux (GTK) out

Author: dkwingsmt

shell/platform/linux/BUILD.gn

@@ -79,6 +79,7 @@ source_set("flutter_linux_sources") {
              "fl_method_codec_private.h",
              "fl_plugin_registrar_private.h",
              "fl_standard_message_codec_private.h",
+             "keyboard_map_private.h",
            ]
 
   configs += [
@@ -97,6 +98,7 @@ source_set("flutter_linux_sources") {
     "fl_json_message_codec.cc",
     "fl_json_method_codec.cc",
     "fl_key_event_plugin.cc",
+    "fl_keyboard_manager.cc",
     "fl_message_codec.cc",
     "fl_method_call.cc",
     "fl_method_channel.cc",
@@ -117,6 +119,7 @@ source_set("flutter_linux_sources") {
     "fl_text_input_plugin.cc",
     "fl_value.cc",
     "fl_view.cc",
+    "keyboard_map.cc",
   ]
 
   # Set flag to stop headers being directly included (library users should not do this)
@@ -167,6 +170,7 @@ executable("flutter_linux_unittests") {
     "fl_json_message_codec_test.cc",
     "fl_json_method_codec_test.cc",
     "fl_key_event_plugin_test.cc",
+    "fl_keyboard_manager_test.cc",
     "fl_message_codec_test.cc",
     "fl_method_channel_test.cc",
     "fl_method_codec_test.cc",

shell/platform/linux/fl_engine.cc

@@ -613,6 +613,11 @@ void fl_engine_send_mouse_pointer_event(FlEngine* self,
   self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1);
 }
 
+void fl_engine_send_key_event(FlEngine* self,
+                              const FlutterKeyEvent* event) {
+  self->embedder_api.SendKeyEvent(self->engine, event);
+}
+
 G_MODULE_EXPORT FlBinaryMessenger* fl_engine_get_binary_messenger(
     FlEngine* self) {
   g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);

shell/platform/linux/fl_engine_private.h

@@ -133,6 +133,16 @@ void fl_engine_send_mouse_pointer_event(FlEngine* engine,
                                         double scroll_delta_y,
                                         int64_t buttons);
 
+/**
+ * fl_engine_send_key_event:
+ * @engine: an #FlEngine.
+ * @event: the key event to send.
+ *
+ * Sends a key event to the engine.
+ */
+void fl_engine_send_key_event(FlEngine* engine,
+                              const FlutterKeyEvent* event);
+
 /**
  * fl_engine_send_platform_message_response:
  * @engine: an #FlEngine.

shell/platform/linux/fl_keyboard_manager.cc

@@ -0,0 +1,184 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/fl_keyboard_manager.h"
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+#include "flutter/shell/platform/linux/keyboard_map_private.h"
+
+// Ensures that a uint64_t can be safely fit into a gpointer.
+//
+// Flutter keyboard keys, values of uint64_t, are used by GHashTable by being
+// reinterpreted as gpointers. This greatly simplifies the implementation
+// (otherwise all keys and values needs allocation), but requires pointers to
+// be at least 64-bit long.
+//
+// Reinterpreting integers as gpointers for GHashTable is officially supported
+// by GTK, but natively it only supports 32-bit, probably due to crossplatform.
+static_assert(sizeof(gpointer) >= sizeof(uint64_t));
+
+static constexpr uint64_t kLinuxKeyIdPlane = 0x00400000000;
+static constexpr uint64_t kAutogeneratedMask = 0x10000000000;
+// // The `gdk_keyval_to_unicode` returns a guint32 character, which should not
+// // exceed this length (including \0) after being converted to UTF-8.
+// static constexpr size_t kCharacterPoolSize = 5;
+static constexpr double kMicrosecondsPerMillisecond = 1000;
+
+struct _FlKeyboardManager {
+  gchar* character_to_free;
+
+  GObject parent_instance;
+
+  // Stores pressed keys, mapping their Flutter physical key to Flutter logical key.
+  //
+  // Both keys and values are directly stored uint64s.
+  GHashTable* pressing_records;
+
+  // A static map from XKB to Flutter's physical key code
+  GHashTable* xkb_to_physical_key;
+
+  // A static map from GTK keyval to Flutter's logical key code
+  GHashTable* keyval_to_logical_key;
+};
+
+G_DEFINE_TYPE(FlKeyboardManager, fl_keyboard_manager, G_TYPE_OBJECT)
+
+static uint64_t event_to_physical_key(const GdkEventKey* event, GHashTable* table) {
+  gpointer record = g_hash_table_lookup(table, GUINT_TO_POINTER(event->hardware_keycode));
+  if (record != nullptr) {
+    return GPOINTER_TO_UINT(record);
+  }
+  // Auto-generate key
+  return kAutogeneratedMask | kLinuxKeyIdPlane | event->hardware_keycode;
+}
+
+static uint64_t event_to_logical_key(const GdkEventKey* event, GHashTable* table) {
+  guint keyval = event->keyval;
+  gpointer record = g_hash_table_lookup(table, GUINT_TO_POINTER(keyval));
+  if (record != nullptr) {
+    return GPOINTER_TO_UINT(record);
+  }
+  // ASCII // TODO
+  if (keyval < 256) {
+    return keyval;
+  }
+  // Auto-generate key
+  return kAutogeneratedMask | kLinuxKeyIdPlane | keyval;
+}
+
+static uint64_t event_to_timestamp(const GdkEventKey* event) {
+  return kMicrosecondsPerMillisecond * (double)event->time;
+}
+
+// Returns a newly accocated UTF-8 string from event->keyval that must be
+// freed later with g_free().
+static char* event_to_character(const GdkEventKey* event) {
+  gunichar unicodeChar = gdk_keyval_to_unicode(event->keyval);
+  glong items_written;
+  gchar* result = g_ucs4_to_utf8(&unicodeChar, 1, NULL, &items_written, NULL);
+  if (items_written == 0) {
+    if (result != NULL)
+      g_free(result);
+    return nullptr;
+  }
+  return result;
+}
+
+static uint64_t gpointerToUint64(gpointer pointer) {
+  return pointer == nullptr ? 0 : reinterpret_cast<uint64_t>(pointer);
+}
+
+static gpointer uint64ToGpointer(uint64_t number) {
+  return reinterpret_cast<gpointer>(number);
+}
+
+// Return the logical key corresponding to the physical key.
+//
+// Returns 0 if not found.
+static uint64_t pressed_logical_for_physical(GHashTable* pressing_records, uint64_t physical) {
+  return gpointerToUint64(g_hash_table_lookup(pressing_records, uint64ToGpointer(physical)));
+}
+
+size_t fl_keyboard_manager_convert_key_event(FlKeyboardManager* self,
+                                             const GdkEventKey* event,
+                                             FlKeyDatum* results) {
+  printf("===START=== state %d\n", event->state);
+  if (self->character_to_free != nullptr) {
+    g_free(self->character_to_free);
+    self->character_to_free = nullptr;
+  }
+  uint64_t physical_key = event_to_physical_key(event, self->xkb_to_physical_key);
+  uint64_t logical_key = event_to_logical_key(event, self->keyval_to_logical_key);
+  bool is_physical_down = event->type == GDK_KEY_PRESS;
+
+  uint64_t last_logical_record = pressed_logical_for_physical(self->pressing_records, physical_key);
+  uint64_t next_logical_record = is_physical_down ? last_logical_record : 0;
+
+  char* character_to_free = nullptr;
+
+  printf("last %lu next %lu down %d type %d\n", last_logical_record, next_logical_record, is_physical_down, event->type);
+  fflush(stdout);
+
+  FlKeyDatum* base_event = results + 0;
+  base_event->physical = physical_key;
+  base_event->timestamp = event_to_timestamp(event);
+  base_event->synthesized = false;
+
+  if (is_physical_down) {
+    character_to_free = event_to_character(event); // Might be null
+    base_event->character = character_to_free;
+
+    if (last_logical_record) {
+      // GTK doesn't report repeat events separatedly, therefore we can't
+      // distinguish a repeat event from a down event after a missed up event.
+      base_event->kind = kFlKeyDataKindRepeat;
+      base_event->logical = last_logical_record;
+    } else {
+      base_event->kind = kFlKeyDataKindDown;
+      base_event->logical = logical_key;
+    }
+  } else { // is_physical_down false
+    base_event->character = nullptr;
+    base_event->kind = kFlKeyDataKindUp;
+    base_event->logical = logical_key;
+  }
+
+  return 1;
+}
+
+static void fl_keyboard_manager_dispose(GObject* object) {
+  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(object);
+
+  g_clear_pointer(&self->pressing_records, g_hash_table_unref);
+  g_clear_pointer(&self->xkb_to_physical_key, g_hash_table_unref);
+  g_clear_pointer(&self->keyval_to_logical_key, g_hash_table_unref);
+  if (self->character_to_free != nullptr) {
+    g_free(self->character_to_free);
+  }
+
+  G_OBJECT_CLASS(fl_keyboard_manager_parent_class)->dispose(object);
+}
+
+static void fl_keyboard_manager_class_init(FlKeyboardManagerClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = fl_keyboard_manager_dispose;
+}
+
+static void fl_keyboard_manager_init(FlKeyboardManager* self) {
+}
+
+FlKeyboardManager* fl_keyboard_manager_new() {
+  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(
+      g_object_new(fl_keyboard_manager_get_type(), nullptr));
+
+  self->pressing_records = g_hash_table_new(g_direct_hash, g_direct_equal);
+  self->xkb_to_physical_key = g_hash_table_new(g_direct_hash, g_direct_equal);
+  initialize_xkb_to_physical_key(self->xkb_to_physical_key);
+  self->keyval_to_logical_key = g_hash_table_new(g_direct_hash, g_direct_equal);
+  initialize_gtk_keyval_to_logical_key(self->keyval_to_logical_key);
+  self->character_to_free = nullptr;
+
+  return self;
+}

shell/platform/linux/fl_keyboard_manager.h

@@ -0,0 +1,46 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_KEYBOARD_MANAGER_H_
+#define FLUTTER_SHELL_PLATFORM_LINUX_FL_KEYBOARD_MANAGER_H_
+
+#include <gdk/gdk.h>
+#include <stdint.h>
+
+#include "flutter/shell/platform/linux/public/flutter_linux/fl_view.h"
+
+typedef enum {
+  kFlKeyDataKindDown = 0,
+  kFlKeyDataKindUp,
+  kFlKeyDataKindRepeat,
+} FlKeyEventKind;
+
+typedef struct {
+  FlKeyEventKind kind;
+  double timestamp;
+  uint64_t physical;
+  uint64_t logical;
+  const char* character;
+  bool synthesized;
+} FlKeyDatum;
+
+constexpr int kMaxConvertedKeyData = 3;
+
+G_BEGIN_DECLS
+
+G_DECLARE_FINAL_TYPE(FlKeyboardManager,
+                     fl_keyboard_manager,
+                     FL,
+                     KEYBOARD_MANAGER,
+                     GObject);
+
+FlKeyboardManager* fl_keyboard_manager_new();
+
+size_t fl_keyboard_manager_convert_key_event(FlKeyboardManager* self,
+                                             const GdkEventKey* event,
+                                             FlKeyDatum* results);
+
+G_END_DECLS
+
+#endif  // FLUTTER_SHELL_PLATFORM_LINUX_FL_KEYBOARD_MANAGER_H_

shell/platform/linux/fl_keyboard_manager_test.cc

@@ -0,0 +1,55 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/fl_keyboard_manager.h"
+
+#include <iostream>
+#include "gtest/gtest.h"
+
+#include "flutter/shell/platform/linux/fl_engine_private.h"
+#include "flutter/shell/platform/linux/testing/fl_test.h"
+#include "flutter/shell/platform/linux/testing/mock_renderer.h"
+
+static void expect_key_datum_eq(const FlKeyDatum& data, const FlKeyDatum& target) {
+  EXPECT_EQ(data.kind, target.kind);
+  EXPECT_EQ(data.physical, target.physical);
+  EXPECT_EQ(data.logical, target.logical);
+  EXPECT_EQ(data.timestamp, target.timestamp);
+  EXPECT_STREQ(data.character, target.character);
+  EXPECT_EQ(data.synthesized, target.synthesized);
+}
+
+// Test sending a letter "a";
+TEST(FlKeyboardManagerTest, SendKeyEvent) {
+  g_autoptr(FlKeyboardManager) manager = fl_keyboard_manager_new();
+  FlKeyDatum physical_data[kMaxConvertedKeyData];
+  size_t result_size;
+
+  char string[] = "a";
+  GdkEventKey key_event = GdkEventKey{
+      GDK_KEY_PRESS,                         // event type
+      nullptr,                               // window (not needed)
+      FALSE,                                 // event was sent explicitly
+      12345,                                 // time
+      0x0,                                   // modifier state
+      GDK_KEY_a,                             // key code
+      1,                                     // length of string representation
+      reinterpret_cast<gchar*>(&string[0]),  // string representation
+      0x026,                                 // scan code
+      0,                                     // keyboard group
+      0,                                     // is a modifier
+  };
+
+  result_size = fl_keyboard_manager_convert_key_event(manager, &key_event, physical_data);
+
+  EXPECT_EQ(result_size, 1u);
+  expect_key_datum_eq(physical_data[0], FlKeyDatum{
+    kFlKeyDataKindDown,       // kind
+    12345000.0,               // timestamp
+    0x00070004,               // physical
+    0x00000061,               // logical
+    "a",                      // character
+    false,                    // synthesized
+  });
+}