fl_keyboard_manager.cc File Reference

#include "flutter/shell/platform/linux/fl_keyboard_manager.h"
#include <array>
#include <cinttypes>
#include <memory>
#include <string>
#include "flutter/shell/platform/linux/fl_key_channel_responder.h"
#include "flutter/shell/platform/linux/fl_key_embedder_responder.h"
#include "flutter/shell/platform/linux/key_mapping.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"

Go to the source code of this file.

Classes
struct	_FlKeyboardPendingEvent
struct	_FlKeyboardManagerUserData
struct	_FlKeyboardManager

Macros
#define	DEBUG_PRINT_LAYOUT
#define	FL_TYPE_KEYBOARD_MANAGER_USER_DATA    fl_keyboard_manager_user_data_get_type()

Functions
	G_DECLARE_FINAL_TYPE (FlKeyboardPendingEvent, fl_keyboard_pending_event, FL, KEYBOARD_PENDING_EVENT, GObject)
	G_DECLARE_FINAL_TYPE (FlKeyboardManagerUserData, fl_keyboard_manager_user_data, FL, KEYBOARD_MANAGER_USER_DATA, GObject)
static uint64_t	get_logical_key_from_layout (const FlKeyEvent *event, const DerivedLayout &layout)
static void	fl_keyboard_pending_event_dispose (GObject *object)
static void	fl_keyboard_pending_event_class_init (FlKeyboardPendingEventClass *klass)
static void	fl_keyboard_pending_event_init (FlKeyboardPendingEvent *self)
static uint64_t	fl_keyboard_manager_get_event_hash (FlKeyEvent *event)
static FlKeyboardPendingEvent *	fl_keyboard_pending_event_new (std::unique_ptr< FlKeyEvent > event, uint64_t sequence_id, size_t to_reply)
	G_DEFINE_TYPE (FlKeyboardManagerUserData, fl_keyboard_manager_user_data, G_TYPE_OBJECT) static void fl_keyboard_manager_user_data_dispose(GObject *object)
static void	fl_keyboard_manager_user_data_class_init (FlKeyboardManagerUserDataClass *klass)
static void	fl_keyboard_manager_user_data_init (FlKeyboardManagerUserData *self)
static FlKeyboardManagerUserData *	fl_keyboard_manager_user_data_new (FlKeyboardManager *manager, uint64_t sequence_id)
	G_DEFINE_TYPE (FlKeyboardManager, fl_keyboard_manager, G_TYPE_OBJECT)
static void	fl_keyboard_manager_dispose (GObject *object)
static void	fl_keyboard_manager_class_init (FlKeyboardManagerClass *klass)
static void	fl_keyboard_manager_init (FlKeyboardManager *self)
static gboolean	g_ptr_array_find_with_equal_func1 (GPtrArray *haystack, gconstpointer needle, GEqualFunc equal_func, guint *index_)
static gboolean	compare_pending_by_sequence_id (gconstpointer pending, gconstpointer needle_sequence_id)
static gboolean	compare_pending_by_hash (gconstpointer pending, gconstpointer needle_hash)
static bool	fl_keyboard_manager_remove_redispatched (FlKeyboardManager *self, uint64_t hash)
static void	responder_handle_event_callback (bool handled, gpointer user_data_ptr)
static uint16_t	convert_key_to_char (FlKeyboardViewDelegate *view_delegate, guint keycode, gint group, gint level)
static void	guarantee_layout (FlKeyboardManager *self, FlKeyEvent *event)
FlMethodResponse *	get_keyboard_state (FlKeyboardManager *self)
static void	method_call_handler (FlMethodChannel *channel, FlMethodCall *method_call, gpointer user_data)
FlKeyboardManager *	fl_keyboard_manager_new (FlBinaryMessenger *messenger, FlKeyboardViewDelegate *view_delegate)
static void	dispatch_to_responder (gpointer responder_data, gpointer foreach_data_ptr)
gboolean	fl_keyboard_manager_handle_event (FlKeyboardManager *self, FlKeyEvent *event)
gboolean	fl_keyboard_manager_is_state_clear (FlKeyboardManager *self)
void	fl_keyboard_manager_sync_modifier_if_needed (FlKeyboardManager *self, guint state, double event_time)
GHashTable *	fl_keyboard_manager_get_pressed_state (FlKeyboardManager *self)

