[Linux, Keyboard] Derive keyboard layout using printable information from system (flutter#32665)

* Workable layout deduction

* Compilable test

* Tests

* Remove print, format

* Use new way to pass logical key

* Use unique_ptr

* Format

* Fix matrix format

* Format

* Cleanup

* Remove duplicate

* Remove printf

* Update shell/platform/linux/fl_keyboard_manager.cc

Co-authored-by: Greg Spencer <gspencergoog@users.noreply.github.com>

Co-authored-by: Greg Spencer <gspencergoog@users.noreply.github.com>

Author: dkwingsmt

shell/platform/darwin/macos/framework/Source/FlutterKeyboardManager.mm

@@ -283,7 +283,7 @@ - (void)buildLayout {
     //
     //  - Mandatory goal, if it matches any clue. This ensures that all alnum
     //    keys can be found somewhere.
-    //  - US layout, if neither clue of the key is EASCII.  This ensures that
+    //  - US layout, if neither clue of the key is EASCII. This ensures that
     //    there are no non-latin logical keys.
     //  - Derived on the fly from keyCode & characters.
     for (const LayoutClue& clue : thisKeyClues) {

shell/platform/embedder/test_utils/key_codes.h

@@ -35,6 +35,7 @@ constexpr uint64_t kPhysicalSuspend = 0x00000014;
 constexpr uint64_t kPhysicalResume = 0x00000015;
 constexpr uint64_t kPhysicalTurbo = 0x00000016;
 constexpr uint64_t kPhysicalPrivacyScreenToggle = 0x00000017;
+constexpr uint64_t kPhysicalMicrophoneMuteToggle = 0x00000018;
 constexpr uint64_t kPhysicalSleep = 0x00010082;
 constexpr uint64_t kPhysicalWakeUp = 0x00010083;
 constexpr uint64_t kPhysicalDisplayToggleIntExt = 0x000100b5;

shell/platform/linux/fl_key_channel_responder.cc

@@ -19,6 +19,7 @@ static constexpr char kKeyCodeKey[] = "keyCode";
 static constexpr char kScanCodeKey[] = "scanCode";
 static constexpr char kModifiersKey[] = "modifiers";
 static constexpr char kToolkitKey[] = "toolkit";
+static constexpr char kSpecifiedLogicalKey[] = "specifiedLogicalKey";
 static constexpr char kUnicodeScalarValuesKey[] = "unicodeScalarValues";
 
 static constexpr char kGtkToolkit[] = "gtk";
@@ -115,6 +116,7 @@ G_DEFINE_TYPE_WITH_CODE(
 static void fl_key_channel_responder_handle_event(
     FlKeyResponder* responder,
     FlKeyEvent* event,
+    uint64_t specified_logical_key,
     FlKeyResponderAsyncCallback callback,
     gpointer user_data);
 
@@ -203,6 +205,7 @@ FlKeyChannelResponder* fl_key_channel_responder_new(
 static void fl_key_channel_responder_handle_event(
     FlKeyResponder* responder,
     FlKeyEvent* event,
+    uint64_t specified_logical_key,
     FlKeyResponderAsyncCallback callback,
     gpointer user_data) {
   FlKeyChannelResponder* self = FL_KEY_CHANNEL_RESPONDER(responder);
@@ -273,6 +276,11 @@ static void fl_key_channel_responder_handle_event(
                              fl_value_new_int(unicode_scarlar_values));
   }
 
+  if (specified_logical_key != 0) {
+    fl_value_set_string_take(message, kSpecifiedLogicalKey,
+                             fl_value_new_int(specified_logical_key));
+  }
+
   FlKeyChannelUserData* data =
       fl_key_channel_user_data_new(self, callback, user_data);
   // Send the message off to the framework for handling (or not).

shell/platform/linux/fl_key_channel_responder_test.cc

@@ -203,3 +203,30 @@ TEST(FlKeyChannelResponderTest, TestKeyEventHandledByFramework) {
   // Blocks here until echo_response_cb is called.
   g_main_loop_run(loop);
 }
+
+TEST(FlKeyChannelResponderTest, UseSpecifiedLogicalKey) {
+  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
+
+  g_autoptr(FlEngine) engine = make_mock_engine();
+  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
+  FlKeyChannelResponderMock mock{
+      .value_converter = echo_response_cb,
+      .channel_name = "test/echo",
+  };
+  g_autoptr(FlKeyResponder) responder =
+      FL_KEY_RESPONDER(fl_key_channel_responder_new(messenger, &mock));
+
+  fl_key_responder_handle_event(
+      responder,
+      fl_key_event_new_by_mock(12345, true, GDK_KEY_A, 0x04, 0x0, nullptr,
+                               false),
+      responder_callback, loop, 888);
+  expected_handled = TRUE;
+  expected_value =
+      "{type: keydown, keymap: linux, scanCode: 4, toolkit: gtk, "
+      "keyCode: 65, modifiers: 0, unicodeScalarValues: 65, "
+      "specifiedLogicalKey: 888}";
+
+  // Blocks here until echo_response_cb is called.
+  g_main_loop_run(loop);
+}

shell/platform/linux/fl_key_embedder_responder.cc

@@ -212,6 +212,7 @@ G_DEFINE_TYPE_WITH_CODE(
 static void fl_key_embedder_responder_handle_event(
     FlKeyResponder* responder,
     FlKeyEvent* event,
+    uint64_t specified_logical_key,
     FlKeyResponderAsyncCallback callback,
     gpointer user_data);
 
@@ -698,6 +699,7 @@ static void synchronize_lock_states_loop_body(gpointer key,
 static void fl_key_embedder_responder_handle_event_impl(
     FlKeyResponder* responder,
     FlKeyEvent* event,
+    uint64_t specified_logical_key,
     FlKeyResponderAsyncCallback callback,
     gpointer user_data) {
   FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(responder);
@@ -706,7 +708,9 @@ static void fl_key_embedder_responder_handle_event_impl(
   g_return_if_fail(callback != nullptr);
 
   const uint64_t physical_key = event_to_physical_key(event);
-  const uint64_t logical_key = event_to_logical_key(event);
+  const uint64_t logical_key = specified_logical_key != 0
+                                   ? specified_logical_key
+                                   : event_to_logical_key(event);
   const double timestamp = event_to_timestamp(event);
   const bool is_down_event = event->is_press;
 
@@ -777,12 +781,13 @@ static void fl_key_embedder_responder_handle_event_impl(
 static void fl_key_embedder_responder_handle_event(
     FlKeyResponder* responder,
     FlKeyEvent* event,
+    uint64_t specified_logical_key,
     FlKeyResponderAsyncCallback callback,
     gpointer user_data) {
   FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(responder);
   self->sent_any_events = false;
-  fl_key_embedder_responder_handle_event_impl(responder, event, callback,
-                                              user_data);
+  fl_key_embedder_responder_handle_event_impl(
+      responder, event, specified_logical_key, callback, user_data);
   if (!self->sent_any_events) {
     self->send_key_event(&empty_event, nullptr, nullptr);
   }

shell/platform/linux/fl_key_embedder_responder_test.cc

@@ -194,8 +194,6 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) {
   invoke_record_callback_and_verify(record, TRUE, &user_data);
   g_ptr_array_clear(g_call_records);
 
-  // Skip testing key repeats, which is not present on GDK.
-
   // Key up
   fl_key_responder_handle_event(
       responder,
@@ -261,6 +259,41 @@ TEST(FlKeyEmbedderResponderTest, SendKeyEvent) {
   g_object_unref(responder);
 }
 
+// Basic key presses, but uses the specified logical key if it is not 0.
+TEST(FlKeyEmbedderResponderTest, UsesSpecifiedLogicalKey) {
+  EXPECT_EQ(g_call_records, nullptr);
+  g_call_records = g_ptr_array_new_with_free_func(g_object_unref);
+  FlKeyResponder* responder = FL_KEY_RESPONDER(
+      fl_key_embedder_responder_new(record_calls_in(g_call_records)));
+  int user_data = 123;  // Arbitrary user data
+
+  FlKeyEmbedderCallRecord* record;
+
+  // On an AZERTY keyboard, press physical key 1, and release.
+  // Key down
+  fl_key_responder_handle_event(
+      responder,
+      fl_key_event_new_by_mock(12345, kPress, GDK_KEY_ampersand, kKeyCodeDigit1,
+                               0, kIsNotModifier),
+      verify_response_handled, &user_data, kLogicalDigit1);
+
+  EXPECT_EQ(g_call_records->len, 1u);
+  record = FL_KEY_EMBEDDER_CALL_RECORD(g_ptr_array_index(g_call_records, 0));
+  EXPECT_EQ(record->event->struct_size, sizeof(FlutterKeyEvent));
+  EXPECT_EQ(record->event->timestamp, 12345000);
+  EXPECT_EQ(record->event->type, kFlutterKeyEventTypeDown);
+  EXPECT_EQ(record->event->physical, kPhysicalDigit1);
+  EXPECT_EQ(record->event->logical, kLogicalDigit1);
+  EXPECT_STREQ(record->event->character, "&");
+  EXPECT_EQ(record->event->synthesized, false);
+
+  invoke_record_callback_and_verify(record, TRUE, &user_data);
+  g_ptr_array_clear(g_call_records);
+
+  clear_g_call_records();
+  g_object_unref(responder);
+}
+
 // Press Shift, key A, then release Shift, key A.
 TEST(FlKeyEmbedderResponderTest, PressShiftDuringLetterKeyTap) {
   EXPECT_EQ(g_call_records, nullptr);

shell/platform/linux/fl_key_event.cc

@@ -33,6 +33,7 @@ FlKeyEvent* fl_key_event_new_from_gdk_event(GdkEvent* raw_event) {
   result->keyval = event->keyval;
   result->state = event->state;
   result->string = clone_string(event->string);
+  result->group = event->group;
   result->origin = event;
   result->dispose_origin = dispose_origin_from_gdk_event;
 

shell/platform/linux/fl_key_event.h

@@ -39,6 +39,8 @@ typedef struct _FlKeyEvent {
   guint keyval;
   // Modifier state.
   int state;
+  // Keyboard group.
+  guint8 group;
   // String, null-terminated.
   //
   // Can be nullptr.

shell/platform/linux/fl_key_responder.cc

@@ -11,11 +11,12 @@ static void fl_key_responder_default_init(FlKeyResponderInterface* iface) {}
 void fl_key_responder_handle_event(FlKeyResponder* self,
                                    FlKeyEvent* event,
                                    FlKeyResponderAsyncCallback callback,
-                                   gpointer user_data) {
+                                   gpointer user_data,
+                                   uint64_t specified_logical_key) {
   g_return_if_fail(FL_IS_KEY_RESPONDER(self));
   g_return_if_fail(event != nullptr);
   g_return_if_fail(callback != nullptr);
 
-  FL_KEY_RESPONDER_GET_IFACE(self)->handle_event(self, event, callback,
-                                                 user_data);
+  FL_KEY_RESPONDER_GET_IFACE(self)->handle_event(
+      self, event, specified_logical_key, callback, user_data);
 }

shell/platform/linux/fl_key_responder.h

@@ -53,6 +53,7 @@ struct _FlKeyResponderInterface {
    */
   void (*handle_event)(FlKeyResponder* responder,
                        FlKeyEvent* event,
+                       uint64_t specified_logical_key,
                        FlKeyResponderAsyncCallback callback,
                        gpointer user_data);
 };
@@ -74,7 +75,8 @@ struct _FlKeyResponderInterface {
 void fl_key_responder_handle_event(FlKeyResponder* responder,
                                    FlKeyEvent* event,
                                    FlKeyResponderAsyncCallback callback,
-                                   gpointer user_data);
+                                   gpointer user_data,
+                                   uint64_t specified_logical_key = 0);
 
 G_END_DECLS