fl_key_embedder_responder.h File Reference

#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_key_event.h"

Go to the source code of this file.

Functions
G_BEGIN_DECLS	G_DECLARE_FINAL_TYPE (FlKeyEmbedderResponder, fl_key_embedder_responder, FL, KEY_EMBEDDER_RESPONDER, GObject)
FlKeyEmbedderResponder *	fl_key_embedder_responder_new (FlEngine *engine)
void	fl_key_embedder_responder_handle_event (FlKeyEmbedderResponder *responder, FlKeyEvent *event, uint64_t specified_logical_key, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_key_embedder_responder_handle_event_finish (FlKeyEmbedderResponder *responder, GAsyncResult *result, gboolean *handled, GError **error)
void	fl_key_embedder_responder_sync_modifiers_if_needed (FlKeyEmbedderResponder *responder, guint state, double event_time)
GHashTable *	fl_key_embedder_responder_get_pressed_state (FlKeyEmbedderResponder *responder)

Function Documentation

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 783 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 737 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.

Completes request started with fl_key_embedder_responder_handle_event().

Returns TRUE on success.

Definition at line 757 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_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 181 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 774 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().

G_DECLARE_FINAL_TYPE()

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE	(	FlKeyEmbedderResponder	,
		fl_key_embedder_responder	,
		FL	,
		KEY_EMBEDDER_RESPONDER	,
		GObject
	)