Variables
static constexpr char	kChannelName [] = "flutter/keyboard"
static constexpr char	kGetKeyboardStateMethod [] = "getKeyboardState"

Macro Definition Documentation

DEBUG_PRINT_LAYOUT

#define DEBUG_PRINT_LAYOUT

Definition at line 20 of file fl_keyboard_manager.cc.

FL_TYPE_KEYBOARD_MANAGER_USER_DATA

#define FL_TYPE_KEYBOARD_MANAGER_USER_DATA    fl_keyboard_manager_user_data_get_type()

Definition at line 33 of file fl_keyboard_manager.cc.

Function Documentation

compare_pending_by_hash()

static gboolean compare_pending_by_hash ( gconstpointer  pending, gconstpointer  needle_hash  )

static

Definition at line 392 of file fl_keyboard_manager.cc.

                                                                   {
  uint64_t hash = *reinterpret_cast<const uint64_t*>(needle_hash);
  return static_cast<const FlKeyboardPendingEvent*>(pending)->hash == hash;
}

compare_pending_by_sequence_id()

static gboolean compare_pending_by_sequence_id ( gconstpointer  pending, gconstpointer  needle_sequence_id  )

static

Definition at line 382 of file fl_keyboard_manager.cc.

                                      {
  uint64_t sequence_id = *reinterpret_cast<const uint64_t*>(needle_sequence_id);
  return static_cast<const FlKeyboardPendingEvent*>(pending)->sequence_id ==
         sequence_id;
}

convert_key_to_char()

static uint16_t convert_key_to_char ( FlKeyboardViewDelegate *  view_delegate, guint  keycode, gint  group, gint  level  )

static

Definition at line 456 of file fl_keyboard_manager.cc.

                                                {
  GdkKeymapKey key = {keycode, group, level};
  constexpr int kBmpMax = 0xD7FF;
  guint origin = fl_keyboard_view_delegate_lookup_key(view_delegate, &key);
  return origin < kBmpMax ? origin : 0xFFFF;
}

dispatch_to_responder()

static void dispatch_to_responder ( gpointer  responder_data, gpointer  foreach_data_ptr  )

static

Definition at line 628 of file fl_keyboard_manager.cc.

                                                             {
  DispatchToResponderLoopContext* context =
      reinterpret_cast<DispatchToResponderLoopContext*>(foreach_data_ptr);
  FlKeyResponder* responder = FL_KEY_RESPONDER(responder_data);
  fl_key_responder_handle_event(
      responder, context->event, responder_handle_event_callback,
      context->user_data, context->specified_logical_key);
}

fl_keyboard_manager_class_init()

static void fl_keyboard_manager_class_init ( FlKeyboardManagerClass *  klass )

static

Definition at line 304 of file fl_keyboard_manager.cc.

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

fl_keyboard_manager_dispose()

static void fl_keyboard_manager_dispose ( GObject *  object )

static

Definition at line 330 of file fl_keyboard_manager.cc.

                                                         {
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(object);
 
  if (self->view_delegate != nullptr) {
    fl_keyboard_view_delegate_subscribe_to_layout_change(self->view_delegate,
                                                         nullptr);
    g_object_remove_weak_pointer(
        G_OBJECT(self->view_delegate),
        reinterpret_cast<gpointer*>(&(self->view_delegate)));
    self->view_delegate = nullptr;
  }
 
  self->derived_layout.reset();
  self->keycode_to_goals.reset();
  self->logical_to_mandatory_goals.reset();
 
  g_ptr_array_free(self->responder_list, TRUE);
  g_ptr_array_set_free_func(self->pending_responds, g_object_unref);
  g_ptr_array_free(self->pending_responds, TRUE);
  g_ptr_array_free(self->pending_redispatches, TRUE);
 
  G_OBJECT_CLASS(fl_keyboard_manager_parent_class)->dispose(object);
}

fl_keyboard_manager_get_event_hash()

static uint64_t fl_keyboard_manager_get_event_hash ( FlKeyEvent *  event )

static

