#include "flutter/shell/platform/linux/fl_key_channel_responder.h"
#include <gtk/gtk.h>
#include <cinttypes>
#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"

Classes
struct	_FlKeyChannelUserData

struct	_FlKeyChannelResponder

Functions
	G_DECLARE_FINAL_TYPE (FlKeyChannelUserData, fl_key_channel_user_data, FL, KEY_CHANNEL_USER_DATA, GObject)

static void	fl_key_channel_user_data_dispose (GObject *object)

static void	fl_key_channel_user_data_class_init (FlKeyChannelUserDataClass *klass)

static void	fl_key_channel_user_data_init (FlKeyChannelUserData *self)

static FlKeyChannelUserData *	fl_key_channel_user_data_new (FlKeyChannelResponder *responder, FlKeyResponderAsyncCallback callback, gpointer user_data)

static void	fl_key_channel_responder_iface_init (FlKeyResponderInterface *iface)

	G_DEFINE_TYPE_WITH_CODE (FlKeyChannelResponder, fl_key_channel_responder, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(FL_TYPE_KEY_RESPONDER, fl_key_channel_responder_iface_init)) static void fl_key_channel_responder_handle_event(FlKeyResponder *responder

static void	handle_response (GObject object, GAsyncResult result, gpointer user_data)

static void	fl_key_channel_responder_dispose (GObject *object)

static void	fl_key_channel_responder_class_init (FlKeyChannelResponderClass *klass)

static void	fl_key_channel_responder_init (FlKeyChannelResponder *self)

FlKeyChannelResponder *	fl_key_channel_responder_new (FlBinaryMessenger messenger, FlKeyChannelResponderMock mock)

static void	fl_key_channel_responder_handle_event (FlKeyResponder responder, FlKeyEvent event, uint64_t specified_logical_key, FlKeyResponderAsyncCallback callback, gpointer user_data)

Variables
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	kSpecifiedLogicalKey [] = "specifiedLogicalKey"

static constexpr char	kUnicodeScalarValuesKey [] = "unicodeScalarValues"

static constexpr char	kGtkToolkit [] = "gtk"

static constexpr char	kLinuxKeymap [] = "linux"

FlKeyEvent *	event

FlKeyEvent uint64_t	specified_logical_key

FlKeyEvent uint64_t FlKeyResponderAsyncCallback	callback

FlKeyEvent uint64_t FlKeyResponderAsyncCallback gpointer	user_data

Function Documentation

◆ fl_key_channel_responder_class_init()

static void fl_key_channel_responder_class_init ( FlKeyChannelResponderClass * klass )

static

Definition at line 173 of file fl_key_channel_responder.cc.

                                        {
   G_OBJECT_CLASS(klass)->dispose = fl_key_channel_responder_dispose;
 }

References fl_key_channel_responder_dispose().

◆ fl_key_channel_responder_dispose()

static void fl_key_channel_responder_dispose ( GObject * object )

static

Definition at line 164 of file fl_key_channel_responder.cc.

                                                               {
   FlKeyChannelResponder* self = FL_KEY_CHANNEL_RESPONDER(object);
  
   g_clear_object(&self->channel);
  
   G_OBJECT_CLASS(fl_key_channel_responder_parent_class)->dispose(object);
 }

Referenced by fl_key_channel_responder_class_init().

◆ fl_key_channel_responder_handle_event()

static void fl_key_channel_responder_handle_event	(	FlKeyResponder *	responder,
		FlKeyEvent *	event,
		uint64_t	specified_logical_key,
		FlKeyResponderAsyncCallback	callback,
		gpointer	user_data
	)

static

Definition at line 205 of file fl_key_channel_responder.cc.

                         {
   FlKeyChannelResponder* self = FL_KEY_CHANNEL_RESPONDER(responder);
   g_return_if_fail(event != nullptr);
   g_return_if_fail(callback != nullptr);
  
   const gchar* type = event->is_press ? kTypeValueDown : kTypeValueUp;
   int64_t scan_code = event->keycode;
   int64_t unicode_scarlar_values = 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).
  
   // 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->is_press;
       break;
     case GDK_KEY_Caps_Lock:
       caps_lock_pressed = event->is_press;
       break;
     case GDK_KEY_Shift_Lock:
       shift_lock_pressed = event->is_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 (unicode_scarlar_values != 0) {
     fl_value_set_string_take(message, kUnicodeScalarValuesKey,
                              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).
   fl_basic_message_channel_send(self->channel, message, nullptr,
                                 handle_response, data);
 }

References callback, event, fl_basic_message_channel_send(), fl_key_channel_user_data_new(), fl_value_new_int(), fl_value_new_map(), fl_value_new_string(), fl_value_set_string_take(), handle_response(), _FlKeyEvent::keyval, kGtkToolkit, kKeyCodeKey, kKeymapKey, kLinuxKeymap, kModifiersKey, kScanCodeKey, kSpecifiedLogicalKey, kToolkitKey, kTypeKey, kTypeValueDown, kTypeValueUp, kUnicodeScalarValuesKey, specified_logical_key, state, type, and user_data.

Referenced by fl_key_channel_responder_iface_init().

◆ fl_key_channel_responder_iface_init()

static void fl_key_channel_responder_iface_init ( FlKeyResponderInterface * iface )

static

Definition at line 123 of file fl_key_channel_responder.cc.

                                     {
   iface->handle_event = fl_key_channel_responder_handle_event;
 }

References fl_key_channel_responder_handle_event().

◆ fl_key_channel_responder_init()

static void fl_key_channel_responder_init ( FlKeyChannelResponder * self )

static

Definition at line 179 of file fl_key_channel_responder.cc.

179 {}

◆ fl_key_channel_responder_new()

FlKeyChannelResponder* fl_key_channel_responder_new	(	FlBinaryMessenger *	messenger,
		FlKeyChannelResponderMock *	mock = `nullptr`
	)

FlKeyChannelResponder:

A #FlKeyResponder that handles events by sending the raw event data in JSON through the message channel.

This class communicates with the RawKeyboard API in the framework. fl_key_channel_responder_new: @messenger: the messenger that the message channel should be built on. @mock: options to mock several functionalities. Only used in unittests.

Creates a new #FlKeyChannelResponder.

Returns: a new #FlKeyChannelResponder.

Definition at line 186 of file fl_key_channel_responder.cc.

                                      {
   g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
  
   FlKeyChannelResponder* self = FL_KEY_CHANNEL_RESPONDER(
       g_object_new(fl_key_channel_responder_get_type(), nullptr));
   self->mock = mock;
  
   g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
   const char* channel_name =
       mock == nullptr ? kChannelName : mock->channel_name;
   self->channel = fl_basic_message_channel_new(messenger, channel_name,
                                                FL_MESSAGE_CODEC(codec));
  
   return self;
 }

References _FlKeyChannelResponderMock::channel_name, fl_basic_message_channel_new(), fl_json_message_codec_new(), and kChannelName.

Referenced by fl_keyboard_manager_new(), TEST(), and test_lock_event().

◆ fl_key_channel_user_data_class_init()

static void fl_key_channel_user_data_class_init ( FlKeyChannelUserDataClass * klass )

static

Definition at line 68 of file fl_key_channel_responder.cc.

                                       {
   G_OBJECT_CLASS(klass)->dispose = fl_key_channel_user_data_dispose;
 }

References fl_key_channel_user_data_dispose().

◆ fl_key_channel_user_data_dispose()

static void fl_key_channel_user_data_dispose ( GObject * object )

static

Definition at line 56 of file fl_key_channel_responder.cc.

                                                               {
   g_return_if_fail(FL_IS_KEY_CHANNEL_USER_DATA(object));
   FlKeyChannelUserData* self = FL_KEY_CHANNEL_USER_DATA(object);
   if (self->responder != nullptr) {
     g_object_remove_weak_pointer(
         G_OBJECT(self->responder),
         reinterpret_cast<gpointer*>(&(self->responder)));
     self->responder = nullptr;
   }
 }

Referenced by fl_key_channel_user_data_class_init().

◆ fl_key_channel_user_data_init()

static void fl_key_channel_user_data_init ( FlKeyChannelUserData * self )

static

Definition at line 74 of file fl_key_channel_responder.cc.

74 {}

◆ fl_key_channel_user_data_new()

static FlKeyChannelUserData* fl_key_channel_user_data_new	(	FlKeyChannelResponder *	responder,
		FlKeyResponderAsyncCallback	callback,
		gpointer	user_data
	)

static

Definition at line 79 of file fl_key_channel_responder.cc.

                         {
   FlKeyChannelUserData* self = FL_KEY_CHANNEL_USER_DATA(
       g_object_new(fl_key_channel_user_data_get_type(), nullptr));
  
   self->responder = responder;
   // Add a weak pointer so we can know if the key event responder disappeared
   // while the framework was responding.
   g_object_add_weak_pointer(G_OBJECT(responder),
                             reinterpret_cast<gpointer*>(&(self->responder)));
   self->callback = callback;
   self->user_data = user_data;
   return self;
 }

References callback, g_object_add_weak_pointer(), and user_data.

Referenced by fl_key_channel_responder_handle_event().

◆ G_DECLARE_FINAL_TYPE()

G_DECLARE_FINAL_TYPE	(	FlKeyChannelUserData	,
		fl_key_channel_user_data	,
		FL	,
		KEY_CHANNEL_USER_DATA	,
		GObject
	)

FlKeyChannelUserData: The user_data used when #FlKeyChannelResponder sends message through the channel.

◆ G_DEFINE_TYPE_WITH_CODE()

G_DEFINE_TYPE_WITH_CODE	(	FlKeyChannelResponder	,
		fl_key_channel_responder	,
		G_TYPE_OBJECT	,
		G_IMPLEMENT_INTERFACE(FL_TYPE_KEY_RESPONDER, fl_key_channel_responder_iface_init)
	)

◆ handle_response()

static void handle_response	(	GObject *	object,
		GAsyncResult *	result,
		gpointer	user_data
	)

static

Definition at line 132 of file fl_key_channel_responder.cc.

                                                 {
   g_autoptr(FlKeyChannelUserData) data = FL_KEY_CHANNEL_USER_DATA(user_data);
  
   // This is true if the weak pointer has been destroyed.
   if (data->responder == nullptr) {
     return;
   }
  
   FlKeyChannelResponder* self = data->responder;
  
   g_autoptr(GError) error = nullptr;
   FlBasicMessageChannel* messageChannel = FL_BASIC_MESSAGE_CHANNEL(object);
   FlValue* message =
       fl_basic_message_channel_send_finish(messageChannel, result, &error);
   if (self->mock != nullptr && self->mock->value_converter != nullptr) {
     message = self->mock->value_converter(message);
   }
   bool handled = false;
   if (error != nullptr) {
     g_warning("Unable to retrieve framework response: %s", error->message);
   } else {
     g_autoptr(FlValue) handled_value =
         fl_value_lookup_string(message, "handled");
     handled = fl_value_get_bool(handled_value);
   }
  
   data->callback(handled, data->user_data);
 }