shell/platform/linux/fl_key_event_plugin.cc - external/github.com/flutter/engine - Git at Google

 // 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_key_event_plugin.h"
 #include "flutter/shell/platform/linux/fl_key_event_plugin_private.h"

 #include <gtk/gtk.h>
 #include <cinttypes>

 #include "flutter/shell/platform/linux/fl_text_input_plugin.h"
 #include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
 #include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"

 static constexpr char kChannelName[] = "flutter/keyevent";
 static constexpr char kTypeKey[] = "type";
 static constexpr char kTypeValueUp[] = "keyup";
 static constexpr char kTypeValueDown[] = "keydown";
 static constexpr char kKeymapKey[] = "keymap";
 static constexpr char kKeyCodeKey[] = "keyCode";
 static constexpr char kScanCodeKey[] = "scanCode";
 static constexpr char kModifiersKey[] = "modifiers";
 static constexpr char kToolkitKey[] = "toolkit";
 static constexpr char kUnicodeScalarValuesKey[] = "unicodeScalarValues";

 static constexpr char kGtkToolkit[] = "gtk";
 static constexpr char kLinuxKeymap[] = "linux";

 static constexpr uint64_t kMaxPendingEvents = 1000;

 // Definition of the FlKeyEventPlugin GObject class.

 struct _FlKeyEventPlugin {
   GObject parent_instance;

   FlBasicMessageChannel* channel = nullptr;
   FlTextInputPlugin* text_input_plugin = nullptr;
   FlKeyEventPluginCallback response_callback = nullptr;
   GPtrArray* pending_events;
 };

 G_DEFINE_TYPE(FlKeyEventPlugin, fl_key_event_plugin, G_TYPE_OBJECT)

 // Declare and define a private pair object to bind the id and the event
 // together.

 G_DECLARE_FINAL_TYPE(FlKeyEventPair,
                      fl_key_event_pair,
                      FL,
                      KEY_EVENT_PAIR,
                      GObject);

 struct _FlKeyEventPair {
   GObject parent_instance;

   uint64_t id;
   GdkEventKey* event;
 };

 G_DEFINE_TYPE(FlKeyEventPair, fl_key_event_pair, G_TYPE_OBJECT)

 // Dispose method for FlKeyEventPair.
 static void fl_key_event_pair_dispose(GObject* object) {
   // Redundant, but added so that we don't get a warning about unused function
   // for FL_IS_KEY_EVENT_PAIR.
   g_return_if_fail(FL_IS_KEY_EVENT_PAIR(object));

   FlKeyEventPair* self = FL_KEY_EVENT_PAIR(object);
   g_clear_pointer(&self->event, gdk_event_free);
   G_OBJECT_CLASS(fl_key_event_pair_parent_class)->dispose(object);
 }

 // Class Initialization method for FlKeyEventPair class.
 static void fl_key_event_pair_class_init(FlKeyEventPairClass* klass) {
   G_OBJECT_CLASS(klass)->dispose = fl_key_event_pair_dispose;
 }

 // Initialization for FlKeyEventPair instances.
 static void fl_key_event_pair_init(FlKeyEventPair* self) {}

 // Creates a new FlKeyEventPair instance, given a unique ID, and an event struct
 // to keep.
 FlKeyEventPair* fl_key_event_pair_new(uint64_t id, GdkEventKey* event) {
   FlKeyEventPair* self =
       FL_KEY_EVENT_PAIR(g_object_new(fl_key_event_pair_get_type(), nullptr));

   // Copy the event to preserve refcounts for referenced values (mainly the
   // window).
   GdkEventKey* event_copy = reinterpret_cast<GdkEventKey*>(
       gdk_event_copy(reinterpret_cast<GdkEvent*>(event)));
   self->id = id;
   self->event = event_copy;
   return self;
 }

 // Declare and define a private class to hold response data from the framework.
 G_DECLARE_FINAL_TYPE(FlKeyEventResponseData,
                      fl_key_event_response_data,
                      FL,
                      KEY_EVENT_RESPONSE_DATA,
                      GObject);

 struct _FlKeyEventResponseData {
   GObject parent_instance;

   FlKeyEventPlugin* plugin;
   uint64_t id;
   gpointer user_data;
 };

 // Definition for FlKeyEventResponseData private class.
 G_DEFINE_TYPE(FlKeyEventResponseData, fl_key_event_response_data, G_TYPE_OBJECT)

 // Dispose method for FlKeyEventResponseData private class.
 static void fl_key_event_response_data_dispose(GObject* object) {
   g_return_if_fail(FL_IS_KEY_EVENT_RESPONSE_DATA(object));
   FlKeyEventResponseData* self = FL_KEY_EVENT_RESPONSE_DATA(object);
   if (self->plugin != nullptr) {
     g_object_remove_weak_pointer(G_OBJECT(self->plugin),
                                  reinterpret_cast<gpointer*>(&(self->plugin)));
     self->plugin = nullptr;
   }
 }

 // Class initialization method for FlKeyEventResponseData private class.
 static void fl_key_event_response_data_class_init(
     FlKeyEventResponseDataClass* klass) {
   G_OBJECT_CLASS(klass)->dispose = fl_key_event_response_data_dispose;
 }

 // Instance initialization method for FlKeyEventResponseData private class.
 static void fl_key_event_response_data_init(FlKeyEventResponseData* self) {}

 // Creates a new FlKeyEventResponseData private class with a plugin that created
 // the request, a unique ID for tracking, and optional user data.
 // Will keep a weak pointer to the plugin.
 FlKeyEventResponseData* fl_key_event_response_data_new(FlKeyEventPlugin* plugin,
                                                        uint64_t id,
                                                        gpointer user_data) {
   FlKeyEventResponseData* self = FL_KEY_EVENT_RESPONSE_DATA(
       g_object_new(fl_key_event_response_data_get_type(), nullptr));

   self->plugin = plugin;
   // Add a weak pointer so we can know if the key event plugin disappeared
   // while the framework was responding.
   g_object_add_weak_pointer(G_OBJECT(plugin),
                             reinterpret_cast<gpointer*>(&(self->plugin)));
   self->id = id;
   self->user_data = user_data;
   return self;
 }

 // Calculates a unique ID for a given GdkEventKey object to use for
 // identification of responses from the framework.
 uint64_t fl_key_event_plugin_get_event_id(GdkEventKey* event) {
   // Combine the event timestamp, the type of event, and the hardware keycode
   // (scan code) of the event to come up with a unique id for this event that
   // can be derived solely from the event data itself, so that we can identify
   // whether or not we have seen this event already.
   return (event->time & 0xffffffff) |
          (static_cast<uint64_t>(event->type) & 0xffff) << 32 |
          (static_cast<uint64_t>(event->hardware_keycode) & 0xffff) << 48;
 }

 // Finds an event in the event queue that was sent to the framework by its ID.
 GdkEventKey* fl_key_event_plugin_find_pending_event(FlKeyEventPlugin* self,
                                                     uint64_t id) {
   for (guint i = 0; i < self->pending_events->len; ++i) {
     if (FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))->id ==
         id) {
       return FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))
           ->event;
     }
   }
   return nullptr;
 }

 // Removes an event from the pending event queue.
 static void remove_pending_event(FlKeyEventPlugin* self, uint64_t id) {
   for (guint i = 0; i < self->pending_events->len; ++i) {
     if (FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))->id ==
         id) {
       g_ptr_array_remove_index(self->pending_events, i);
       return;
     }
   }
   g_warning("Tried to remove pending event with id %" PRIu64
             ", but the event was not found.",
             id);
 }

 // Adds an GdkEventKey to the pending event queue, with a unique ID, and the
 // plugin that added it.
 static void add_pending_event(FlKeyEventPlugin* self,
                               uint64_t id,
                               GdkEventKey* event) {
   if (self->pending_events->len > kMaxPendingEvents) {
     g_warning(
         "There are %d keyboard events that have not yet received a "
         "response from the framework. Are responses being sent?",
         self->pending_events->len);
   }
   g_ptr_array_add(self->pending_events, fl_key_event_pair_new(id, event));
 }

 // Handles a response from the framework to a key event sent to the framework
 // earlier.
 static void handle_response(GObject* object,
                             GAsyncResult* result,
                             gpointer user_data) {
   g_autoptr(FlKeyEventResponseData) data =
       FL_KEY_EVENT_RESPONSE_DATA(user_data);

   // Will also return if the weak pointer has been destroyed.
   if (data->plugin == nullptr) {
     return;
   }

   FlKeyEventPlugin* self = data->plugin;

   g_autoptr(GError) error = nullptr;
   FlBasicMessageChannel* messageChannel = FL_BASIC_MESSAGE_CHANNEL(object);
   FlValue* message =
       fl_basic_message_channel_send_finish(messageChannel, result, &error);
   if (error != nullptr) {
     g_warning("Unable to retrieve framework response: %s", error->message);
     return;
   }
   g_autoptr(FlValue) handled_value = fl_value_lookup_string(message, "handled");
   bool handled = FALSE;
   if (handled_value != nullptr) {
     GdkEventKey* event = fl_key_event_plugin_find_pending_event(self, data->id);
     if (event == nullptr) {
       g_warning("Event response for event id %" PRIu64
                 " received, but pending event was not found.",
                 data->id);
     } else {
       handled = fl_value_get_bool(handled_value);
       if (!handled) {
         if (self->text_input_plugin != nullptr) {
           // Propagate the event to the text input plugin.
           handled = fl_text_input_plugin_filter_keypress(
               self->text_input_plugin, event);
         }
         // Dispatch the event to other GTK windows if the text input plugin
         // didn't handle it. We keep track of the event id so we can recognize
         // the event when our window receives it again and not respond to it. If
         // the response callback is set, then use that instead.
         if (!handled && self->response_callback == nullptr) {
           gdk_event_put(reinterpret_cast<GdkEvent*>(event));
         }
       }
     }
   }

   if (handled) {
     // Because the event was handled, we no longer need to track it. Unhandled
     // events will be removed when the event is re-dispatched to the window.
     remove_pending_event(self, data->id);
   }

   if (self->response_callback != nullptr) {
     self->response_callback(object, message, handled, data->user_data);
   }
 }

 // Disposes of an FlKeyEventPlugin instance.
 static void fl_key_event_plugin_dispose(GObject* object) {
   FlKeyEventPlugin* self = FL_KEY_EVENT_PLUGIN(object);

   g_clear_object(&self->channel);
   if (self->text_input_plugin != nullptr) {
     g_object_remove_weak_pointer(
         G_OBJECT(self->text_input_plugin),
         reinterpret_cast<gpointer*>(&(self->text_input_plugin)));
     self->text_input_plugin = nullptr;
   }
   g_ptr_array_free(self->pending_events, TRUE);

   G_OBJECT_CLASS(fl_key_event_plugin_parent_class)->dispose(object);
 }

 // Initializes the FlKeyEventPlugin class methods.
 static void fl_key_event_plugin_class_init(FlKeyEventPluginClass* klass) {
   G_OBJECT_CLASS(klass)->dispose = fl_key_event_plugin_dispose;
 }

 // Initializes an FlKeyEventPlugin instance.
 static void fl_key_event_plugin_init(FlKeyEventPlugin* self) {}

 // Creates a new FlKeyEventPlugin instance, with a messenger used to send
 // messages to the framework, an FlTextInputPlugin used to handle key events
 // that the framework doesn't handle. Mainly for testing purposes, it also takes
 // an optional callback to call when a response is received, and an optional
 // channel name to use when sending messages.
 FlKeyEventPlugin* fl_key_event_plugin_new(
     FlBinaryMessenger* messenger,
     FlTextInputPlugin* text_input_plugin,
     FlKeyEventPluginCallback response_callback,
     const char* channel_name) {
   g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
   g_return_val_if_fail(FL_IS_TEXT_INPUT_PLUGIN(text_input_plugin), nullptr);

   FlKeyEventPlugin* self = FL_KEY_EVENT_PLUGIN(
       g_object_new(fl_key_event_plugin_get_type(), nullptr));

   g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
   self->channel = fl_basic_message_channel_new(
       messenger, channel_name == nullptr ? kChannelName : channel_name,
       FL_MESSAGE_CODEC(codec));
   self->response_callback = response_callback;
   // Add a weak pointer so we know if the text input plugin goes away.
   g_object_add_weak_pointer(
       G_OBJECT(text_input_plugin),
       reinterpret_cast<gpointer*>(&(self->text_input_plugin)));
   self->text_input_plugin = text_input_plugin;

   self->pending_events = g_ptr_array_new_with_free_func(g_object_unref);
   return self;
 }

 // Sends a key event to the framework.
 bool fl_key_event_plugin_send_key_event(FlKeyEventPlugin* self,
                                         GdkEventKey* event,
                                         gpointer user_data) {
   g_return_val_if_fail(FL_IS_KEY_EVENT_PLUGIN(self), FALSE);
   g_return_val_if_fail(event != nullptr, FALSE);

   // Get an ID for the event, so we can match them up when we get a response
   // from the framework. Use the event time, type, and hardware keycode as a
   // unique ID, since they are part of the event structure that we can look up
   // when we receive a random event that may or may not have been
   // tracked/produced by this code.
   uint64_t id = fl_key_event_plugin_get_event_id(event);
   if (self->pending_events->len != 0 &&
       fl_key_event_plugin_find_pending_event(self, id) != nullptr) {
     // If the event is in the queue of pending events we've seen, then we know
     // that this is a re-dispatched event, and we shouldn't respond to it, but
     // we should remove it from tracking.
     remove_pending_event(self, id);
     return FALSE;
   }

   const gchar* type;
   switch (event->type) {
     case GDK_KEY_PRESS:
       type = kTypeValueDown;
       break;
     case GDK_KEY_RELEASE:
       type = kTypeValueUp;
       break;
     default:
       return FALSE;
   }

   int64_t scan_code = event->hardware_keycode;
   int64_t unicodeScalarValues = gdk_keyval_to_unicode(event->keyval);

   // For most modifier keys, GTK keeps track of the "pressed" state of the
   // modifier keys. Flutter uses this information to keep modifier keys from
   // being "stuck" when a key-up event is lost because it happens after the app
   // loses focus.
   //
   // For Lock keys (ShiftLock, CapsLock, NumLock), however, GTK keeps track of
   // the state of the locks themselves, not the "pressed" state of the key.
   //
   // Since Flutter expects the "pressed" state of the modifier keys, the lock
   // state for these keys is discarded here, and it is substituted for the
   // pressed state of the key.
   //
   // This code has the flaw that if a key event is missed due to the app losing
   // focus, then this state will still think the key is pressed when it isn't,
   // but that is no worse than for "regular" keys until we implement the
   // sync/cancel events on app focus changes.
   //
   // This is necessary to do here instead of in the framework because Flutter
   // does modifier key syncing in the framework, and will turn on/off these keys
   // as being "pressed" whenever the lock is on, which breaks a lot of
   // interactions (for example, if shift-lock is on, tab traversal is broken).
   //
   // TODO(gspencergoog): get rid of this tracked state when we are tracking the
   // state of all keys and sending sync/cancel events when focus is gained/lost.

   // Remove lock states from state mask.
   guint state = event->state & ~(GDK_LOCK_MASK | GDK_MOD2_MASK);

   static bool shift_lock_pressed = FALSE;
   static bool caps_lock_pressed = FALSE;
   static bool num_lock_pressed = FALSE;
   switch (event->keyval) {
     case GDK_KEY_Num_Lock:
       num_lock_pressed = event->type == GDK_KEY_PRESS;
       break;
     case GDK_KEY_Caps_Lock:
       caps_lock_pressed = event->type == GDK_KEY_PRESS;
       break;
     case GDK_KEY_Shift_Lock:
       shift_lock_pressed = event->type == GDK_KEY_PRESS;
       break;
   }

   // Add back in the state matching the actual pressed state of the lock keys,
   // not the lock states.
   state |= (shift_lock_pressed || caps_lock_pressed) ? GDK_LOCK_MASK : 0x0;
   state |= num_lock_pressed ? GDK_MOD2_MASK : 0x0;

   g_autoptr(FlValue) message = fl_value_new_map();
   fl_value_set_string_take(message, kTypeKey, fl_value_new_string(type));
   fl_value_set_string_take(message, kKeymapKey,
                            fl_value_new_string(kLinuxKeymap));
   fl_value_set_string_take(message, kScanCodeKey, fl_value_new_int(scan_code));
   fl_value_set_string_take(message, kToolkitKey,
                            fl_value_new_string(kGtkToolkit));
   fl_value_set_string_take(message, kKeyCodeKey,
                            fl_value_new_int(event->keyval));
   fl_value_set_string_take(message, kModifiersKey, fl_value_new_int(state));
   if (unicodeScalarValues != 0) {
     fl_value_set_string_take(message, kUnicodeScalarValuesKey,
                              fl_value_new_int(unicodeScalarValues));
   }

   // Track the event as pending a response from the framework.
   add_pending_event(self, id, event);
   FlKeyEventResponseData* data =
       fl_key_event_response_data_new(self, id, user_data);
   // Send the message off to the framework for handling (or not).
   fl_basic_message_channel_send(self->channel, message, nullptr,
                                 handle_response, data);
   // Return true before we know what the framework will do, because if it
   // doesn't handle the key, we'll re-dispatch it later.
   return TRUE;
 }
	// 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_key_event_plugin.h"
	#include "flutter/shell/platform/linux/fl_key_event_plugin_private.h"

	#include <gtk/gtk.h>
	#include <cinttypes>

	#include "flutter/shell/platform/linux/fl_text_input_plugin.h"
	#include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
	#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"

	static constexpr char kChannelName[] = "flutter/keyevent";
	static constexpr char kTypeKey[] = "type";
	static constexpr char kTypeValueUp[] = "keyup";
	static constexpr char kTypeValueDown[] = "keydown";
	static constexpr char kKeymapKey[] = "keymap";
	static constexpr char kKeyCodeKey[] = "keyCode";
	static constexpr char kScanCodeKey[] = "scanCode";
	static constexpr char kModifiersKey[] = "modifiers";
	static constexpr char kToolkitKey[] = "toolkit";
	static constexpr char kUnicodeScalarValuesKey[] = "unicodeScalarValues";

	static constexpr char kGtkToolkit[] = "gtk";
	static constexpr char kLinuxKeymap[] = "linux";

	static constexpr uint64_t kMaxPendingEvents = 1000;

	// Definition of the FlKeyEventPlugin GObject class.

	struct _FlKeyEventPlugin {
	GObject parent_instance;

	FlBasicMessageChannel* channel = nullptr;
	FlTextInputPlugin* text_input_plugin = nullptr;
	FlKeyEventPluginCallback response_callback = nullptr;
	GPtrArray* pending_events;
	};

	G_DEFINE_TYPE(FlKeyEventPlugin, fl_key_event_plugin, G_TYPE_OBJECT)

	// Declare and define a private pair object to bind the id and the event
	// together.

	G_DECLARE_FINAL_TYPE(FlKeyEventPair,
	fl_key_event_pair,
	FL,
	KEY_EVENT_PAIR,
	GObject);

	struct _FlKeyEventPair {
	GObject parent_instance;

	uint64_t id;
	GdkEventKey* event;
	};

	G_DEFINE_TYPE(FlKeyEventPair, fl_key_event_pair, G_TYPE_OBJECT)

	// Dispose method for FlKeyEventPair.
	static void fl_key_event_pair_dispose(GObject* object) {
	// Redundant, but added so that we don't get a warning about unused function
	// for FL_IS_KEY_EVENT_PAIR.
	g_return_if_fail(FL_IS_KEY_EVENT_PAIR(object));

	FlKeyEventPair* self = FL_KEY_EVENT_PAIR(object);
	g_clear_pointer(&self->event, gdk_event_free);
	G_OBJECT_CLASS(fl_key_event_pair_parent_class)->dispose(object);
	}

	// Class Initialization method for FlKeyEventPair class.
	static void fl_key_event_pair_class_init(FlKeyEventPairClass* klass) {
	G_OBJECT_CLASS(klass)->dispose = fl_key_event_pair_dispose;
	}

	// Initialization for FlKeyEventPair instances.
	static void fl_key_event_pair_init(FlKeyEventPair* self) {}

	// Creates a new FlKeyEventPair instance, given a unique ID, and an event struct
	// to keep.
	FlKeyEventPair* fl_key_event_pair_new(uint64_t id, GdkEventKey* event) {
	FlKeyEventPair* self =
	FL_KEY_EVENT_PAIR(g_object_new(fl_key_event_pair_get_type(), nullptr));

	// Copy the event to preserve refcounts for referenced values (mainly the
	// window).
	GdkEventKey* event_copy = reinterpret_cast<GdkEventKey*>(
	gdk_event_copy(reinterpret_cast<GdkEvent*>(event)));
	self->id = id;
	self->event = event_copy;
	return self;
	}

	// Declare and define a private class to hold response data from the framework.
	G_DECLARE_FINAL_TYPE(FlKeyEventResponseData,
	fl_key_event_response_data,
	FL,
	KEY_EVENT_RESPONSE_DATA,
	GObject);

	struct _FlKeyEventResponseData {
	GObject parent_instance;

	FlKeyEventPlugin* plugin;
	uint64_t id;
	gpointer user_data;
	};

	// Definition for FlKeyEventResponseData private class.
	G_DEFINE_TYPE(FlKeyEventResponseData, fl_key_event_response_data, G_TYPE_OBJECT)

	// Dispose method for FlKeyEventResponseData private class.
	static void fl_key_event_response_data_dispose(GObject* object) {
	g_return_if_fail(FL_IS_KEY_EVENT_RESPONSE_DATA(object));
	FlKeyEventResponseData* self = FL_KEY_EVENT_RESPONSE_DATA(object);
	if (self->plugin != nullptr) {
	g_object_remove_weak_pointer(G_OBJECT(self->plugin),
	reinterpret_cast<gpointer*>(&(self->plugin)));
	self->plugin = nullptr;
	}
	}

	// Class initialization method for FlKeyEventResponseData private class.
	static void fl_key_event_response_data_class_init(
	FlKeyEventResponseDataClass* klass) {
	G_OBJECT_CLASS(klass)->dispose = fl_key_event_response_data_dispose;
	}

	// Instance initialization method for FlKeyEventResponseData private class.
	static void fl_key_event_response_data_init(FlKeyEventResponseData* self) {}

	// Creates a new FlKeyEventResponseData private class with a plugin that created
	// the request, a unique ID for tracking, and optional user data.
	// Will keep a weak pointer to the plugin.
	FlKeyEventResponseData* fl_key_event_response_data_new(FlKeyEventPlugin* plugin,
	uint64_t id,
	gpointer user_data) {
	FlKeyEventResponseData* self = FL_KEY_EVENT_RESPONSE_DATA(
	g_object_new(fl_key_event_response_data_get_type(), nullptr));

	self->plugin = plugin;
	// Add a weak pointer so we can know if the key event plugin disappeared
	// while the framework was responding.
	g_object_add_weak_pointer(G_OBJECT(plugin),
	reinterpret_cast<gpointer*>(&(self->plugin)));
	self->id = id;
	self->user_data = user_data;
	return self;
	}

	// Calculates a unique ID for a given GdkEventKey object to use for
	// identification of responses from the framework.
	uint64_t fl_key_event_plugin_get_event_id(GdkEventKey* event) {
	// Combine the event timestamp, the type of event, and the hardware keycode
	// (scan code) of the event to come up with a unique id for this event that
	// can be derived solely from the event data itself, so that we can identify
	// whether or not we have seen this event already.
	return (event->time & 0xffffffff) \|
	(static_cast<uint64_t>(event->type) & 0xffff) << 32 \|
	(static_cast<uint64_t>(event->hardware_keycode) & 0xffff) << 48;
	}

	// Finds an event in the event queue that was sent to the framework by its ID.
	GdkEventKey* fl_key_event_plugin_find_pending_event(FlKeyEventPlugin* self,
	uint64_t id) {
	for (guint i = 0; i < self->pending_events->len; ++i) {
	if (FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))->id ==
	id) {
	return FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))
	->event;
	}
	}
	return nullptr;
	}

	// Removes an event from the pending event queue.
	static void remove_pending_event(FlKeyEventPlugin* self, uint64_t id) {
	for (guint i = 0; i < self->pending_events->len; ++i) {
	if (FL_KEY_EVENT_PAIR(g_ptr_array_index(self->pending_events, i))->id ==
	id) {
	g_ptr_array_remove_index(self->pending_events, i);
	return;
	}
	}
	g_warning("Tried to remove pending event with id %" PRIu64
	", but the event was not found.",
	id);
	}

	// Adds an GdkEventKey to the pending event queue, with a unique ID, and the
	// plugin that added it.
	static void add_pending_event(FlKeyEventPlugin* self,
	uint64_t id,
	GdkEventKey* event) {
	if (self->pending_events->len > kMaxPendingEvents) {
	g_warning(
	"There are %d keyboard events that have not yet received a "
	"response from the framework. Are responses being sent?",
	self->pending_events->len);
	}
	g_ptr_array_add(self->pending_events, fl_key_event_pair_new(id, event));
	}

	// Handles a response from the framework to a key event sent to the framework
	// earlier.
	static void handle_response(GObject* object,
	GAsyncResult* result,
	gpointer user_data) {
	g_autoptr(FlKeyEventResponseData) data =
	FL_KEY_EVENT_RESPONSE_DATA(user_data);

	// Will also return if the weak pointer has been destroyed.
	if (data->plugin == nullptr) {
	return;
	}

	FlKeyEventPlugin* self = data->plugin;

	g_autoptr(GError) error = nullptr;
	FlBasicMessageChannel* messageChannel = FL_BASIC_MESSAGE_CHANNEL(object);
	FlValue* message =
	fl_basic_message_channel_send_finish(messageChannel, result, &error);
	if (error != nullptr) {
	g_warning("Unable to retrieve framework response: %s", error->message);
	return;
	}
	g_autoptr(FlValue) handled_value = fl_value_lookup_string(message, "handled");
	bool handled = FALSE;
	if (handled_value != nullptr) {
	GdkEventKey* event = fl_key_event_plugin_find_pending_event(self, data->id);
	if (event == nullptr) {
	g_warning("Event response for event id %" PRIu64
	" received, but pending event was not found.",
	data->id);
	} else {
	handled = fl_value_get_bool(handled_value);
	if (!handled) {
	if (self->text_input_plugin != nullptr) {
	// Propagate the event to the text input plugin.
	handled = fl_text_input_plugin_filter_keypress(
	self->text_input_plugin, event);
	}
	// Dispatch the event to other GTK windows if the text input plugin
	// didn't handle it. We keep track of the event id so we can recognize
	// the event when our window receives it again and not respond to it. If
	// the response callback is set, then use that instead.
	if (!handled && self->response_callback == nullptr) {
	gdk_event_put(reinterpret_cast<GdkEvent*>(event));
	}
	}
	}
	}

	if (handled) {
	// Because the event was handled, we no longer need to track it. Unhandled
	// events will be removed when the event is re-dispatched to the window.
	remove_pending_event(self, data->id);
	}

	if (self->response_callback != nullptr) {
	self->response_callback(object, message, handled, data->user_data);
	}
	}

	// Disposes of an FlKeyEventPlugin instance.
	static void fl_key_event_plugin_dispose(GObject* object) {
	FlKeyEventPlugin* self = FL_KEY_EVENT_PLUGIN(object);

	g_clear_object(&self->channel);
	if (self->text_input_plugin != nullptr) {
	g_object_remove_weak_pointer(
	G_OBJECT(self->text_input_plugin),
	reinterpret_cast<gpointer*>(&(self->text_input_plugin)));
	self->text_input_plugin = nullptr;
	}
	g_ptr_array_free(self->pending_events, TRUE);

	G_OBJECT_CLASS(fl_key_event_plugin_parent_class)->dispose(object);
	}

	// Initializes the FlKeyEventPlugin class methods.
	static void fl_key_event_plugin_class_init(FlKeyEventPluginClass* klass) {
	G_OBJECT_CLASS(klass)->dispose = fl_key_event_plugin_dispose;
	}

	// Initializes an FlKeyEventPlugin instance.
	static void fl_key_event_plugin_init(FlKeyEventPlugin* self) {}

	// Creates a new FlKeyEventPlugin instance, with a messenger used to send
	// messages to the framework, an FlTextInputPlugin used to handle key events
	// that the framework doesn't handle. Mainly for testing purposes, it also takes
	// an optional callback to call when a response is received, and an optional
	// channel name to use when sending messages.
	FlKeyEventPlugin* fl_key_event_plugin_new(
	FlBinaryMessenger* messenger,
	FlTextInputPlugin* text_input_plugin,
	FlKeyEventPluginCallback response_callback,
	const char* channel_name) {
	g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
	g_return_val_if_fail(FL_IS_TEXT_INPUT_PLUGIN(text_input_plugin), nullptr);

	FlKeyEventPlugin* self = FL_KEY_EVENT_PLUGIN(
	g_object_new(fl_key_event_plugin_get_type(), nullptr));

	g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
	self->channel = fl_basic_message_channel_new(
	messenger, channel_name == nullptr ? kChannelName : channel_name,
	FL_MESSAGE_CODEC(codec));
	self->response_callback = response_callback;
	// Add a weak pointer so we know if the text input plugin goes away.
	g_object_add_weak_pointer(
	G_OBJECT(text_input_plugin),
	reinterpret_cast<gpointer*>(&(self->text_input_plugin)));
	self->text_input_plugin = text_input_plugin;

	self->pending_events = g_ptr_array_new_with_free_func(g_object_unref);
	return self;
	}

	// Sends a key event to the framework.
	bool fl_key_event_plugin_send_key_event(FlKeyEventPlugin* self,
	GdkEventKey* event,
	gpointer user_data) {
	g_return_val_if_fail(FL_IS_KEY_EVENT_PLUGIN(self), FALSE);
	g_return_val_if_fail(event != nullptr, FALSE);

	// Get an ID for the event, so we can match them up when we get a response
	// from the framework. Use the event time, type, and hardware keycode as a
	// unique ID, since they are part of the event structure that we can look up
	// when we receive a random event that may or may not have been
	// tracked/produced by this code.
	uint64_t id = fl_key_event_plugin_get_event_id(event);
	if (self->pending_events->len != 0 &&
	fl_key_event_plugin_find_pending_event(self, id) != nullptr) {
	// If the event is in the queue of pending events we've seen, then we know
	// that this is a re-dispatched event, and we shouldn't respond to it, but
	// we should remove it from tracking.
	remove_pending_event(self, id);
	return FALSE;
	}

	const gchar* type;
	switch (event->type) {
	case GDK_KEY_PRESS:
	type = kTypeValueDown;
	break;
	case GDK_KEY_RELEASE:
	type = kTypeValueUp;
	break;
	default:
	return FALSE;
	}

	int64_t scan_code = event->hardware_keycode;
	int64_t unicodeScalarValues = gdk_keyval_to_unicode(event->keyval);

	// For most modifier keys, GTK keeps track of the "pressed" state of the
	// modifier keys. Flutter uses this information to keep modifier keys from
	// being "stuck" when a key-up event is lost because it happens after the app
	// loses focus.
	//
	// For Lock keys (ShiftLock, CapsLock, NumLock), however, GTK keeps track of
	// the state of the locks themselves, not the "pressed" state of the key.
	//
	// Since Flutter expects the "pressed" state of the modifier keys, the lock
	// state for these keys is discarded here, and it is substituted for the
	// pressed state of the key.
	//
	// This code has the flaw that if a key event is missed due to the app losing
	// focus, then this state will still think the key is pressed when it isn't,
	// but that is no worse than for "regular" keys until we implement the
	// sync/cancel events on app focus changes.
	//
	// This is necessary to do here instead of in the framework because Flutter
	// does modifier key syncing in the framework, and will turn on/off these keys
	// as being "pressed" whenever the lock is on, which breaks a lot of
	// interactions (for example, if shift-lock is on, tab traversal is broken).
	//
	// TODO(gspencergoog): get rid of this tracked state when we are tracking the
	// state of all keys and sending sync/cancel events when focus is gained/lost.

	// Remove lock states from state mask.
	guint state = event->state & ~(GDK_LOCK_MASK \| GDK_MOD2_MASK);

	static bool shift_lock_pressed = FALSE;
	static bool caps_lock_pressed = FALSE;
	static bool num_lock_pressed = FALSE;
	switch (event->keyval) {
	case GDK_KEY_Num_Lock:
	num_lock_pressed = event->type == GDK_KEY_PRESS;
	break;
	case GDK_KEY_Caps_Lock:
	caps_lock_pressed = event->type == GDK_KEY_PRESS;
	break;
	case GDK_KEY_Shift_Lock:
	shift_lock_pressed = event->type == GDK_KEY_PRESS;
	break;
	}

	// Add back in the state matching the actual pressed state of the lock keys,
	// not the lock states.
	state \|= (shift_lock_pressed \|\| caps_lock_pressed) ? GDK_LOCK_MASK : 0x0;
	state \|= num_lock_pressed ? GDK_MOD2_MASK : 0x0;

	g_autoptr(FlValue) message = fl_value_new_map();
	fl_value_set_string_take(message, kTypeKey, fl_value_new_string(type));
	fl_value_set_string_take(message, kKeymapKey,
	fl_value_new_string(kLinuxKeymap));
	fl_value_set_string_take(message, kScanCodeKey, fl_value_new_int(scan_code));
	fl_value_set_string_take(message, kToolkitKey,
	fl_value_new_string(kGtkToolkit));
	fl_value_set_string_take(message, kKeyCodeKey,
	fl_value_new_int(event->keyval));
	fl_value_set_string_take(message, kModifiersKey, fl_value_new_int(state));
	if (unicodeScalarValues != 0) {
	fl_value_set_string_take(message, kUnicodeScalarValuesKey,
	fl_value_new_int(unicodeScalarValues));
	}

	// Track the event as pending a response from the framework.
	add_pending_event(self, id, event);
	FlKeyEventResponseData* data =
	fl_key_event_response_data_new(self, id, user_data);
	// Send the message off to the framework for handling (or not).
	fl_basic_message_channel_send(self->channel, message, nullptr,
	handle_response, data);
	// Return true before we know what the framework will do, because if it
	// doesn't handle the key, we'll re-dispatch it later.
	return TRUE;
	}