Definition at line 168 of file fl_keyboard_manager.cc.

                                                                      {
  // 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.
  guint64 type =
      static_cast<uint64_t>(event->is_press ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
  guint64 keycode = static_cast<uint64_t>(event->keycode);
  return (event->time & 0xffffffff) | ((type & 0xffff) << 32) |
         ((keycode & 0xffff) << 48);
}

fl_keyboard_manager_get_pressed_state()

GHashTable * fl_keyboard_manager_get_pressed_state

(

FlKeyboardManager *

manager

)

fl_keyboard_manager_get_pressed_state: @manager: the FlKeyboardManager 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 688 of file fl_keyboard_manager.cc.

                                                                           {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), nullptr);
 
  // The embedder responder is the first element in
  // FlKeyboardManager.responder_list.
  FlKeyEmbedderResponder* responder =
      FL_KEY_EMBEDDER_RESPONDER(g_ptr_array_index(self->responder_list, 0));
  return fl_key_embedder_responder_get_pressed_state(responder);
}

fl_keyboard_manager_handle_event()

gboolean fl_keyboard_manager_handle_event	(	FlKeyboardManager *	manager,
		FlKeyEvent *	event
	)

fl_keyboard_manager_handle_event: @manager: the FlKeyboardManager self. @event: the event to be dispatched. It is usually a wrap of a GdkEventKey. This event will be managed and released by FlKeyboardManager.

Make the manager process a system key event. This might eventually send messages to the framework, trigger text input effects, or redispatch the event back to the system.

Definition at line 638 of file fl_keyboard_manager.cc.

                                                             {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), FALSE);
  g_return_val_if_fail(event != nullptr, FALSE);
  g_return_val_if_fail(self->view_delegate != nullptr, FALSE);
 
  guarantee_layout(self, event);
 
  uint64_t incoming_hash = fl_keyboard_manager_get_event_hash(event);
  if (fl_keyboard_manager_remove_redispatched(self, incoming_hash)) {
    return FALSE;
  }
 
  FlKeyboardPendingEvent* pending = fl_keyboard_pending_event_new(
      std::unique_ptr<FlKeyEvent>(event), ++self->last_sequence_id,
      self->responder_list->len);
 
  g_ptr_array_add(self->pending_responds, pending);
  FlKeyboardManagerUserData* user_data =
      fl_keyboard_manager_user_data_new(self, pending->sequence_id);
  DispatchToResponderLoopContext data{
      .event = event,
      .specified_logical_key =
          get_logical_key_from_layout(event, *self->derived_layout),
      .user_data = user_data,
  };
  g_ptr_array_foreach(self->responder_list, dispatch_to_responder, &data);
 
  return TRUE;
}

fl_keyboard_manager_init()

static void fl_keyboard_manager_init ( FlKeyboardManager *  self )

static

Definition at line 308 of file fl_keyboard_manager.cc.

                                                              {
  self->derived_layout = std::make_unique<DerivedLayout>();
 
  self->keycode_to_goals =
      std::make_unique<std::map<uint16_t, const LayoutGoal*>>();
  self->logical_to_mandatory_goals =
      std::make_unique<std::map<uint64_t, const LayoutGoal*>>();
  for (const LayoutGoal& goal : layout_goals) {
    (*self->keycode_to_goals)[goal.keycode] = &goal;
    if (goal.mandatory) {
      (*self->logical_to_mandatory_goals)[goal.logical_key] = &goal;
    }
  }
 
  self->responder_list = g_ptr_array_new_with_free_func(g_object_unref);
 
  self->pending_responds = g_ptr_array_new();
  self->pending_redispatches = g_ptr_array_new_with_free_func(g_object_unref);
 
  self->last_sequence_id = 1;
}

fl_keyboard_manager_is_state_clear()

gboolean fl_keyboard_manager_is_state_clear

(

FlKeyboardManager *

manager

)

fl_keyboard_manager_is_state_clear: @manager: the FlKeyboardManager self.

A debug-only method that queries whether the manager's various states are cleared, i.e. no pending events for redispatching or for responding.

Returns: true if the manager's various states are cleared.

Definition at line 669 of file fl_keyboard_manager.cc.

                                                                     {
  g_return_val_if_fail(FL_IS_KEYBOARD_MANAGER(self), FALSE);
  return self->pending_responds->len == 0 &&
         self->pending_redispatches->len == 0;
}

