fl_key_embedder_responder.cc File Reference

#include "flutter/shell/platform/linux/fl_key_embedder_responder.h"
#include <gtk/gtk.h>
#include <cinttypes>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_key_mapping.h"

Go to the source code of this file.

Classes
struct	_FlKeyEmbedderResponder

Functions
static uint64_t	lookup_hash_table (GHashTable *table, uint64_t key)
static gboolean	hash_table_find_equal_value (gpointer key, gpointer value, gpointer user_data)
static uint64_t	reverse_lookup_hash_table (GHashTable *table, uint64_t value)
static uint64_t	to_lower (uint64_t n)
static void	fl_key_embedder_responder_dispose (GObject *object)
static void	fl_key_embedder_responder_class_init (FlKeyEmbedderResponderClass *klass)
static void	fl_key_embedder_responder_init (FlKeyEmbedderResponder *self)
FlKeyEmbedderResponder *	fl_key_embedder_responder_new (FlEngine *engine)
static uint64_t	apply_id_plane (uint64_t logical_id, uint64_t plane)
static uint64_t	event_to_physical_key (FlKeyEvent *event)
static uint64_t	event_to_logical_key (FlKeyEvent *event)
static uint64_t	event_to_timestamp (FlKeyEvent *event)
static char *	event_to_character (FlKeyEvent *event)
static void	synthesize_simple_event (FlKeyEmbedderResponder *self, FlutterKeyEventType type, uint64_t physical, uint64_t logical, double timestamp)
static void	update_pressing_state (FlKeyEmbedderResponder *self, uint64_t physical_key, uint64_t logical_key)
static void	possibly_update_lock_bit (FlKeyEmbedderResponder *self, uint64_t logical_key, bool is_down)
static void	update_mapping_record (FlKeyEmbedderResponder *self, uint64_t physical_key, uint64_t logical_key)
static void	synchronize_pressed_states (FlKeyEmbedderResponder *self, guint state, double timestamp)
static int	find_stage_by_record (bool is_down, bool is_enabled)
static int	find_stage_by_self_event (int stage_by_record, bool is_down_event, bool is_state_on, bool reverse_state_logic)
static int	find_stage_by_others_event (int stage_by_record, bool is_state_on)
static void	update_caps_lock_state_logic_inferrence (FlKeyEmbedderResponder *self, bool is_down_event, bool enabled_by_state, int stage_by_record)
static void	synchronize_lock_states (FlKeyEmbedderResponder *self, guint state, double timestamp, bool is_down, uint64_t event_logical_key)
static uint64_t	corrected_modifier_physical_key (GHashTable *modifier_bit_to_checked_keys, uint64_t physical_key_from_event, uint64_t logical_key)
static void	fl_key_embedder_responder_handle_event_impl (FlKeyEmbedderResponder *responder, FlKeyEvent *event, uint64_t specified_logical_key, GTask *task)
void	fl_key_embedder_responder_handle_event (FlKeyEmbedderResponder *self, FlKeyEvent *event, uint64_t specified_logical_key, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_key_embedder_responder_handle_event_finish (FlKeyEmbedderResponder *self, GAsyncResult *result, gboolean *handled, GError **error)
void	fl_key_embedder_responder_sync_modifiers_if_needed (FlKeyEmbedderResponder *self, guint state, double event_time)
GHashTable *	fl_key_embedder_responder_get_pressed_state (FlKeyEmbedderResponder *self)

Variables
constexpr uint64_t	kMicrosecondsPerMillisecond = 1000
static const FlutterKeyEvent	kEmptyEvent

Function Documentation

apply_id_plane()

static uint64_t apply_id_plane ( uint64_t  logical_id, uint64_t  plane  )

static

Definition at line 217 of file fl_key_embedder_responder.cc.

                                                                    {
  return (logical_id & kValueMask) | plane;
}

References kValueMask.

Referenced by event_to_logical_key(), and event_to_physical_key().

corrected_modifier_physical_key()

static uint64_t corrected_modifier_physical_key ( GHashTable *  modifier_bit_to_checked_keys, uint64_t  physical_key_from_event, uint64_t  logical_key  )

static

Definition at line 603 of file fl_key_embedder_responder.cc.

                          {
  // If no match is found, defaults to the physical key retrieved from the
  // event.
  uint64_t corrected_physical_key = physical_key_from_event;
 
  // Check if the physical key is one of the known modifier physical key.
  bool known_modifier_physical_key = false;
  GHashTableIter iter;
  g_hash_table_iter_init(&iter, modifier_bit_to_checked_keys);
  gpointer value;
  while (g_hash_table_iter_next(&iter, nullptr, &value)) {
    FlKeyEmbedderCheckedKey* checked_key =
        reinterpret_cast<FlKeyEmbedderCheckedKey*>(value);
    if (checked_key->primary_physical_key == physical_key_from_event) {
      known_modifier_physical_key = true;
    }
  }
 
  // If the physical key matches a known modifier key, find the modifier
  // physical key from the logical key.
  if (known_modifier_physical_key) {
    g_hash_table_iter_init(&iter, modifier_bit_to_checked_keys);
    while (g_hash_table_iter_next(&iter, nullptr, &value)) {
      FlKeyEmbedderCheckedKey* checked_key =
          reinterpret_cast<FlKeyEmbedderCheckedKey*>(value);
      if (checked_key->primary_logical_key == logical_key ||
          checked_key->secondary_logical_key == logical_key) {
        corrected_physical_key = checked_key->primary_physical_key;
      }
    }
  }
 
  return corrected_physical_key;
}

References FlKeyEmbedderCheckedKey::primary_logical_key, FlKeyEmbedderCheckedKey::primary_physical_key, FlKeyEmbedderCheckedKey::secondary_logical_key, and value.

Referenced by fl_key_embedder_responder_handle_event_impl().

event_to_character()

static char * event_to_character ( FlKeyEvent *  event )

static

Definition at line 250 of file fl_key_embedder_responder.cc.

                                                   {
  gunichar unicodeChar = gdk_keyval_to_unicode(fl_key_event_get_keyval(event));
  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;
}

References fl_key_event_get_keyval().

Referenced by fl_key_embedder_responder_handle_event_impl().

event_to_logical_key()

static uint64_t event_to_logical_key ( FlKeyEvent *  event )

static

Definition at line 229 of file fl_key_embedder_responder.cc.

                                                        {
  guint keyval = fl_key_event_get_keyval(event);
  auto found = gtk_keyval_to_logical_key_map.find(keyval);
  if (found != gtk_keyval_to_logical_key_map.end()) {
    return found->second;
  }
  // EASCII range
  if (keyval < 256) {
    return apply_id_plane(to_lower(keyval), kUnicodePlane);
  }
  // Auto-generate key
  return apply_id_plane(keyval, kGtkPlane);
}

References apply_id_plane(), fl_key_event_get_keyval(), gtk_keyval_to_logical_key_map, kGtkPlane, kUnicodePlane, and to_lower().

Referenced by fl_key_embedder_responder_handle_event_impl().

event_to_physical_key()

static uint64_t event_to_physical_key ( FlKeyEvent *  event )

static

Definition at line 221 of file fl_key_embedder_responder.cc.

                                                         {
  auto found = xkb_to_physical_key_map.find(fl_key_event_get_keycode(event));
  if (found != xkb_to_physical_key_map.end()) {
    return found->second;
  }
  return apply_id_plane(fl_key_event_get_keycode(event), kGtkPlane);
}

References apply_id_plane(), fl_key_event_get_keycode(), kGtkPlane, and xkb_to_physical_key_map.

Referenced by fl_key_embedder_responder_handle_event_impl().

event_to_timestamp()

static uint64_t event_to_timestamp ( FlKeyEvent *  event )

static

Definition at line 243 of file fl_key_embedder_responder.cc.

                                                      {
  return kMicrosecondsPerMillisecond *
         static_cast<double>(fl_key_event_get_time(event));
}

References fl_key_event_get_time(), and kMicrosecondsPerMillisecond.

Referenced by fl_key_embedder_responder_handle_event_impl().

find_stage_by_others_event()

static int find_stage_by_others_event ( int  stage_by_record, bool  is_state_on  )

static

Definition at line 450 of file fl_key_embedder_responder.cc.

                                                                             {
  g_return_val_if_fail(stage_by_record >= 0 && stage_by_record < 4,
                       stage_by_record);
  if (!is_state_on) {
    return 0;
  }
  if (stage_by_record == 0) {
    return 1;
  }
  return stage_by_record;
}

Referenced by synchronize_lock_states().

find_stage_by_record()

static int find_stage_by_record ( bool  is_down, bool  is_enabled  )

static

Definition at line 423 of file fl_key_embedder_responder.cc.

                                                               {
  constexpr int stage_by_record_index[] = {
      0,  // is_down: 0,  is_enabled: 0
      2,  //          0               1
      3,  //          1               0
      1   //          1               1
  };
  return stage_by_record_index[(is_down << 1) + is_enabled];
}

References is_enabled().

Referenced by synchronize_lock_states().

find_stage_by_self_event()

static int find_stage_by_self_event ( int  stage_by_record, bool  is_down_event, bool  is_state_on, bool  reverse_state_logic  )

static

Definition at line 435 of file fl_key_embedder_responder.cc.

                                                              {
  if (!is_state_on) {
    return reverse_state_logic ? 2 : 0;
  }
  if (is_down_event) {
    return reverse_state_logic ? 0 : 2;
  }
  return stage_by_record;
}

Referenced by synchronize_lock_states(), and update_caps_lock_state_logic_inferrence().

fl_key_embedder_responder_class_init()

static void fl_key_embedder_responder_class_init ( FlKeyEmbedderResponderClass *  klass )

static

Definition at line 152 of file fl_key_embedder_responder.cc.

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

References fl_key_embedder_responder_dispose().

fl_key_embedder_responder_dispose()

static void fl_key_embedder_responder_dispose ( GObject *  object )

static

Definition at line 163 of file fl_key_embedder_responder.cc.

                                                               {
  FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(object);
 
  g_cancellable_cancel(self->cancellable);
 
  g_weak_ref_clear(&self->engine);
  g_clear_pointer(&self->pressing_records, g_hash_table_unref);
  g_clear_pointer(&self->mapping_records, g_hash_table_unref);
  g_clear_pointer(&self->modifier_bit_to_checked_keys, g_hash_table_unref);
  g_clear_pointer(&self->lock_bit_to_checked_keys, g_hash_table_unref);
  g_clear_pointer(&self->logical_key_to_lock_bit, g_hash_table_unref);
  g_clear_object(&self->cancellable);
 
  G_OBJECT_CLASS(fl_key_embedder_responder_parent_class)->dispose(object);
}

References self.

Referenced by fl_key_embedder_responder_class_init().

fl_key_embedder_responder_get_pressed_state()

GHashTable * fl_key_embedder_responder_get_pressed_state

(

FlKeyEmbedderResponder *

responder

)

fl_key_embedder_responder_get_pressed_state: @responder: the #FlKeyEmbedderResponder self.

Returns the keyboard pressed state. The hash table contains one entry per pressed keys, mapping from the logical key to the physical key.

Definition at line 782 of file fl_key_embedder_responder.cc.

                                  {
  return self->pressing_records;
}

References self.

Referenced by fl_keyboard_manager_get_pressed_state().

fl_key_embedder_responder_handle_event()

void fl_key_embedder_responder_handle_event	(	FlKeyEmbedderResponder *	responder,
		FlKeyEvent *	event,
		uint64_t	specified_logical_key,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_key_embedder_responder_handle_event: @responder: the #FlKeyEmbedderResponder self. @event: the event to be handled. Must not be null. The object is managed by callee and must not be assumed available after this function. @specified_logical_key: @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): a #GAsyncReadyCallback to call when the view is added. @user_data: (closure): user data to pass to @callback.

Let the responder handle an event, expecting the responder to report whether to handle the event.

Definition at line 736 of file fl_key_embedder_responder.cc.

                                                                {
  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
 
  self->sent_any_events = false;
  fl_key_embedder_responder_handle_event_impl(self, event,
                                              specified_logical_key, task);
  if (!self->sent_any_events) {
    g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
    if (engine != nullptr) {
      fl_engine_send_key_event(engine, &kEmptyEvent, self->cancellable, nullptr,
                               nullptr);
    }
  }
}

References callback, engine, fl_engine_send_key_event(), fl_key_embedder_responder_handle_event_impl(), g_autoptr(), kEmptyEvent, self, and user_data.

Referenced by fl_keyboard_manager_handle_event(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

fl_key_embedder_responder_handle_event_finish()

gboolean fl_key_embedder_responder_handle_event_finish	(	FlKeyEmbedderResponder *	responder,
		GAsyncResult *	result,
		gboolean *	handled,
		GError **	error
	)

fl_key_embedder_responder_handle_event_finish: @responder: an #FlKeyEmbedderResponder.

Returns

: a #GAsyncResult. @handled: location to write if this event was handled by the embedder. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore. If error is not NULL, *error must be initialized (typically NULL, but an error from a previous call using GLib error handling is explicitly valid).

Completes request started with fl_key_embedder_responder_handle_event().

Returns TRUE on success.

Definition at line 756 of file fl_key_embedder_responder.cc.

                    {
  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
 
  g_autofree gboolean* return_value =
      static_cast<gboolean*>(g_task_propagate_pointer(G_TASK(result), error));
  if (return_value == nullptr) {
    return FALSE;
  }
 
  *handled = *return_value;
  return TRUE;
}

References error, self, and TRUE.

Referenced by responder_handle_embedder_event_cb(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

fl_key_embedder_responder_handle_event_impl()

static void fl_key_embedder_responder_handle_event_impl ( FlKeyEmbedderResponder *  responder, FlKeyEvent *  event, uint64_t  specified_logical_key, GTask *  task  )

static

Definition at line 641 of file fl_key_embedder_responder.cc.

                 {
  FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(responder);
 
  const uint64_t logical_key = specified_logical_key != 0
                                   ? specified_logical_key
                                   : event_to_logical_key(event);
  const uint64_t physical_key_from_event = event_to_physical_key(event);
  const uint64_t physical_key = corrected_modifier_physical_key(
      self->modifier_bit_to_checked_keys, physical_key_from_event, logical_key);
  guint state = fl_key_event_get_state(event);
  const double timestamp = event_to_timestamp(event);
  const bool is_down_event = fl_key_event_get_is_press(event);
 
  // Update lock mode states
  synchronize_lock_states(self, state, timestamp, is_down_event, logical_key);
 
  // Update pressing states
  synchronize_pressed_states(self, state, timestamp);
 
  // Construct the real event
  const uint64_t last_logical_record =
      lookup_hash_table(self->pressing_records, physical_key);
 
  FlutterKeyEvent out_event;
  out_event.struct_size = sizeof(out_event);
  out_event.timestamp = timestamp;
  out_event.physical = physical_key;
  out_event.logical =
      last_logical_record != 0 ? last_logical_record : logical_key;
  out_event.character = nullptr;
  out_event.synthesized = false;
 
  g_autofree char* character_to_free = nullptr;
  if (is_down_event) {
    if (last_logical_record) {
      // A key has been pressed that has the exact physical key as a currently
      // pressed one. This can happen during repeated events.
      out_event.type = kFlutterKeyEventTypeRepeat;
    } else {
      out_event.type = kFlutterKeyEventTypeDown;
    }
    character_to_free = event_to_character(event);  // Might be null
    out_event.character = character_to_free;
  } else {  // is_down_event false
    if (!last_logical_record) {
      // The physical key has been released before. It might indicate a missed
      // event due to loss of focus, or multiple keyboards pressed keys with the
      // same physical key. Ignore the up event.
      gboolean* return_value = g_new0(gboolean, 1);
      *return_value = TRUE;
      g_task_return_pointer(task, return_value, g_free);
      return;
    } else {
      out_event.type = kFlutterKeyEventTypeUp;
    }
  }
 
  if (out_event.type != kFlutterKeyEventTypeRepeat) {
    update_pressing_state(self, physical_key, is_down_event ? logical_key : 0);
  }
  possibly_update_lock_bit(self, logical_key, is_down_event);
  if (is_down_event) {
    update_mapping_record(self, physical_key, logical_key);
  }
  self->sent_any_events = true;
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine != nullptr) {
    fl_engine_send_key_event(
        engine, &out_event, self->cancellable,
        [](GObject* object, GAsyncResult* result, gpointer user_data) {
          g_autoptr(GTask) task = G_TASK(user_data);
 
          gboolean handled;
          g_autoptr(GError) error = nullptr;
          if (!fl_engine_send_key_event_finish(FL_ENGINE(object), result,
                                               &handled, &error)) {
            if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
              return;
            }
            g_warning("Failed to handle key event: %s", error->message);
            handled = FALSE;
          }
 
          gboolean* return_value = g_new0(gboolean, 1);
          *return_value = handled;
          g_task_return_pointer(task, return_value, g_free);
        },
        g_object_ref(task));
  }
}

References FlutterKeyEvent::character, corrected_modifier_physical_key(), engine, event_to_character(), event_to_logical_key(), event_to_physical_key(), event_to_timestamp(), fl_engine_send_key_event(), fl_key_event_get_is_press(), fl_key_event_get_state(), g_autoptr(), kFlutterKeyEventTypeDown, kFlutterKeyEventTypeRepeat, kFlutterKeyEventTypeUp, FlutterKeyEvent::logical, lookup_hash_table(), FlutterKeyEvent::physical, possibly_update_lock_bit(), self, FlutterKeyEvent::struct_size, synchronize_lock_states(), synchronize_pressed_states(), FlutterKeyEvent::synthesized, FlutterKeyEvent::timestamp, TRUE, FlutterKeyEvent::type, update_mapping_record(), update_pressing_state(), and user_data.

Referenced by fl_key_embedder_responder_handle_event().

fl_key_embedder_responder_init()

static void fl_key_embedder_responder_init ( FlKeyEmbedderResponder *  self )

static

Definition at line 158 of file fl_key_embedder_responder.cc.

                                                                         {
  self->cancellable = g_cancellable_new();
}

References self.

fl_key_embedder_responder_new()

FlKeyEmbedderResponder * fl_key_embedder_responder_new

(

FlEngine *

engine

)

FlKeyEmbedderResponder:

A #FlKeyResponder that handles events by sending the converted events through the embedder API.

This class communicates with the HardwareKeyboard API in the framework. fl_key_embedder_responder_new: @engine: The #FlEngine, whose the embedder API will be used to send the event.

Creates a new #FlKeyEmbedderResponder.

Returns: a new #FlKeyEmbedderResponder.

Definition at line 180 of file fl_key_embedder_responder.cc.

                                                                        {
  FlKeyEmbedderResponder* self = FL_KEY_EMBEDDER_RESPONDER(
      g_object_new(fl_key_embedder_responder_get_type(), nullptr));
 
  g_weak_ref_init(&self->engine, engine);
 
  self->pressing_records = g_hash_table_new(g_direct_hash, g_direct_equal);
  self->mapping_records = g_hash_table_new(g_direct_hash, g_direct_equal);
  self->lock_records = 0;
  self->caps_lock_state_logic_inferrence = STATE_LOGIC_INFERRENCE_UNDECIDED;
 
  self->modifier_bit_to_checked_keys =
      g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
  initialize_modifier_bit_to_checked_keys(self->modifier_bit_to_checked_keys);
 
  self->lock_bit_to_checked_keys =
      g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
  initialize_lock_bit_to_checked_keys(self->lock_bit_to_checked_keys);
 
  // Associate a logical key with its corresponding modifier bit.
  self->logical_key_to_lock_bit =
      g_hash_table_new(g_direct_hash, g_direct_equal);
  GHashTableIter iter;
  g_hash_table_iter_init(&iter, self->lock_bit_to_checked_keys);
  gpointer key, value;
  while (g_hash_table_iter_next(&iter, &key, &value)) {
    guint lock_bit = GPOINTER_TO_UINT(key);
    FlKeyEmbedderCheckedKey* checked_key =
        reinterpret_cast<FlKeyEmbedderCheckedKey*>(value);
    g_hash_table_insert(self->logical_key_to_lock_bit,
                        uint64_to_gpointer(checked_key->primary_logical_key),
                        GUINT_TO_POINTER(lock_bit));
  }
 
  return self;
}

References engine, g_hash_table_insert(), initialize_lock_bit_to_checked_keys(), initialize_modifier_bit_to_checked_keys(), key, FlKeyEmbedderCheckedKey::primary_logical_key, self, uint64_to_gpointer(), and value.

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

fl_key_embedder_responder_sync_modifiers_if_needed()

void fl_key_embedder_responder_sync_modifiers_if_needed	(	FlKeyEmbedderResponder *	responder,
		guint	state,
		double	event_time
	)

fl_key_embedder_responder_sync_modifiers_if_needed: @responder: the #FlKeyEmbedderResponder self. @state: the state of the modifiers mask. @event_time: the time attribute of the incoming GDK event.

If needed, synthesize modifier keys up and down event by comparing their current pressing states with the given modifiers mask.

Definition at line 773 of file fl_key_embedder_responder.cc.

                       {
  g_return_if_fail(FL_IS_KEY_EMBEDDER_RESPONDER(self));
  synchronize_pressed_states(self, state,
                             event_time * kMicrosecondsPerMillisecond);
}

References kMicrosecondsPerMillisecond, self, and synchronize_pressed_states().

Referenced by fl_keyboard_manager_sync_modifier_if_needed().

hash_table_find_equal_value()

static gboolean hash_table_find_equal_value ( gpointer  key, gpointer  value, gpointer  user_data  )

static

Definition at line 35 of file fl_key_embedder_responder.cc.

                                                                {
  return gpointer_to_uint64(value) == gpointer_to_uint64(user_data);
}

References gpointer_to_uint64(), user_data, and value.

Referenced by reverse_lookup_hash_table().

lookup_hash_table()

static uint64_t lookup_hash_table ( GHashTable *  table, uint64_t  key  )

static

Definition at line 30 of file fl_key_embedder_responder.cc.

                                                                   {
  return gpointer_to_uint64(
      g_hash_table_lookup(table, uint64_to_gpointer(key)));
}

References gpointer_to_uint64(), key, and uint64_to_gpointer().

Referenced by fl_key_embedder_responder_handle_event_impl(), synchronize_lock_states(), synchronize_pressed_states(), and update_pressing_state().

possibly_update_lock_bit()

static void possibly_update_lock_bit ( FlKeyEmbedderResponder *  self, uint64_t  logical_key, bool  is_down  )

static

Definition at line 311 of file fl_key_embedder_responder.cc.

                                                   {
  if (!is_down) {
    return;
  }
  const guint mode_bit = GPOINTER_TO_UINT(g_hash_table_lookup(
      self->logical_key_to_lock_bit, uint64_to_gpointer(logical_key)));
  if (mode_bit != 0) {
    self->lock_records ^= mode_bit;
  }
}

References self, and uint64_to_gpointer().

Referenced by fl_key_embedder_responder_handle_event_impl(), and synchronize_lock_states().

reverse_lookup_hash_table()

static uint64_t reverse_lookup_hash_table ( GHashTable *  table, uint64_t  value  )

static

Definition at line 47 of file fl_key_embedder_responder.cc.

                                                                             {
  return gpointer_to_uint64(g_hash_table_find(
      table, hash_table_find_equal_value, uint64_to_gpointer(value)));
}

References gpointer_to_uint64(), hash_table_find_equal_value(), uint64_to_gpointer(), and value.

Referenced by synchronize_pressed_states().

synchronize_lock_states()

static void synchronize_lock_states ( FlKeyEmbedderResponder *  self, guint  state, double  timestamp, bool  is_down, uint64_t  event_logical_key  )

static

Definition at line 503 of file fl_key_embedder_responder.cc.

                                                                {
  GHashTableIter iter;
  g_hash_table_iter_init(&iter, self->lock_bit_to_checked_keys);
  gpointer key, value;
  while (g_hash_table_iter_next(&iter, &key, &value)) {
    guint modifier_bit = GPOINTER_TO_UINT(key);
    FlKeyEmbedderCheckedKey* checked_key =
        reinterpret_cast<FlKeyEmbedderCheckedKey*>(value);
 
    const uint64_t logical_key = checked_key->primary_logical_key;
    const uint64_t recorded_physical_key =
        lookup_hash_table(self->mapping_records, logical_key);
    // The physical key is derived from past mapping record if possible.
    //
    // If the event to be synthesized is a key up event, then there must have
    // been a key down event before, which has updated the mapping record.
    // If the event to be synthesized is a key down event, then there might
    // not have been a mapping record, in which case the hard-coded
    // #primary_physical_key is used.
    const uint64_t physical_key = recorded_physical_key != 0
                                      ? recorded_physical_key
                                      : checked_key->primary_physical_key;
 
    // A lock mode key can be at any of a 4-stage cycle, depending on whether
    // it's pressed and enabled. The following table lists the definition of
    // each stage (TruePressed and TrueEnabled), the event of the lock key
    // between every 2 stages (SelfType and SelfState), and the event of other
    // keys at each stage (OthersState). On certain platforms SelfState uses a
    // reversed rule for certain keys (SelfState(rvsd), as documented in
    // #update_caps_lock_state_logic_inferrence).
    //
    //               #    [0]         [1]          [2]           [3]
    //     TruePressed: Released    Pressed      Released      Pressed
    //     TrueEnabled: Disabled    Enabled      Enabled       Disabled
    //        SelfType:         Down         Up           Down            Up
    //       SelfState:          0           1             1              1
    // SelfState(rvsd):          1           1             0              1
    //     OthersState:    0           1            1              1
    //
    // When the exact stage can't be derived, choose the stage that requires the
    // minimal synthesization.
 
    const uint64_t pressed_logical_key =
        recorded_physical_key == 0
            ? 0
            : lookup_hash_table(self->pressing_records, recorded_physical_key);
 
    g_return_if_fail(pressed_logical_key == 0 ||
                     pressed_logical_key == logical_key);
    const int stage_by_record = find_stage_by_record(
        pressed_logical_key != 0, (self->lock_records & modifier_bit) != 0);
 
    const bool enabled_by_state = (state & modifier_bit) != 0;
    const bool this_key_is_event_key = logical_key == event_logical_key;
    if (this_key_is_event_key && checked_key->is_caps_lock) {
      update_caps_lock_state_logic_inferrence(self, is_down, enabled_by_state,
                                              stage_by_record);
      g_return_if_fail(self->caps_lock_state_logic_inferrence !=
                       STATE_LOGIC_INFERRENCE_UNDECIDED);
    }
    const bool reverse_state_logic =
        checked_key->is_caps_lock && self->caps_lock_state_logic_inferrence ==
                                         STATE_LOGIC_INFERRENCE_REVERSED;
    const int stage_by_event =
        this_key_is_event_key
            ? find_stage_by_self_event(stage_by_record, is_down,
                                       enabled_by_state, reverse_state_logic)
            : find_stage_by_others_event(stage_by_record, enabled_by_state);
 
    // The destination stage is equal to stage_by_event but shifted cyclically
    // to be no less than stage_by_record.
    constexpr int kNumStages = 4;
    const int destination_stage = stage_by_event >= stage_by_record
                                      ? stage_by_event
                                      : stage_by_event + kNumStages;
 
    g_return_if_fail(stage_by_record <= destination_stage);
    for (int current_stage = stage_by_record;
         current_stage < destination_stage && current_stage < 9;
         current_stage += 1) {
      const int standard_current_stage = current_stage % kNumStages;
      const bool is_down_event =
          standard_current_stage == 0 || standard_current_stage == 2;
      if (is_down_event && recorded_physical_key == 0) {
        update_mapping_record(self, physical_key, logical_key);
      }
      FlutterKeyEventType type =
          is_down_event ? kFlutterKeyEventTypeDown : kFlutterKeyEventTypeUp;
      update_pressing_state(self, physical_key,
                            is_down_event ? logical_key : 0);
      possibly_update_lock_bit(self, logical_key, is_down_event);
      synthesize_simple_event(self, type, physical_key, logical_key, timestamp);
    }
  }
}

References find_stage_by_others_event(), find_stage_by_record(), find_stage_by_self_event(), FlKeyEmbedderCheckedKey::is_caps_lock, key, kFlutterKeyEventTypeDown, kFlutterKeyEventTypeUp, lookup_hash_table(), possibly_update_lock_bit(), FlKeyEmbedderCheckedKey::primary_logical_key, FlKeyEmbedderCheckedKey::primary_physical_key, self, synthesize_simple_event(), type, update_caps_lock_state_logic_inferrence(), update_mapping_record(), update_pressing_state(), and value.

Referenced by fl_key_embedder_responder_handle_event_impl().

synchronize_pressed_states()

static void synchronize_pressed_states ( FlKeyEmbedderResponder *  self, guint  state, double  timestamp  )

static

Definition at line 333 of file fl_key_embedder_responder.cc.

                                                         {
  GHashTableIter iter;
  g_hash_table_iter_init(&iter, self->modifier_bit_to_checked_keys);
  gpointer key, value;
  while (g_hash_table_iter_next(&iter, &key, &value)) {
    guint modifier_bit = GPOINTER_TO_UINT(key);
    FlKeyEmbedderCheckedKey* checked_key =
        reinterpret_cast<FlKeyEmbedderCheckedKey*>(value);
 
    // Each TestKey contains up to two logical keys, typically the left modifier
    // and the right modifier, that correspond to the same modifier_bit. We'd
    // like to infer whether to synthesize a down or up event for each key.
    //
    // The hard part is that, if we want to synthesize a down event, we don't
    // know which physical key to use. Here we assume the keyboard layout do not
    // change frequently and use the last physical-logical relationship,
    // recorded in #mapping_records.
    const uint64_t logical_keys[] = {
        checked_key->primary_logical_key,
        checked_key->secondary_logical_key,
    };
    const guint length = checked_key->secondary_logical_key == 0 ? 1 : 2;
 
    const bool any_pressed_by_state = (state & modifier_bit) != 0;
 
    bool any_pressed_by_record = false;
 
    // Traverse each logical key of this modifier bit for 2 purposes:
    //
    //  1. Perform the synthesization of release events: If the modifier bit is
    //  0
    //     and the key is pressed, synthesize a release event.
    //  2. Prepare for the synthesization of press events: If the modifier bit
    //  is
    //     1, and no keys are pressed (discovered here), synthesize a press
    //     event later.
    for (guint logical_key_idx = 0; logical_key_idx < length;
         logical_key_idx++) {
      const uint64_t logical_key = logical_keys[logical_key_idx];
      g_return_if_fail(logical_key != 0);
      const uint64_t pressing_physical_key =
          reverse_lookup_hash_table(self->pressing_records, logical_key);
      const bool this_key_pressed_before_event = pressing_physical_key != 0;
 
      any_pressed_by_record =
          any_pressed_by_record || this_key_pressed_before_event;
 
      if (this_key_pressed_before_event && !any_pressed_by_state) {
        const uint64_t recorded_physical_key =
            lookup_hash_table(self->mapping_records, logical_key);
        // Since this key has been pressed before, there must have been a
        // recorded physical key.
        g_return_if_fail(recorded_physical_key != 0);
        // In rare cases #recorded_logical_key is different from #logical_key.
        const uint64_t recorded_logical_key =
            lookup_hash_table(self->pressing_records, recorded_physical_key);
        synthesize_simple_event(self, kFlutterKeyEventTypeUp,
                                recorded_physical_key, recorded_logical_key,
                                timestamp);
        update_pressing_state(self, recorded_physical_key, 0);
      }
    }
    // If the modifier should be pressed, synthesize a down event for its
    // primary key.
    if (any_pressed_by_state && !any_pressed_by_record) {
      const uint64_t logical_key = checked_key->primary_logical_key;
      const uint64_t recorded_physical_key =
          lookup_hash_table(self->mapping_records, logical_key);
      // The physical key is derived from past mapping record if possible.
      //
      // The event to be synthesized is a key down event. There might not have
      // been a mapping record, in which case the hard-coded
      // #primary_physical_key is used.
      const uint64_t physical_key = recorded_physical_key != 0
                                        ? recorded_physical_key
                                        : checked_key->primary_physical_key;
      if (recorded_physical_key == 0) {
        update_mapping_record(self, physical_key, logical_key);
      }
      synthesize_simple_event(self, kFlutterKeyEventTypeDown, physical_key,
                              logical_key, timestamp);
      update_pressing_state(self, physical_key, logical_key);
    }
  }
}

References key, kFlutterKeyEventTypeDown, kFlutterKeyEventTypeUp, length, lookup_hash_table(), FlKeyEmbedderCheckedKey::primary_logical_key, FlKeyEmbedderCheckedKey::primary_physical_key, reverse_lookup_hash_table(), FlKeyEmbedderCheckedKey::secondary_logical_key, self, synthesize_simple_event(), update_mapping_record(), update_pressing_state(), and value.

Referenced by fl_key_embedder_responder_handle_event_impl(), and fl_key_embedder_responder_sync_modifiers_if_needed().

synthesize_simple_event()

static void synthesize_simple_event ( FlKeyEmbedderResponder *  self, FlutterKeyEventType  type, uint64_t  physical, uint64_t  logical, double  timestamp  )

static

Definition at line 264 of file fl_key_embedder_responder.cc.

                                                      {
  FlutterKeyEvent out_event;
  out_event.struct_size = sizeof(out_event);
  out_event.timestamp = timestamp;
  out_event.type = type;
  out_event.physical = physical;
  out_event.logical = logical;
  out_event.character = nullptr;
  out_event.synthesized = true;
  self->sent_any_events = true;
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine != nullptr) {
    fl_engine_send_key_event(engine, &out_event, self->cancellable, nullptr,
                             nullptr);
  }
}

References FlutterKeyEvent::character, engine, fl_engine_send_key_event(), g_autoptr(), FlutterKeyEvent::logical, FlutterKeyEvent::physical, self, FlutterKeyEvent::struct_size, FlutterKeyEvent::synthesized, FlutterKeyEvent::timestamp, type, and FlutterKeyEvent::type.

Referenced by synchronize_lock_states(), and synchronize_pressed_states().

to_lower()

static uint64_t to_lower ( uint64_t  n )

static

Definition at line 52 of file fl_key_embedder_responder.cc.

                                     {
  constexpr uint64_t lower_a = 0x61;
  constexpr uint64_t upper_a = 0x41;
  constexpr uint64_t upper_z = 0x5a;
 
  constexpr uint64_t lower_a_grave = 0xe0;
  constexpr uint64_t upper_a_grave = 0xc0;
  constexpr uint64_t upper_thorn = 0xde;
  constexpr uint64_t division = 0xf7;
 
  // ASCII range.
  if (n >= upper_a && n <= upper_z) {
    return n - upper_a + lower_a;
  }
 
  // EASCII range.
  if (n >= upper_a_grave && n <= upper_thorn && n != division) {
    return n - upper_a_grave + lower_a_grave;
  }
 
  return n;
}

Referenced by event_to_logical_key().

update_caps_lock_state_logic_inferrence()

static void update_caps_lock_state_logic_inferrence ( FlKeyEmbedderResponder *  self, bool  is_down_event, bool  enabled_by_state, int  stage_by_record  )

static

Definition at line 477 of file fl_key_embedder_responder.cc.

                         {
  if (self->caps_lock_state_logic_inferrence !=
      STATE_LOGIC_INFERRENCE_UNDECIDED) {
    return;
  }
  if (!is_down_event) {
    return;
  }
  const int stage_by_event = find_stage_by_self_event(
      stage_by_record, is_down_event, enabled_by_state, false);
  if ((stage_by_event == 0 && stage_by_record == 2) ||
      (stage_by_event == 2 && stage_by_record == 0)) {
    self->caps_lock_state_logic_inferrence = STATE_LOGIC_INFERRENCE_REVERSED;
  } else {
    self->caps_lock_state_logic_inferrence = STATE_LOGIC_INFERRENCE_NORMAL;
  }
}

References find_stage_by_self_event(), and self.

Referenced by synchronize_lock_states().

update_mapping_record()

static void update_mapping_record ( FlKeyEmbedderResponder *  self, uint64_t  physical_key, uint64_t  logical_key  )

static

Definition at line 324 of file fl_key_embedder_responder.cc.

                                                        {
  g_hash_table_insert(self->mapping_records, uint64_to_gpointer(logical_key),
                      uint64_to_gpointer(physical_key));
}

References g_hash_table_insert(), self, and uint64_to_gpointer().

Referenced by fl_key_embedder_responder_handle_event_impl(), synchronize_lock_states(), and synchronize_pressed_states().

update_pressing_state()

static void update_pressing_state ( FlKeyEmbedderResponder *  self, uint64_t  physical_key, uint64_t  logical_key  )

static

Definition at line 290 of file fl_key_embedder_responder.cc.

                                                        {
  if (logical_key != 0) {
    g_return_if_fail(lookup_hash_table(self->pressing_records, physical_key) ==
                     0);
    g_hash_table_insert(self->pressing_records,
                        uint64_to_gpointer(physical_key),
                        uint64_to_gpointer(logical_key));
  } else {
    g_return_if_fail(lookup_hash_table(self->pressing_records, physical_key) !=
                     0);
    g_hash_table_remove(self->pressing_records,
                        uint64_to_gpointer(physical_key));
  }
}

References g_hash_table_insert(), lookup_hash_table(), self, and uint64_to_gpointer().

Referenced by fl_key_embedder_responder_handle_event_impl(), synchronize_lock_states(), and synchronize_pressed_states().

Variable Documentation

kEmptyEvent

const FlutterKeyEvent kEmptyEvent

static

Initial value:

{
    .struct_size = sizeof(FlutterKeyEvent),
    .timestamp = 0,
    .type = kFlutterKeyEventTypeDown,
    .physical = 0,
    .logical = 0,
    .character = nullptr,
    .synthesized = false,
}

Definition at line 15 of file fl_key_embedder_responder.cc.

                                        {
    .struct_size = sizeof(FlutterKeyEvent),
    .timestamp = 0,
    .type = kFlutterKeyEventTypeDown,
    .physical = 0,
    .logical = 0,
    .character = nullptr,
    .synthesized = false,
};

Referenced by fl_key_embedder_responder_handle_event().

kMicrosecondsPerMillisecond

constexpr uint64_t kMicrosecondsPerMillisecond = 1000

constexpr

Definition at line 13 of file fl_key_embedder_responder.cc.

Referenced by event_to_timestamp(), and fl_key_embedder_responder_sync_modifiers_if_needed().