fl_keyboard_manager_new()

FlKeyboardManager * fl_keyboard_manager_new	(	FlBinaryMessenger *	messenger,
		FlKeyboardViewDelegate *	view_delegate
	)

FlKeyboardManager:

Processes keyboard events and cooperate with TextInputPlugin.

A keyboard event goes through a few sections, each can choose to handle the event, and only unhandled events can move to the next section:

• Keyboard: Dispatch to the embedder responder and the channel responder simultaneously. After both responders have responded (asynchronously), the event is considered handled if either responder handles it.
• Text input: Events are sent to IM filter (usually owned by TextInputPlugin) and are handled synchronously.
• Redispatching: Events are inserted back to the system for redispatching. fl_keyboard_manager_new: @view_delegate: An interface that the manager requires to communicate with the platform. Usually implemented by FlView.

Create a new FlKeyboardManager.

Returns: a new FlKeyboardManager.

Definition at line 585 of file fl_keyboard_manager.cc.

                                           {
  g_return_val_if_fail(FL_IS_KEYBOARD_VIEW_DELEGATE(view_delegate), nullptr);
 
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(
      g_object_new(fl_keyboard_manager_get_type(), nullptr));
 
  self->view_delegate = view_delegate;
  g_object_add_weak_pointer(
      G_OBJECT(view_delegate),
      reinterpret_cast<gpointer*>(&(self->view_delegate)));
 
  // The embedder responder must be added before the channel responder.
  g_ptr_array_add(
      self->responder_list,
      FL_KEY_RESPONDER(fl_key_embedder_responder_new(
          [](const FlutterKeyEvent* event, FlutterKeyEventCallback callback,
             void* callback_user_data, void* send_key_event_user_data) {
            FlKeyboardManager* self =
                FL_KEYBOARD_MANAGER(send_key_event_user_data);
            g_return_if_fail(self->view_delegate != nullptr);
            fl_keyboard_view_delegate_send_key_event(
                self->view_delegate, event, callback, callback_user_data);
          },
          self)));
  g_ptr_array_add(self->responder_list,
                  FL_KEY_RESPONDER(fl_key_channel_responder_new(
                      fl_keyboard_view_delegate_get_messenger(view_delegate))));
 
  fl_keyboard_view_delegate_subscribe_to_layout_change(
      self->view_delegate, [self]() { self->derived_layout->clear(); });
 
  // Setup the flutter/keyboard channel.
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  self->channel =
      fl_method_channel_new(messenger, kChannelName, FL_METHOD_CODEC(codec));
  fl_method_channel_set_method_call_handler(self->channel, method_call_handler,
                                            self, nullptr);
  return self;
}

fl_keyboard_manager_remove_redispatched()

static bool fl_keyboard_manager_remove_redispatched ( FlKeyboardManager *  self, uint64_t  hash  )

static

Definition at line 402 of file fl_keyboard_manager.cc.

                                                                   {
  guint result_index;
  gboolean found = g_ptr_array_find_with_equal_func1(
      self->pending_redispatches, static_cast<const uint64_t*>(&hash),
      compare_pending_by_hash, &result_index);
  if (found) {
    // The removed object is freed due to `pending_redispatches`'s free_func.
    g_ptr_array_remove_index_fast(self->pending_redispatches, result_index);
    return TRUE;
  } else {
    return FALSE;
  }
}

fl_keyboard_manager_sync_modifier_if_needed()

void fl_keyboard_manager_sync_modifier_if_needed	(	FlKeyboardManager *	manager,
		guint	state,
		double	event_time
	)

fl_keyboard_manager_sync_modifier_if_needed: @manager: the FlKeyboardManager 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 675 of file fl_keyboard_manager.cc.

                                                                    {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER(self));
 
  // The embedder responder is the first element in
  // FlKeyboardManager.responder_list.
  FlKeyEmbedderResponder* responder =
      FL_KEY_EMBEDDER_RESPONDER(g_ptr_array_index(self->responder_list, 0));
  fl_key_embedder_responder_sync_modifiers_if_needed(responder, state,
                                                     event_time);
}

fl_keyboard_manager_user_data_class_init()

static void fl_keyboard_manager_user_data_class_init ( FlKeyboardManagerUserDataClass *  klass )

static

Definition at line 229 of file fl_keyboard_manager.cc.

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

fl_keyboard_manager_user_data_init()

static void fl_keyboard_manager_user_data_init ( FlKeyboardManagerUserData *  self )

static

Definition at line 234 of file fl_keyboard_manager.cc.

                                     {}

fl_keyboard_manager_user_data_new()

static FlKeyboardManagerUserData * fl_keyboard_manager_user_data_new ( FlKeyboardManager *  manager, uint64_t  sequence_id  )

static

Definition at line 238 of file fl_keyboard_manager.cc.

                          {
  FlKeyboardManagerUserData* self = FL_KEYBOARD_MANAGER_USER_DATA(
      g_object_new(fl_keyboard_manager_user_data_get_type(), nullptr));
 
  self->manager = manager;
  // 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(manager),
                            reinterpret_cast<gpointer*>(&(self->manager)));
  self->sequence_id = sequence_id;
  return self;
}

fl_keyboard_pending_event_class_init()

static void fl_keyboard_pending_event_class_init ( FlKeyboardPendingEventClass *  klass )

static

Definition at line 159 of file fl_keyboard_manager.cc.

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

fl_keyboard_pending_event_dispose()

static void fl_keyboard_pending_event_dispose ( GObject *  object )

static

Definition at line 147 of file fl_keyboard_manager.cc.

                                                               {
  // Redundant, but added so that we don't get a warning about unused function
  // for FL_IS_KEYBOARD_PENDING_EVENT.
  g_return_if_fail(FL_IS_KEYBOARD_PENDING_EVENT(object));
 
  FlKeyboardPendingEvent* self = FL_KEYBOARD_PENDING_EVENT(object);
  if (self->event != nullptr) {
    fl_key_event_dispose(self->event.release());
  }
  G_OBJECT_CLASS(fl_keyboard_pending_event_parent_class)->dispose(object);
}

fl_keyboard_pending_event_init()

static void fl_keyboard_pending_event_init ( FlKeyboardPendingEvent *  self )

static

Definition at line 164 of file fl_keyboard_manager.cc.

{}

fl_keyboard_pending_event_new()

static FlKeyboardPendingEvent * fl_keyboard_pending_event_new ( std::unique_ptr< FlKeyEvent >  event, uint64_t  sequence_id, size_t  to_reply  )

static

Definition at line 184 of file fl_keyboard_manager.cc.

                     {
  FlKeyboardPendingEvent* self = FL_KEYBOARD_PENDING_EVENT(
      g_object_new(fl_keyboard_pending_event_get_type(), nullptr));
 
  self->event = std::move(event);
  self->sequence_id = sequence_id;
  self->unreplied = to_reply;
  self->any_handled = false;
  self->hash = fl_keyboard_manager_get_event_hash(self->event.get());
  return self;
}

G_DECLARE_FINAL_TYPE() [1/2]

G_DECLARE_FINAL_TYPE	(	FlKeyboardManagerUserData	,
		fl_keyboard_manager_user_data	,
		FL	,
		KEYBOARD_MANAGER_USER_DATA	,
		GObject
	)

G_DECLARE_FINAL_TYPE() [2/2]

G_DECLARE_FINAL_TYPE	(	FlKeyboardPendingEvent	,
		fl_keyboard_pending_event	,
		FL	,
		KEYBOARD_PENDING_EVENT	,
		GObject
	)

G_DEFINE_TYPE() [1/2]

G_DEFINE_TYPE	(	FlKeyboardManager	,
		fl_keyboard_manager	,
		G_TYPE_OBJECT
	)

G_DEFINE_TYPE() [2/2]

G_DEFINE_TYPE	(	FlKeyboardManagerUserData	,
		fl_keyboard_manager_user_data	,
		G_TYPE_OBJECT
	)

Definition at line 215 of file fl_keyboard_manager.cc.

                                                                   {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER_USER_DATA(object));
  FlKeyboardManagerUserData* self = FL_KEYBOARD_MANAGER_USER_DATA(object);
  if (self->manager != nullptr) {
    g_object_remove_weak_pointer(G_OBJECT(self->manager),
                                 reinterpret_cast<gpointer*>(&(self->manager)));
    self->manager = nullptr;
  }
}

g_ptr_array_find_with_equal_func1()

static gboolean g_ptr_array_find_with_equal_func1 ( GPtrArray *  haystack, gconstpointer  needle, GEqualFunc  equal_func, guint *  index_  )

static

Definition at line 359 of file fl_keyboard_manager.cc.

                                                                 {
  guint i;
  g_return_val_if_fail(haystack != NULL, FALSE);
  if (equal_func == NULL) {
    equal_func = g_direct_equal;
  }
  for (i = 0; i < haystack->len; i++) {
    if (equal_func(g_ptr_array_index(haystack, i), needle)) {
      if (index_ != NULL) {
        *index_ = i;
      }
      return TRUE;
    }
  }
 
  return FALSE;
}

get_keyboard_state()

FlMethodResponse * get_keyboard_state

(

FlKeyboardManager *

self

)

Definition at line 544 of file fl_keyboard_manager.cc.

                                                              {
  g_autoptr(FlValue) result = fl_value_new_map();
 
  GHashTable* pressing_records =
      fl_keyboard_view_delegate_get_keyboard_state(self->view_delegate);
 
  g_hash_table_foreach(
      pressing_records,
      [](gpointer key, gpointer value, gpointer user_data) {
        int64_t physical_key = reinterpret_cast<int64_t>(key);
        int64_t logical_key = reinterpret_cast<int64_t>(value);
        FlValue* fl_value_map = reinterpret_cast<FlValue*>(user_data);
 
        fl_value_set_take(fl_value_map, fl_value_new_int(physical_key),
                          fl_value_new_int(logical_key));
      },
      result);
  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
}

get_logical_key_from_layout()

static uint64_t get_logical_key_from_layout ( const FlKeyEvent *  event, const DerivedLayout &  layout  )

static

Definition at line 97 of file fl_keyboard_manager.cc.

                                                                         {
  guint8 group = event->group;
  guint16 keycode = event->keycode;
  if (keycode >= kLayoutSize) {
    return 0;
  }
 
  auto found_group_layout = layout.find(group);
  if (found_group_layout != layout.end()) {
    return found_group_layout->second[keycode];
  }
  return 0;
}

guarantee_layout()

static void guarantee_layout ( FlKeyboardManager *  self, FlKeyEvent *  event  )

static

Definition at line 468 of file fl_keyboard_manager.cc.

                                                                         {
  guint8 group = event->group;
  if (self->derived_layout->find(group) != self->derived_layout->end()) {
    return;
  }
  if (self->keycode_to_goals->find(event->keycode) ==
      self->keycode_to_goals->end()) {
    return;
  }
 
  DerivedGroupLayout& layout = (*self->derived_layout)[group];
 
  // Clone all mandatory goals. Each goal is removed from this cloned map when
  // fulfilled, and the remaining ones will be assigned to a default position.
  std::map<uint64_t, const LayoutGoal*> remaining_mandatory_goals =
      *self->logical_to_mandatory_goals;
 
#ifdef DEBUG_PRINT_LAYOUT
  std::string debug_layout_data;
  for (uint16_t keycode = 0; keycode < 128; keycode += 1) {
    std::vector<uint16_t> this_key_clues = {
        convert_key_to_char(self->view_delegate, keycode, group, 0),
        convert_key_to_char(self->view_delegate, keycode, group, 1),  // Shift
    };
    debug_format_layout_data(debug_layout_data, keycode, this_key_clues[0],
                             this_key_clues[1]);
  }
#endif
 
  // It's important to only traverse layout goals instead of all keycodes.
  // Some key codes outside of the standard keyboard also gives alpha-numeric
  // letters, and will therefore take over mandatory goals from standard
  // keyboard keys if they come first. Example: French keyboard digit 1.
  for (const LayoutGoal& keycode_goal : layout_goals) {
    uint16_t keycode = keycode_goal.keycode;
    std::vector<uint16_t> this_key_clues = {
        convert_key_to_char(self->view_delegate, keycode, group, 0),
        convert_key_to_char(self->view_delegate, keycode, group, 1),  // Shift
    };
 
    // The logical key should be the first available clue from below:
    //
    //  - 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
    //    there are no non-latin logical keys.
    //  - A value derived on the fly from keycode & keyval.
    for (uint16_t clue : this_key_clues) {
      auto matching_goal = remaining_mandatory_goals.find(clue);
      if (matching_goal != remaining_mandatory_goals.end()) {
        // Found a key that produces a mandatory char. Use it.
        g_return_if_fail(layout[keycode] == 0);
        layout[keycode] = clue;
        remaining_mandatory_goals.erase(matching_goal);
        break;
      }
    }
    bool has_any_eascii =
        is_eascii(this_key_clues[0]) || is_eascii(this_key_clues[1]);
    // See if any produced char meets the requirement as a logical key.
    if (layout[keycode] == 0 && !has_any_eascii) {
      auto found_us_layout = self->keycode_to_goals->find(keycode);
      if (found_us_layout != self->keycode_to_goals->end()) {
        layout[keycode] = found_us_layout->second->logical_key;
      }
    }
  }
 
  // Ensure all mandatory goals are assigned.
  for (const auto mandatory_goal_iter : remaining_mandatory_goals) {
    const LayoutGoal* goal = mandatory_goal_iter.second;
    layout[goal->keycode] = goal->logical_key;
  }
}

method_call_handler()

static void method_call_handler ( FlMethodChannel *  channel, FlMethodCall *  method_call, gpointer  user_data  )

static

Definition at line 565 of file fl_keyboard_manager.cc.

                                                    {
  FlKeyboardManager* self = FL_KEYBOARD_MANAGER(user_data);
 
  const gchar* method = fl_method_call_get_name(method_call);
 
  g_autoptr(FlMethodResponse) response = nullptr;
  if (strcmp(method, kGetKeyboardStateMethod) == 0) {
    response = get_keyboard_state(self);
  } else {
    response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
  }
 
  g_autoptr(GError) error = nullptr;
  if (!fl_method_call_respond(method_call, response, &error)) {
    g_warning("Failed to send method call response: %s", error->message);
  }
}

responder_handle_event_callback()

static void responder_handle_event_callback ( bool  handled, gpointer  user_data_ptr  )

static

Definition at line 418 of file fl_keyboard_manager.cc.

                                                                    {
  g_return_if_fail(FL_IS_KEYBOARD_MANAGER_USER_DATA(user_data_ptr));
  FlKeyboardManagerUserData* user_data =
      FL_KEYBOARD_MANAGER_USER_DATA(user_data_ptr);
  FlKeyboardManager* self = user_data->manager;
  g_return_if_fail(self->view_delegate != nullptr);
 
  guint result_index = -1;
  gboolean found = g_ptr_array_find_with_equal_func1(
      self->pending_responds, &user_data->sequence_id,
      compare_pending_by_sequence_id, &result_index);
  g_return_if_fail(found);
  FlKeyboardPendingEvent* pending = FL_KEYBOARD_PENDING_EVENT(
      g_ptr_array_index(self->pending_responds, result_index));
  g_return_if_fail(pending != nullptr);
  g_return_if_fail(pending->unreplied > 0);
  pending->unreplied -= 1;
  pending->any_handled = pending->any_handled || handled;
  // All responders have replied.
  if (pending->unreplied == 0) {
    g_object_unref(user_data_ptr);
    gpointer removed =
        g_ptr_array_remove_index_fast(self->pending_responds, result_index);
    g_return_if_fail(removed == pending);
    bool should_redispatch = !pending->any_handled &&
                             !fl_keyboard_view_delegate_text_filter_key_press(
                                 self->view_delegate, pending->event.get());
    if (should_redispatch) {
      g_ptr_array_add(self->pending_redispatches, pending);
      fl_keyboard_view_delegate_redispatch_event(self->view_delegate,
                                                 std::move(pending->event));
    } else {
      g_object_unref(pending);
    }
  }
}

Variable Documentation

kChannelName

constexpr char kChannelName[] = "flutter/keyboard"

staticconstexpr

Definition at line 22 of file fl_keyboard_manager.cc.

kGetKeyboardStateMethod

constexpr char kGetKeyboardStateMethod[] = "getKeyboardState"

staticconstexpr

Definition at line 23 of file fl_keyboard_manager.cc.