fl_engine.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"
#include <epoxy/egl.h>
#include <gmodule.h>
#include <cstring>
#include "flutter/common/constants.h"
#include "flutter/shell/platform/common/engine_switches.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_accessibility_handler.h"
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_display_monitor.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"
#include "flutter/shell/platform/linux/fl_keyboard_handler.h"
#include "flutter/shell/platform/linux/fl_opengl_manager.h"
#include "flutter/shell/platform/linux/fl_pixel_buffer_texture_private.h"
#include "flutter/shell/platform/linux/fl_platform_handler.h"
#include "flutter/shell/platform/linux/fl_plugin_registrar_private.h"
#include "flutter/shell/platform/linux/fl_settings_handler.h"
#include "flutter/shell/platform/linux/fl_texture_gl_private.h"
#include "flutter/shell/platform/linux/fl_texture_registrar_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_plugin_registry.h"

Go to the source code of this file.

Classes
struct	_FlEngine

Enumerations
enum	{   SIGNAL_ON_PRE_ENGINE_RESTART ,   SIGNAL_UPDATE_SEMANTICS ,   LAST_SIGNAL }

Functions
static void	fl_engine_plugin_registry_iface_init (FlPluginRegistryInterface *iface)
	G_DEFINE_TYPE_WITH_CODE (FlEngine, fl_engine, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(), fl_engine_plugin_registry_iface_init)) enum
static void	parse_locale (const gchar *locale, gchar **language, gchar **territory, gchar **codeset, gchar **modifier)
static void	set_renderable (FlEngine *self, int64_t view_id, FlRenderable *renderable)
	Stores a weak reference to the renderable with the given ID. More...
static FlRenderable *	get_renderable (FlEngine *self, int64_t view_id)
static void	remove_renderable (FlEngine *self, int64_t view_id)
	Remove a renderable that no longer exists. More...
static void	view_added_cb (const FlutterAddViewResult *result)
static void	view_removed_cb (const FlutterRemoveViewResult *result)
static void	free_locale (FlutterLocale *locale)
static void	setup_locales (FlEngine *self)
static bool	create_opengl_backing_store (FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
static bool	collect_opengl_backing_store (FlEngine *self, const FlutterBackingStore *backing_store)
static bool	create_software_backing_store (FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
static bool	collect_software_backing_store (FlEngine *self, const FlutterBackingStore *backing_store)
static bool	compositor_create_backing_store_callback (const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out, void *user_data)
static bool	compositor_collect_backing_store_callback (const FlutterBackingStore *backing_store, void *user_data)
static bool	compositor_present_view_callback (const FlutterPresentViewInfo *info)
static void *	fl_engine_gl_proc_resolver (void *user_data, const char *name)
static bool	fl_engine_gl_make_current (void *user_data)
static bool	fl_engine_gl_clear_current (void *user_data)
static uint32_t	fl_engine_gl_get_fbo (void *user_data)
static bool	fl_engine_gl_make_resource_current (void *user_data)
static bool	fl_engine_gl_external_texture_frame_callback (void *user_data, int64_t texture_id, size_t width, size_t height, FlutterOpenGLTexture *opengl_texture)
static bool	fl_engine_runs_task_on_current_thread (void *user_data)
static void	fl_engine_post_task (FlutterTask task, uint64_t target_time_nanos, void *user_data)
static void	fl_engine_platform_message_cb (const FlutterPlatformMessage *message, void *user_data)
static void	fl_engine_update_semantics_cb (const FlutterSemanticsUpdate2 *update, void *user_data)
static void	setup_keyboard (FlEngine *self)
static void	fl_engine_on_pre_engine_restart_cb (void *user_data)
static void	fl_engine_platform_message_response_cb (const uint8_t *data, size_t data_length, void *user_data)
static FlPluginRegistrar *	fl_engine_get_registrar_for_plugin (FlPluginRegistry *registry, const gchar *name)
static void	fl_engine_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
static void	fl_engine_dispose (GObject *object)
static void	fl_engine_class_init (FlEngineClass *klass)
static void	fl_engine_init (FlEngine *self)
static FlEngine *	fl_engine_new_full (FlDartProject *project, FlBinaryMessenger *binary_messenger)
FlEngine *	fl_engine_for_id (int64_t id)
G_MODULE_EXPORT FlEngine *	fl_engine_new (FlDartProject *project)
FlEngine *	fl_engine_new_with_binary_messenger (FlBinaryMessenger *binary_messenger)
G_MODULE_EXPORT FlEngine *	fl_engine_new_headless (FlDartProject *project)
FlutterRendererType	fl_engine_get_renderer_type (FlEngine *self)
FlOpenGLManager *	fl_engine_get_opengl_manager (FlEngine *self)
FlDisplayMonitor *	fl_engine_get_display_monitor (FlEngine *self)
gboolean	fl_engine_start (FlEngine *self, GError **error)
FlutterEngineProcTable *	fl_engine_get_embedder_api (FlEngine *self)
void	fl_engine_notify_display_update (FlEngine *self, const FlutterEngineDisplay *displays, size_t displays_length)
void	fl_engine_set_implicit_view (FlEngine *self, FlRenderable *renderable)
FlutterViewId	fl_engine_add_view (FlEngine *self, FlRenderable *renderable, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_engine_add_view_finish (FlEngine *self, GAsyncResult *result, GError **error)
FlRenderable *	fl_engine_get_renderable (FlEngine *self, FlutterViewId view_id)
void	fl_engine_remove_view (FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_engine_remove_view_finish (FlEngine *self, GAsyncResult *result, GError **error)
void	fl_engine_set_platform_message_handler (FlEngine *self, FlEnginePlatformMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
gboolean	fl_engine_send_platform_message_response (FlEngine *self, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
void	fl_engine_send_platform_message (FlEngine *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
GBytes *	fl_engine_send_platform_message_finish (FlEngine *self, GAsyncResult *result, GError **error)
void	fl_engine_send_window_metrics_event (FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio)
void	fl_engine_send_mouse_pointer_event (FlEngine *self, FlutterViewId view_id, FlutterPointerPhase phase, size_t timestamp, double x, double y, FlutterPointerDeviceKind device_kind, double scroll_delta_x, double scroll_delta_y, int64_t buttons, double rotation, double pressure)
void	fl_engine_send_touch_up_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void	fl_engine_send_touch_down_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void	fl_engine_send_touch_move_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void	fl_engine_send_touch_add_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void	fl_engine_send_touch_remove_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void	fl_engine_send_pointer_pan_zoom_event (FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, FlutterPointerPhase phase, double pan_x, double pan_y, double scale, double rotation)
static void	send_key_event_cb (bool handled, void *user_data)
void	fl_engine_send_key_event (FlEngine *self, const FlutterKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean	fl_engine_send_key_event_finish (FlEngine *self, GAsyncResult *result, gboolean *handled, GError **error)
void	fl_engine_dispatch_semantics_action (FlEngine *self, FlutterViewId view_id, uint64_t node_id, FlutterSemanticsAction action, GBytes *data)
gboolean	fl_engine_mark_texture_frame_available (FlEngine *self, int64_t texture_id)
gboolean	fl_engine_register_external_texture (FlEngine *self, int64_t texture_id)
gboolean	fl_engine_unregister_external_texture (FlEngine *self, int64_t texture_id)
G_MODULE_EXPORT FlBinaryMessenger *	fl_engine_get_binary_messenger (FlEngine *self)
FlTaskRunner *	fl_engine_get_task_runner (FlEngine *self)
void	fl_engine_execute_task (FlEngine *self, FlutterTask *task)
G_MODULE_EXPORT FlTextureRegistrar *	fl_engine_get_texture_registrar (FlEngine *self)
void	fl_engine_update_accessibility_features (FlEngine *self, int32_t flags)
void	fl_engine_request_app_exit (FlEngine *self)
FlKeyboardManager *	fl_engine_get_keyboard_manager (FlEngine *self)
FlTextInputHandler *	fl_engine_get_text_input_handler (FlEngine *self)
FlMouseCursorHandler *	fl_engine_get_mouse_cursor_handler (FlEngine *self)

Variables
static constexpr size_t	kPlatformTaskRunnerIdentifier = 1
static constexpr int32_t	kMousePointerDeviceId = 0
static constexpr int32_t	kPointerPanZoomDeviceId = 1
static guint	fl_engine_signals [LAST_SIGNAL]

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SIGNAL_ON_PRE_ENGINE_RESTART
SIGNAL_UPDATE_SEMANTICS
LAST_SIGNAL

Definition at line 117 of file fl_engine.cc.

{ SIGNAL_ON_PRE_ENGINE_RESTART, SIGNAL_UPDATE_SEMANTICS, LAST_SIGNAL };

Function Documentation

collect_opengl_backing_store()

static bool collect_opengl_backing_store ( FlEngine *  self, const FlutterBackingStore *  backing_store  )

static

Definition at line 319 of file fl_engine.cc.

                                              {
  if (!fl_opengl_manager_make_current(self->opengl_manager)) {
    return false;
  }
 
  // OpenGL context is required when destroying #FlFramebuffer.
  g_object_unref(backing_store->open_gl.framebuffer.user_data);
  return true;
}

References fl_opengl_manager_make_current().

Referenced by compositor_collect_backing_store_callback().

collect_software_backing_store()

static bool collect_software_backing_store ( FlEngine *  self, const FlutterBackingStore *  backing_store  )

static

Definition at line 355 of file fl_engine.cc.

                                              {
  free(const_cast<void*>(backing_store->software.allocation));
  return true;
}

Referenced by compositor_collect_backing_store_callback().

compositor_collect_backing_store_callback()

static bool compositor_collect_backing_store_callback ( const FlutterBackingStore *  backing_store, void *  user_data  )

static

Definition at line 379 of file fl_engine.cc.

                     {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  switch (self->renderer_type) {
    case kOpenGL:
      return collect_opengl_backing_store(self, backing_store);
    case kSoftware:
      return collect_software_backing_store(self, backing_store);
    default:
      return false;
  }
}

References collect_opengl_backing_store(), collect_software_backing_store(), and user_data.

Referenced by fl_engine_start().

compositor_create_backing_store_callback()

static bool compositor_create_backing_store_callback ( const FlutterBackingStoreConfig *  config, FlutterBackingStore *  backing_store_out, void *  user_data  )

static

Definition at line 363 of file fl_engine.cc.

                     {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  switch (self->renderer_type) {
    case kOpenGL:
      return create_opengl_backing_store(self, config, backing_store_out);
    case kSoftware:
      return create_software_backing_store(self, config, backing_store_out);
    default:
      return false;
  }
}

References create_opengl_backing_store(), create_software_backing_store(), and user_data.

Referenced by fl_engine_start().

compositor_present_view_callback()

static bool compositor_present_view_callback ( const FlutterPresentViewInfo *  info )

static

Definition at line 394 of file fl_engine.cc.

                                        {
  FlEngine* self = static_cast<FlEngine*>(info->user_data);
 
  g_autoptr(FlRenderable) renderable = get_renderable(self, info->view_id);
  if (renderable == nullptr) {
    return true;
  }
 
  fl_renderable_present_layers(renderable, info->layers, info->layers_count);
  return true;
}

References fl_renderable_present_layers(), g_autoptr(), get_renderable(), and renderable.

Referenced by fl_engine_start().

create_opengl_backing_store()

static bool create_opengl_backing_store ( FlEngine *  self, const FlutterBackingStoreConfig *  config, FlutterBackingStore *  backing_store_out  )

static

Definition at line 282 of file fl_engine.cc.

                                            {
  if (!fl_opengl_manager_make_current(self->opengl_manager)) {
    return false;
  }
 
  GLint sized_format = GL_RGBA8;
  GLint general_format = GL_RGBA;
  if (epoxy_has_gl_extension("GL_EXT_texture_format_BGRA8888")) {
    sized_format = GL_BGRA8_EXT;
    general_format = GL_BGRA_EXT;
  }
 
  FlFramebuffer* framebuffer = fl_framebuffer_new(
      general_format, config->size.width, config->size.height, FALSE);
  if (!framebuffer) {
    g_warning("Failed to create backing store");
    return false;
  }
 
  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
  backing_store_out->open_gl.framebuffer.user_data = framebuffer;
  backing_store_out->open_gl.framebuffer.name =
      fl_framebuffer_get_id(framebuffer);
  backing_store_out->open_gl.framebuffer.target = sized_format;
  backing_store_out->open_gl.framebuffer.destruction_callback = [](void* p) {
    // Backing store destroyed in fl_compositor_opengl_collect_backing_store(),
    // set on FlutterCompositor.collect_backing_store_callback during engine
    // start.
  };
 
  return true;
}

References fl_framebuffer_get_id(), fl_framebuffer_new(), fl_opengl_manager_make_current(), and framebuffer.

Referenced by compositor_create_backing_store_callback().

create_software_backing_store()

static bool create_software_backing_store ( FlEngine *  self, const FlutterBackingStoreConfig *  config, FlutterBackingStore *  backing_store_out  )

static

Definition at line 331 of file fl_engine.cc.

                                            {
  size_t allocation_length = config->size.width * config->size.height * 4;
  uint8_t* allocation = static_cast<uint8_t*>(malloc(allocation_length));
  if (allocation == nullptr) {
    return false;
  }
 
  backing_store_out->type = kFlutterBackingStoreTypeSoftware;
  backing_store_out->software.allocation = allocation;
  backing_store_out->software.height = config->size.height;
  backing_store_out->software.row_bytes = config->size.width * 4;
  backing_store_out->software.user_data = nullptr;
  backing_store_out->software.destruction_callback = [](void* p) {
    // Backing store destroyed in
    // fl_compositor_software_collect_backing_store(), set on
    // FlutterCompositor.collect_backing_store_callback during engine start.
  };
 
  return true;
}

Referenced by compositor_create_backing_store_callback().

fl_engine_add_view()

FlutterViewId fl_engine_add_view	(	FlEngine *	engine,
		FlRenderable *	renderable,
		size_t	min_width,
		size_t	min_height,
		size_t	max_width,
		size_t	max_height,
		double	pixel_ratio,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_engine_add_view: @engine: an #FlEngine. @renderable: the object that will render this view. @min_width: minimum width of view in pixels. @min_height: minimum height of view in pixels. @max_width: maximum width of view in pixels. @max_height: maximum height of view in pixels. @pixel_ratio: scale factor for view. @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.

Asynchronously add a new view. The returned view ID should not be used until this function completes.

Returns: the ID for the view.

Definition at line 961 of file fl_engine.cc.

                                                     {
  g_return_val_if_fail(FL_IS_ENGINE(self), -1);
 
  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
 
  FlutterViewId view_id = self->next_view_id;
  self->next_view_id++;
 
  set_renderable(self, view_id, renderable);
 
  // We don't know which display this view will open on, so set to zero and this
  // will be updated in a following FlutterWindowMetricsEvent
  FlutterEngineDisplayId display_id = 0;
 
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = min_width;
  metrics.height = min_height;
  metrics.pixel_ratio = pixel_ratio;
  metrics.display_id = display_id;
  metrics.view_id = view_id;
  metrics.has_constraints = true;
  metrics.min_width_constraint = min_width;
  metrics.min_height_constraint = min_height;
  metrics.max_width_constraint = max_width;
  metrics.max_height_constraint = max_height;
  FlutterAddViewInfo info;
  info.struct_size = sizeof(FlutterAddViewInfo);
  info.view_id = view_id;
  info.view_metrics = &metrics;
  info.user_data = g_object_ref(task);
  info.add_view_callback = view_added_cb;
  FlutterEngineResult result = self->embedder_api.AddView(self->engine, &info);
  if (result != kSuccess) {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "AddView returned %d",
                            result);
    // This would have been done in the callback, but that won't occur now.
    g_object_unref(task);
  }
 
  return view_id;
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), renderable, set_renderable(), user_data, view_added_cb(), and view_id.

Referenced by fl_view_new_for_engine(), fl_view_new_sized_to_content(), and TEST_F().

fl_engine_add_view_finish()

gboolean fl_engine_add_view_finish	(	FlEngine *	engine,
		GAsyncResult *	result,
		GError **	error
	)

fl_engine_add_view_finish: @engine: an #FlEngine.

Returns

: a #GAsyncResult. @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_engine_add_view().

Returns: TRUE on success.

Definition at line 1014 of file fl_engine.cc.

                                                   {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  return g_task_propagate_boolean(G_TASK(result), error);
}

References error.

Referenced by add_view_cb(), add_view_engine_error_cb(), add_view_error_cb(), and view_added_cb().

fl_engine_class_init()

static void fl_engine_class_init ( FlEngineClass *  klass )

static

Definition at line 640 of file fl_engine.cc.

                                                       {
  G_OBJECT_CLASS(klass)->dispose = fl_engine_dispose;
  G_OBJECT_CLASS(klass)->set_property = fl_engine_set_property;
 
  g_object_class_install_property(
      G_OBJECT_CLASS(klass), PROP_BINARY_MESSENGER,
      g_param_spec_object(
          "binary-messenger", "messenger", "Binary messenger",
          fl_binary_messenger_get_type(),
          static_cast<GParamFlags>(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
                                   G_PARAM_STATIC_STRINGS)));
 
  fl_engine_signals[SIGNAL_ON_PRE_ENGINE_RESTART] = g_signal_new(
      "on-pre-engine-restart", fl_engine_get_type(), G_SIGNAL_RUN_LAST, 0,
      nullptr, nullptr, nullptr, G_TYPE_NONE, 0);
  fl_engine_signals[SIGNAL_UPDATE_SEMANTICS] = g_signal_new(
      "update-semantics", fl_engine_get_type(), G_SIGNAL_RUN_LAST, 0, nullptr,
      nullptr, nullptr, G_TYPE_NONE, 1, G_TYPE_POINTER);
}

References fl_engine_dispose(), fl_engine_set_property(), fl_engine_signals, SIGNAL_ON_PRE_ENGINE_RESTART, and SIGNAL_UPDATE_SEMANTICS.

fl_engine_dispatch_semantics_action()

void fl_engine_dispatch_semantics_action	(	FlEngine *	engine,
		FlutterViewId	view_id,
		uint64_t	node_id,
		FlutterSemanticsAction	action,
		GBytes *	data
	)

fl_engine_dispatch_semantics_action: @engine: an #FlEngine. @view_id: the view that the event occured on. @node_id: the semantics action identifier. @action: the action being dispatched. @data: (allow-none): data associated with the action.

Definition at line 1491 of file fl_engine.cc.

                                                       {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  const uint8_t* action_data = nullptr;
  size_t action_data_length = 0;
  if (data != nullptr) {
    action_data = static_cast<const uint8_t*>(
        g_bytes_get_data(data, &action_data_length));
  }
 
  FlutterSendSemanticsActionInfo info;
  info.struct_size = sizeof(FlutterSendSemanticsActionInfo);
  info.view_id = view_id;
  info.node_id = node_id;
  info.action = action;
  info.data = action_data;
  info.data_length = action_data_length;
  if (self->embedder_api.SendSemanticsAction(self->engine, &info) != kSuccess) {
    g_warning("Failed to send semantics action");
  }
}

References view_id.

Referenced by fl_accessible_node_perform_action_impl(), and TEST_F().

fl_engine_dispose()

static void fl_engine_dispose ( GObject *  object )

static

Definition at line 590 of file fl_engine.cc.

                                               {
  FlEngine* self = FL_ENGINE(object);
 
  if (self->engine != nullptr) {
    if (self->embedder_api.Shutdown(self->engine) != kSuccess) {
      g_warning("Failed to shutdown Flutter engine");
    }
    self->engine = nullptr;
  }
 
  if (self->aot_data != nullptr) {
    if (self->embedder_api.CollectAOTData(self->aot_data) != kSuccess) {
      g_warning("Failed to send collect AOT data");
    }
    self->aot_data = nullptr;
  }
 
  fl_binary_messenger_shutdown(self->binary_messenger);
  fl_texture_registrar_shutdown(self->texture_registrar);
 
  g_clear_object(&self->project);
  g_clear_object(&self->display_monitor);
  g_clear_object(&self->opengl_manager);
  g_clear_object(&self->texture_registrar);
  g_clear_object(&self->binary_messenger);
  g_clear_object(&self->settings_handler);
  g_clear_object(&self->platform_handler);
  g_clear_object(&self->accessibility_handler);
  g_clear_object(&self->keyboard_manager);
  g_clear_object(&self->text_input_handler);
  g_clear_object(&self->keyboard_handler);
  g_clear_object(&self->mouse_cursor_handler);
  g_clear_object(&self->task_runner);
  {
    g_autoptr(GMutexLocker) locker =
        g_mutex_locker_new(&self->renderables_mutex);
    g_clear_pointer(&self->renderables_by_view_id, g_hash_table_unref);
  }
  g_mutex_clear(&self->renderables_mutex);
 
  if (self->platform_message_handler_destroy_notify) {
    self->platform_message_handler_destroy_notify(
        self->platform_message_handler_data);
  }
  self->platform_message_handler_data = nullptr;
  self->platform_message_handler_destroy_notify = nullptr;
 
  G_OBJECT_CLASS(fl_engine_parent_class)->dispose(object);
}

References fl_binary_messenger_shutdown(), fl_texture_registrar_shutdown(), and g_autoptr().

Referenced by fl_engine_class_init().

fl_engine_execute_task()

void fl_engine_execute_task	(	FlEngine *	engine,
		FlutterTask *	task
	)

fl_engine_execute_task: @engine: an #FlEngine. @task: a #FlutterTask to execute.

Executes given Flutter task.

Definition at line 1553 of file fl_engine.cc.

                                                               {
  g_return_if_fail(FL_IS_ENGINE(self));
  if (self->embedder_api.RunTask(self->engine, task) != kSuccess) {
    g_warning("Failed to run task");
  }
}

Referenced by fl_task_runner_process_expired_tasks_locked().

fl_engine_for_id()

FlEngine* fl_engine_for_id

(

int64_t

handle

)

fl_engine_for_id: @handle: an engine identifier obtained through PlatformDispatcher.instance.engineId.

Returns Flutter engine associated with the identifier. The identifier must be valid and for a running engine otherwise the behavior is undefined. Must be called from the main thread.

Returns: a #FlEngine or NULL.

Definition at line 724 of file fl_engine.cc.

                                       {
  void* engine = reinterpret_cast<void*>(id);
  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
  return FL_ENGINE(engine);
}

References id.

Referenced by TEST_F().

fl_engine_get_binary_messenger()

G_MODULE_EXPORT FlBinaryMessenger* fl_engine_get_binary_messenger

(

FlEngine *

engine

)

fl_engine_get_binary_messenger: @engine: an #FlEngine.

Gets the messenger to communicate with this engine.

Returns: an #FlBinaryMessenger.

Definition at line 1542 of file fl_engine.cc.

                    {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->binary_messenger;
}

Referenced by fl_accessibility_handler_new(), fl_keyboard_manager_new(), fl_settings_handler_new(), fl_view_get_registrar_for_plugin(), realize_cb(), and TEST_F().

fl_engine_get_display_monitor()

FlDisplayMonitor* fl_engine_get_display_monitor

(

FlEngine *

engine

)

fl_engine_get_display_monitor: @engine: an #FlEngine.

Gets the display monitor used by this engine.

Returns: an #FlDisplayMonitor.

Definition at line 754 of file fl_engine.cc.

                                                                {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->display_monitor;
}

Referenced by handle_geometry_changed(), and TEST_F().

fl_engine_get_embedder_api()

FlutterEngineProcTable* fl_engine_get_embedder_api

(

FlEngine *

engine

)

fl_engine_get_embedder_api: @engine: an #FlEngine.

Gets the embedder API proc table, allowing modificiations for unit testing.

Returns: a mutable pointer to the embedder API proc table.

Definition at line 940 of file fl_engine.cc.

                                                                   {
  return &(self->embedder_api);
}

Referenced by TEST_F().

fl_engine_get_keyboard_manager()

FlKeyboardManager* fl_engine_get_keyboard_manager

(

FlEngine *

engine

)

fl_engine_get_keyboard_manager: @engine: an #FlEngine.

Gets the keyboard manager used by this engine.

Returns: an #FlKeyboardManager.

Definition at line 1585 of file fl_engine.cc.

                                                                  {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->keyboard_manager;
}

Referenced by handle_key_event(), sync_modifier_if_needed(), and TEST_F().

fl_engine_get_mouse_cursor_handler()

FlMouseCursorHandler* fl_engine_get_mouse_cursor_handler

(

FlEngine *

engine

)

fl_engine_get_mouse_cursor_handler: @engine: an #FlEngine.

Gets the mouse cursor handler used by this engine.

Returns: an #FlMouseCursorHandler.

Definition at line 1595 of file fl_engine.cc.

                                                                         {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->mouse_cursor_handler;
}

Referenced by cursor_changed_cb(), setup_cursor(), and TEST_F().

fl_engine_get_opengl_manager()

FlOpenGLManager* fl_engine_get_opengl_manager

(

FlEngine *

engine

)

fl_engine_get_opengl_manager: @engine: an #FlEngine.

Gets the OpenGL manager used by this engine.

Returns: an #FlOpenGLManager.

Definition at line 749 of file fl_engine.cc.

                                                              {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->opengl_manager;
}

Referenced by realize_cb(), and setup_opengl().

fl_engine_get_registrar_for_plugin()

static FlPluginRegistrar* fl_engine_get_registrar_for_plugin ( FlPluginRegistry *  registry, const gchar *  name  )

static

Definition at line 560 of file fl_engine.cc.

                       {
  FlEngine* self = FL_ENGINE(registry);
 
  return fl_plugin_registrar_new(nullptr, self->binary_messenger,
                                 self->texture_registrar);
}

References fl_plugin_registrar_new().

Referenced by fl_engine_plugin_registry_iface_init().

fl_engine_get_renderable()

FlRenderable* fl_engine_get_renderable	(	FlEngine *	engine,
		FlutterViewId	view_id
	)

fl_engine_get_renderable: @engine: an #FlEngine. @view_id: ID to check.

Gets the renderable associated with the give view ID.

Returns: (transfer full): a reference to an #FlRenderable or NULL if none for this ID.

Definition at line 1021 of file fl_engine.cc.

                                                                              {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
 
  return get_renderable(self, view_id);
}

References get_renderable(), and view_id.

fl_engine_get_renderer_type()

FlutterRendererType fl_engine_get_renderer_type

(

FlEngine *

engine

)

fl_engine_get_renderer_type: @engine: an #FlEngine.

Gets the rendering type used by this engine.

Returns: type of rendering used.

Definition at line 744 of file fl_engine.cc.

                                                                {
  g_return_val_if_fail(FL_IS_ENGINE(self), static_cast<FlutterRendererType>(0));
  return self->renderer_type;
}

Referenced by fl_view_renderer_realize().

fl_engine_get_task_runner()

FlTaskRunner* fl_engine_get_task_runner

(

FlEngine *

engine

)

fl_engine_get_task_runner: @engine: an #FlEngine.

Returns

: a #FlTaskRunner.

Returns: task runner responsible for scheduling Flutter tasks.

Definition at line 1548 of file fl_engine.cc.

                                                        {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->task_runner;
}

Referenced by setup_opengl(), setup_software(), and TEST_F().

fl_engine_get_text_input_handler()

FlTextInputHandler* fl_engine_get_text_input_handler

(

FlEngine *

engine

)

fl_engine_get_text_input_handler: @engine: an #FlEngine.

Gets the text input handler used by this engine.

Returns: an #FlTextInputHandler.

Definition at line 1590 of file fl_engine.cc.

                                                                     {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->text_input_handler;
}

Referenced by fl_view_dispose(), fl_view_focus_in_event(), handle_key_event(), and TEST_F().

fl_engine_get_texture_registrar()

G_MODULE_EXPORT FlTextureRegistrar* fl_engine_get_texture_registrar

(

FlEngine *

engine

)

fl_engine_get_texture_registrar: @engine: an #FlEngine.

Gets the texture registrar for registering textures.

Returns: an #FlTextureRegistrar.

Definition at line 1560 of file fl_engine.cc.

                    {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
  return self->texture_registrar;
}

Referenced by fl_view_get_registrar_for_plugin().

fl_engine_gl_clear_current()

static bool fl_engine_gl_clear_current ( void *  user_data )

static

Definition at line 418 of file fl_engine.cc.

                                                        {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  return fl_opengl_manager_clear_current(self->opengl_manager);
}

References fl_opengl_manager_clear_current(), and user_data.

Referenced by fl_engine_start().

fl_engine_gl_external_texture_frame_callback()

static bool fl_engine_gl_external_texture_frame_callback ( void *  user_data, int64_t  texture_id, size_t  width, size_t  height, FlutterOpenGLTexture *  opengl_texture  )

static

Definition at line 434 of file fl_engine.cc.

                                          {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  if (!self->texture_registrar) {
    return false;
  }
 
  FlTexture* texture =
      fl_texture_registrar_lookup_texture(self->texture_registrar, texture_id);
  if (texture == nullptr) {
    g_warning("Unable to find texture %" G_GINT64_FORMAT, texture_id);
    return false;
  }
 
  gboolean result;
  g_autoptr(GError) error = nullptr;
  if (FL_IS_TEXTURE_GL(texture)) {
    result = fl_texture_gl_populate(FL_TEXTURE_GL(texture), width, height,
                                    opengl_texture, &error);
  } else if (FL_IS_PIXEL_BUFFER_TEXTURE(texture)) {
    result =
        fl_pixel_buffer_texture_populate(FL_PIXEL_BUFFER_TEXTURE(texture),
                                         width, height, opengl_texture, &error);
  } else {
    g_warning("Unsupported texture type %" G_GINT64_FORMAT, texture_id);
    return false;
  }
 
  if (!result) {
    g_warning("%s", error->message);
    return false;
  }
 
  return true;
}

References error, fl_pixel_buffer_texture_populate(), fl_texture_gl_populate(), fl_texture_registrar_lookup_texture(), g_autoptr(), height, texture_id, user_data, and width.

Referenced by fl_engine_start().

fl_engine_gl_get_fbo()

static uint32_t fl_engine_gl_get_fbo ( void *  user_data )

static

Definition at line 423 of file fl_engine.cc.

                                                      {
  // There is only one frame buffer object - always return that.
  return 0;
}

Referenced by fl_engine_start().

fl_engine_gl_make_current()

static bool fl_engine_gl_make_current ( void *  user_data )

static

Definition at line 413 of file fl_engine.cc.

                                                       {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  return fl_opengl_manager_make_current(self->opengl_manager);
}

References fl_opengl_manager_make_current(), and user_data.

Referenced by fl_engine_start().

fl_engine_gl_make_resource_current()

static bool fl_engine_gl_make_resource_current ( void *  user_data )

static

Definition at line 428 of file fl_engine.cc.

                                                                {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  return fl_opengl_manager_make_resource_current(self->opengl_manager);
}

References fl_opengl_manager_make_resource_current(), and user_data.

Referenced by fl_engine_start().

fl_engine_gl_proc_resolver()

static void* fl_engine_gl_proc_resolver ( void *  user_data, const char *  name  )

static

Definition at line 409 of file fl_engine.cc.

                                                                           {
  return reinterpret_cast<void*>(eglGetProcAddress(name));
}

Referenced by fl_engine_start().

fl_engine_init()

static void fl_engine_init ( FlEngine *  self )

static

Definition at line 660 of file fl_engine.cc.

                                           {
  self->thread = g_thread_self();
 
  self->embedder_api.struct_size = sizeof(FlutterEngineProcTable);
  if (FlutterEngineGetProcAddresses(&self->embedder_api) != kSuccess) {
    g_warning("Failed get get engine function pointers");
  }
 
  self->opengl_manager = fl_opengl_manager_new();
 
  self->display_monitor =
      fl_display_monitor_new(self, gdk_display_get_default());
  self->task_runner = fl_task_runner_new(self);
 
  // Implicit view is 0, so start at 1.
  self->next_view_id = 1;
  g_mutex_init(&self->renderables_mutex);
  self->renderables_by_view_id = g_hash_table_new_full(
      g_direct_hash, g_direct_equal, nullptr, [](gpointer value) {
        GWeakRef* ref = static_cast<GWeakRef*>(value);
        g_weak_ref_clear(ref);
        free(ref);
      });
 
  self->texture_registrar = fl_texture_registrar_new(self);
}

References fl_display_monitor_new(), fl_opengl_manager_new(), fl_task_runner_new(), fl_texture_registrar_new(), and value.

fl_engine_mark_texture_frame_available()

gboolean fl_engine_mark_texture_frame_available	(	FlEngine *	engine,
		int64_t	texture_id
	)

fl_engine_mark_texture_frame_available: @engine: an #FlEngine. @texture_id: the identifier of the texture whose frame has been updated.

Tells the Flutter engine that a new texture frame is available for the given texture.

Returns: TRUE on success.

Definition at line 1521 of file fl_engine.cc.

                                                                    {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  return self->embedder_api.MarkExternalTextureFrameAvailable(
             self->engine, texture_id) == kSuccess;
}

References texture_id.

Referenced by mark_texture_frame_available().

fl_engine_new()

G_MODULE_EXPORT FlEngine* fl_engine_new

(

FlDartProject *

project

)

FlEngine:

#FlEngine is an object that contains a running Flutter engine. fl_engine_new: @project: an #FlDartProject.

Creates new Flutter engine.

Returns: a new #FlEngine.

Definition at line 730 of file fl_engine.cc.

                                                                {
  return fl_engine_new_full(project, nullptr);
}

References fl_engine_new_full().

Referenced by fl_engine_new_headless(), fl_view_new(), TEST(), and TEST_F().

fl_engine_new_full()

static FlEngine* fl_engine_new_full ( FlDartProject *  project, FlBinaryMessenger *  binary_messenger  )

static

Definition at line 687 of file fl_engine.cc.

                                                                         {
  g_return_val_if_fail(FL_IS_DART_PROJECT(project), nullptr);
 
  FlEngine* self = FL_ENGINE(g_object_new(fl_engine_get_type(), nullptr));
 
  self->project = FL_DART_PROJECT(g_object_ref(project));
  const gchar* renderer = g_getenv("FLUTTER_LINUX_RENDERER");
  if (g_strcmp0(renderer, "software") == 0) {
    self->renderer_type = kSoftware;
    g_warning(
        "Using the software renderer. Not all features are supported. This is "
        "not recommended.\n"
        "\n"
        "To switch back to the default renderer, unset the "
        "FLUTTER_LINUX_RENDERER environment variable.");
  } else {
    if (renderer != nullptr && strcmp(renderer, "opengl") != 0) {
      g_warning("Unknown renderer type '%s', defaulting to opengl", renderer);
    }
    self->renderer_type = kOpenGL;
  }
 
  if (binary_messenger != nullptr) {
    self->binary_messenger =
        FL_BINARY_MESSENGER(g_object_ref(binary_messenger));
  } else {
    self->binary_messenger = fl_binary_messenger_new(self);
  }
  self->keyboard_manager = fl_keyboard_manager_new(self);
  self->mouse_cursor_handler =
      fl_mouse_cursor_handler_new(self->binary_messenger);
  self->accessibility_handler = fl_accessibility_handler_new(self);
 
  return self;
}

References fl_accessibility_handler_new(), fl_binary_messenger_new(), fl_keyboard_manager_new(), and fl_mouse_cursor_handler_new().

Referenced by fl_engine_new(), and fl_engine_new_with_binary_messenger().

fl_engine_new_headless()

G_MODULE_EXPORT FlEngine* fl_engine_new_headless

(

FlDartProject *

project

)

fl_engine_new_headless: @project: an #FlDartProject.

Creates new Flutter engine running in headless mode.

Returns: a new #FlEngine.

Definition at line 740 of file fl_engine.cc.

                                                                         {
  return fl_engine_new(project);
}

References fl_engine_new().

fl_engine_new_with_binary_messenger()

FlEngine* fl_engine_new_with_binary_messenger

(

FlBinaryMessenger *

binary_messenger

)

fl_engine_new_with_binary_messenger: @binary_messenger: an #FlBinaryMessenger.

Creates a new engine with a custom binary messenger. Used for testing.

Returns: a new #FlEngine.

Definition at line 734 of file fl_engine.cc.

                                         {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  return fl_engine_new_full(project, binary_messenger);
}

References fl_dart_project_new(), fl_engine_new_full(), and g_autoptr().

Referenced by FlAccessibilityHandlerTest::SetUp(), FlKeyboardHandlerTest::SetUp(), and FlSettingsHandlerTest::SetUp().

fl_engine_notify_display_update()

void fl_engine_notify_display_update	(	FlEngine *	engine,
		const FlutterEngineDisplay *	displays,
		size_t	displays_length
	)

fl_engine_notify_display_update: @engine: an #FlEngine. @displays: displays present on the system. @displays_length: length of @displays.

Notify the current displays that are in the system.

Definition at line 944 of file fl_engine.cc.

                                                             {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  FlutterEngineResult result = self->embedder_api.NotifyDisplayUpdate(
      self->engine, kFlutterEngineDisplaysUpdateTypeStartup, displays,
      displays_length);
  if (result != kSuccess) {
    g_warning("Failed to notify display update to Flutter engine: %d", result);
  }
}

Referenced by notify_display_update(), and TEST_F().

fl_engine_on_pre_engine_restart_cb()

static void fl_engine_on_pre_engine_restart_cb ( void *  user_data )

static

Definition at line 541 of file fl_engine.cc.

                                                                {
  FlEngine* self = FL_ENGINE(user_data);
 
  setup_keyboard(self);
 
  g_signal_emit(self, fl_engine_signals[SIGNAL_ON_PRE_ENGINE_RESTART], 0);
}

References fl_engine_signals, setup_keyboard(), SIGNAL_ON_PRE_ENGINE_RESTART, and user_data.

Referenced by fl_engine_start().

fl_engine_platform_message_cb()

static void fl_engine_platform_message_cb ( const FlutterPlatformMessage *  message, void *  user_data  )

static

Definition at line 490 of file fl_engine.cc.

                                                           {
  FlEngine* self = FL_ENGINE(user_data);
 
  gboolean handled = FALSE;
  if (self->platform_message_handler != nullptr) {
    g_autoptr(GBytes) data =
        g_bytes_new(message->message, message->message_size);
    handled = self->platform_message_handler(
        self, message->channel, data, message->response_handle,
        self->platform_message_handler_data);
  }
 
  if (!handled) {
    fl_engine_send_platform_message_response(self, message->response_handle,
                                             nullptr, nullptr);
  }
}

References fl_engine_send_platform_message_response(), g_autoptr(), message, and user_data.

Referenced by fl_engine_start().

fl_engine_platform_message_response_cb()

static void fl_engine_platform_message_response_cb ( const uint8_t *  data, size_t  data_length, void *  user_data  )

static

Definition at line 551 of file fl_engine.cc.

                                                                    {
  g_autoptr(GTask) task = G_TASK(user_data);
  g_task_return_pointer(task, g_bytes_new(data, data_length),
                        reinterpret_cast<GDestroyNotify>(g_bytes_unref));
}

References g_autoptr(), and user_data.

Referenced by fl_engine_send_platform_message().

fl_engine_plugin_registry_iface_init()

static void fl_engine_plugin_registry_iface_init ( FlPluginRegistryInterface *  iface )

static

Definition at line 569 of file fl_engine.cc.

                                      {
  iface->get_registrar_for_plugin = fl_engine_get_registrar_for_plugin;
}

References fl_engine_get_registrar_for_plugin().

fl_engine_post_task()

static void fl_engine_post_task ( FlutterTask  task, uint64_t  target_time_nanos, void *  user_data  )

static

Definition at line 481 of file fl_engine.cc.

                                                 {
  FlEngine* self = static_cast<FlEngine*>(user_data);
 
  fl_task_runner_post_flutter_task(self->task_runner, task, target_time_nanos);
}

References fl_task_runner_post_flutter_task(), and user_data.

Referenced by fl_engine_start().

fl_engine_register_external_texture()

gboolean fl_engine_register_external_texture	(	FlEngine *	engine,
		int64_t	texture_id
	)

fl_engine_register_external_texture: @engine: an #FlEngine. @texture_id: the identifier of the texture that is available.

Tells the Flutter engine that a new external texture is available.

Returns: TRUE on success.

Definition at line 1528 of file fl_engine.cc.

                                                                 {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  return self->embedder_api.RegisterExternalTexture(self->engine, texture_id) ==
         kSuccess;
}

References texture_id.

Referenced by register_texture().

fl_engine_remove_view()

void fl_engine_remove_view	(	FlEngine *	engine,
		FlutterViewId	view_id,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_engine_remove_view: @engine: an #FlEngine. @view_id: ID to remove. @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.

Removes a view previously added with fl_engine_add_view().

Definition at line 1027 of file fl_engine.cc.

                                               {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  remove_renderable(self, view_id);
 
  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
 
  FlutterRemoveViewInfo info;
  info.struct_size = sizeof(FlutterRemoveViewInfo);
  info.view_id = view_id;
  info.user_data = g_object_ref(task);
  info.remove_view_callback = view_removed_cb;
  FlutterEngineResult result =
      self->embedder_api.RemoveView(self->engine, &info);
  if (result != kSuccess) {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "RemoveView returned %d",
                            result);
    // This would have been done in the callback, but that won't occur now.
    g_object_unref(task);
  }
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), remove_renderable(), user_data, view_id, and view_removed_cb().

Referenced by fl_view_dispose(), and TEST_F().

fl_engine_remove_view_finish()

gboolean fl_engine_remove_view_finish	(	FlEngine *	engine,
		GAsyncResult *	result,
		GError **	error
	)

fl_engine_remove_view_finish: @engine: an #FlEngine.

Returns

: a #GAsyncResult. @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_engine_remove_view().

Returns: TRUE on succcess.

Definition at line 1054 of file fl_engine.cc.

                                                      {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  return g_task_propagate_boolean(G_TASK(result), error);
}

References error.

Referenced by remove_view_cb(), remove_view_engine_error_cb(), and remove_view_error_cb().

fl_engine_request_app_exit()

void fl_engine_request_app_exit

(

FlEngine *

engine

)

fl_engine_request_app_exit: @engine: an #FlEngine.

Request the application exits.

Definition at line 1580 of file fl_engine.cc.

                                                {
  g_return_if_fail(FL_IS_ENGINE(self));
  fl_platform_handler_request_app_exit(self->platform_handler);
}

References fl_platform_handler_request_app_exit().

Referenced by window_delete_event_cb().

fl_engine_runs_task_on_current_thread()

static bool fl_engine_runs_task_on_current_thread ( void *  user_data )

static

Definition at line 475 of file fl_engine.cc.

                                                                   {
  FlEngine* self = static_cast<FlEngine*>(user_data);
  return self->thread == g_thread_self();
}

References user_data.

Referenced by fl_engine_start().

fl_engine_send_key_event()

void fl_engine_send_key_event	(	FlEngine *	engine,
		const FlutterKeyEvent *	event,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_engine_send_key_event: @engine: an #FlEngine. @event: key event to send. @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied. @user_data: (closure): user data to pass to @callback.

Send a key event to the engine.

Definition at line 1451 of file fl_engine.cc.

                                                  {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
 
  if (self->engine == nullptr) {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "No engine");
    return;
  }
 
  if (self->embedder_api.SendKeyEvent(self->engine, event, send_key_event_cb,
                                      g_object_ref(task)) != kSuccess) {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "Failed to send key event");
    g_object_unref(task);
  }
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), send_key_event_cb(), and user_data.

Referenced by fl_key_embedder_responder_handle_event(), fl_key_embedder_responder_handle_event_impl(), synthesize_simple_event(), and TEST_F().

fl_engine_send_key_event_finish()

gboolean fl_engine_send_key_event_finish	(	FlEngine *	engine,
		GAsyncResult *	result,
		gboolean *	handled,
		GError **	error
	)

fl_engine_send_key_event_finish: @engine: an #FlEngine.

Returns

: a #GAsyncResult. @handled: location to write if this event was handled by the engine. @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_engine_send_key_event().

Returns: TRUE on success.

Definition at line 1474 of file fl_engine.cc.

                                                         {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  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, and TRUE.

Referenced by TEST_F().

fl_engine_send_mouse_pointer_event()

void fl_engine_send_mouse_pointer_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		FlutterPointerPhase	phase,
		size_t	timestamp,
		double	x,
		double	y,
		FlutterPointerDeviceKind	device_kind,
		double	scroll_delta_x,
		double	scroll_delta_y,
		int64_t	buttons,
		double	rotation,
		double	pressure
	)

fl_engine_send_mouse_pointer_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @phase: mouse phase. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device_kind: kind of pointing device. @scroll_delta_x: x offset of scroll. @scroll_delta_y: y offset of scroll. @buttons: buttons that are pressed. @rotation: rotation of the pointer device in degrees. @pressure: pressure of the pointer device.

Sends a mouse pointer event to the engine.

Definition at line 1215 of file fl_engine.cc.

                                                         {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent fl_event = {};
  fl_event.struct_size = sizeof(fl_event);
  fl_event.phase = phase;
  fl_event.timestamp = timestamp;
  fl_event.x = x;
  fl_event.y = y;
  if (scroll_delta_x != 0 || scroll_delta_y != 0) {
    fl_event.signal_kind = kFlutterPointerSignalKindScroll;
  }
  fl_event.scroll_delta_x = scroll_delta_x;
  fl_event.scroll_delta_y = scroll_delta_y;
  fl_event.device_kind = device_kind;
  fl_event.buttons = buttons;
  fl_event.device = kMousePointerDeviceId;
  fl_event.view_id = view_id;
  // GDK reports tablet pressure through GDK_AXIS_PRESSURE. The GDK input device
  // documentation defines pressure as normalized from 0.0 to 1.0, which matches
  // Flutter's expected pressure range.
  // See: https://refspecs.linuxbase.org/gtk/2.6/gdk/gdk-Input-Devices.html
  fl_event.pressure = pressure;
  fl_event.pressure_min = 0.0;
  fl_event.pressure_max = 1.0;
  // GTK reports rotation in degrees, so convert it to radians for
  // FlutterPointerEvent.rotation.
  fl_event.rotation = rotation * G_PI / 180.0;
  if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References kMousePointerDeviceId, view_id, x, and y.

Referenced by ensure_pointer_added(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_leave(), fl_pointer_manager_handle_motion(), fl_scrolling_manager_handle_scroll_event(), and TEST_F().

fl_engine_send_platform_message()

void fl_engine_send_platform_message	(	FlEngine *	engine,
		const gchar *	channel,
		GBytes *	message,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_engine_send_platform_message: @engine: an #FlEngine. @channel: channel to send to. @message: (allow-none): message buffer to send or NULL for an empty message @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied. @user_data: (closure): user data to pass to @callback.

Asynchronously sends a platform message.

Definition at line 1112 of file fl_engine.cc.

                                                         {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  GTask* task = nullptr;
  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
  if (callback != nullptr) {
    task = g_task_new(self, cancellable, callback, user_data);
 
    if (self->engine == nullptr) {
      g_task_return_new_error(task, fl_engine_error_quark(),
                              FL_ENGINE_ERROR_FAILED, "No engine to send to");
      g_object_unref(task);
      return;
    }
 
    FlutterEngineResult result =
        self->embedder_api.PlatformMessageCreateResponseHandle(
            self->engine, fl_engine_platform_message_response_cb, task,
            &response_handle);
    if (result != kSuccess) {
      g_task_return_new_error(task, fl_engine_error_quark(),
                              FL_ENGINE_ERROR_FAILED,
                              "Failed to create response handle");
      g_object_unref(task);
      return;
    }
  } else if (self->engine == nullptr) {
    return;
  }
 
  FlutterPlatformMessage fl_message = {};
  fl_message.struct_size = sizeof(fl_message);
  fl_message.channel = channel;
  fl_message.message =
      message != nullptr
          ? static_cast<const uint8_t*>(g_bytes_get_data(message, nullptr))
          : nullptr;
  fl_message.message_size = message != nullptr ? g_bytes_get_size(message) : 0;
  fl_message.response_handle = response_handle;
  FlutterEngineResult result =
      self->embedder_api.SendPlatformMessage(self->engine, &fl_message);
 
  if (result != kSuccess && task != nullptr) {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED,
                            "Failed to send platform messages");
    g_object_unref(task);
  }
 
  if (response_handle != nullptr) {
    if (self->embedder_api.PlatformMessageReleaseResponseHandle(
            self->engine, response_handle) != kSuccess) {
      g_warning("Failed to release response handle");
    }
  }
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), fl_engine_platform_message_response_cb(), message, and user_data.

Referenced by send_on_channel(), and TEST_F().

fl_engine_send_platform_message_finish()

GBytes* fl_engine_send_platform_message_finish	(	FlEngine *	engine,
		GAsyncResult *	result,
		GError **	error
	)

fl_engine_send_platform_message_finish: @engine: an #FlEngine.

Returns

: a #GAsyncResult. @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_engine_send_platform_message().

Returns: message response on success or NULL on error.

Definition at line 1174 of file fl_engine.cc.

                                                               {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
 
  return static_cast<GBytes*>(g_task_propagate_pointer(G_TASK(result), error));
}

References error.

Referenced by send_on_channel_finish().

fl_engine_send_platform_message_response()

gboolean fl_engine_send_platform_message_response	(	FlEngine *	engine,
		const FlutterPlatformMessageResponseHandle *	handle,
		GBytes *	response,
		GError **	error
	)

fl_engine_send_platform_message_response: @engine: an #FlEngine. @handle: handle that was provided in FlEnginePlatformMessageHandler. @response: (allow-none): response to send or NULL for an empty response. @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).

Responds to a platform message.

Returns: TRUE on success.

Definition at line 1080 of file fl_engine.cc.

                    {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  g_return_val_if_fail(handle != nullptr, FALSE);
 
  if (self->engine == nullptr) {
    g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                "No engine to send response to");
    return FALSE;
  }
 
  gsize data_length = 0;
  const uint8_t* data = nullptr;
  if (response != nullptr) {
    data =
        static_cast<const uint8_t*>(g_bytes_get_data(response, &data_length));
  }
  FlutterEngineResult result = self->embedder_api.SendPlatformMessageResponse(
      self->engine, handle, data, data_length);
 
  if (result != kSuccess) {
    g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                "Failed to send platform message response");
    return FALSE;
  }
 
  return TRUE;
}

References error, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), and TRUE.

Referenced by fl_engine_platform_message_cb(), send_response(), and TEST_F().

fl_engine_send_pointer_pan_zoom_event()

void fl_engine_send_pointer_pan_zoom_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		FlutterPointerPhase	phase,
		double	pan_x,
		double	pan_y,
		double	scale,
		double	rotation
	)

fl_engine_send_pointer_pan_zoom_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @phase: mouse phase. @pan_x: x offset of the pan/zoom in pixels. @pan_y: y offset of the pan/zoom in pixels. @scale: scale of the pan/zoom. @rotation: rotation of the pan/zoom in radians.

Sends a pan/zoom pointer event to the engine.

Definition at line 1409 of file fl_engine.cc.

                                                            {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent fl_event = {};
  fl_event.struct_size = sizeof(fl_event);
  fl_event.timestamp = timestamp;
  fl_event.x = x;
  fl_event.y = y;
  fl_event.phase = phase;
  fl_event.pan_x = pan_x;
  fl_event.pan_y = pan_y;
  fl_event.scale = scale;
  fl_event.rotation = rotation;
  fl_event.device = kPointerPanZoomDeviceId;
  fl_event.device_kind = kFlutterPointerDeviceKindTrackpad;
  fl_event.view_id = view_id;
  if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References kPointerPanZoomDeviceId, view_id, x, and y.

Referenced by fl_scrolling_manager_handle_rotation_begin(), fl_scrolling_manager_handle_rotation_end(), fl_scrolling_manager_handle_rotation_update(), fl_scrolling_manager_handle_scroll_event(), fl_scrolling_manager_handle_zoom_begin(), fl_scrolling_manager_handle_zoom_end(), fl_scrolling_manager_handle_zoom_update(), and TEST_F().

fl_engine_send_touch_add_event()

void fl_engine_send_touch_add_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		int32_t	device
	)

fl_engine_send_touch_add_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device: device id.

Sends a touch add event to the engine.

Definition at line 1351 of file fl_engine.cc.

                                                    {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent event;
  event.timestamp = timestamp;
  event.x = x;
  event.y = y;
  event.device_kind = kFlutterPointerDeviceKindTouch;
  event.device = device;
  event.buttons = 0;
  event.view_id = view_id;
  event.phase = FlutterPointerPhase::kAdd;
  event.struct_size = sizeof(event);
 
  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References view_id, x, and y.

Referenced by ensure_touch_added().

fl_engine_send_touch_down_event()

void fl_engine_send_touch_down_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		int32_t	device
	)

fl_engine_send_touch_down_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device: device id.

Sends a touch down event to the engine.

Definition at line 1293 of file fl_engine.cc.

                                                     {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent event;
  event.timestamp = timestamp;
  event.x = x;
  event.y = y;
  event.device_kind = kFlutterPointerDeviceKindTouch;
  event.device = device;
  event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
  event.view_id = view_id;
  event.phase = FlutterPointerPhase::kDown;
  event.struct_size = sizeof(event);
 
  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References view_id, x, and y.

Referenced by fl_touch_manager_handle_touch_event().

fl_engine_send_touch_move_event()

void fl_engine_send_touch_move_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		int32_t	device
	)

fl_engine_send_touch_move_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device: device id.

Sends a touch move event to the engine.

Definition at line 1322 of file fl_engine.cc.

                                                     {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent event;
  event.timestamp = timestamp;
  event.x = x;
  event.y = y;
  event.device_kind = kFlutterPointerDeviceKindTouch;
  event.device = device;
  event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
  event.view_id = view_id;
  event.phase = FlutterPointerPhase::kMove;
  event.struct_size = sizeof(event);
 
  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References view_id, x, and y.

Referenced by fl_touch_manager_handle_touch_event().

fl_engine_send_touch_remove_event()

void fl_engine_send_touch_remove_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		int32_t	device
	)

fl_engine_send_touch_remove_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device: device id.

Sends a touch remove event to the engine.

Definition at line 1380 of file fl_engine.cc.

                                                       {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent event;
  event.timestamp = timestamp;
  event.x = x;
  event.y = y;
  event.device_kind = kFlutterPointerDeviceKindTouch;
  event.device = device;
  event.buttons = 0;
  event.view_id = view_id;
  event.phase = FlutterPointerPhase::kRemove;
  event.struct_size = sizeof(event);
 
  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References view_id, x, and y.

Referenced by fl_touch_manager_handle_touch_event().

fl_engine_send_touch_up_event()

void fl_engine_send_touch_up_event	(	FlEngine *	engine,
		FlutterViewId	view_id,
		size_t	timestamp,
		double	x,
		double	y,
		int32_t	device
	)

fl_engine_send_touch_up_event: @engine: an #FlEngine. @view_id: the view that the event occured on. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @device: device id.

Sends a touch up event to the engine.

Definition at line 1264 of file fl_engine.cc.

                                                   {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterPointerEvent event;
  event.timestamp = timestamp;
  event.x = x;
  event.y = y;
  event.device_kind = kFlutterPointerDeviceKindTouch;
  event.device = device;
  event.buttons = 0;
  event.view_id = view_id;
  event.phase = FlutterPointerPhase::kUp;
  event.struct_size = sizeof(event);
 
  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References view_id, x, and y.

Referenced by fl_touch_manager_handle_touch_event().

fl_engine_send_window_metrics_event()

void fl_engine_send_window_metrics_event	(	FlEngine *	engine,
		FlutterEngineDisplayId	display_id,
		FlutterViewId	view_id,
		size_t	min_width,
		size_t	min_height,
		size_t	max_width,
		size_t	max_height,
		double	pixel_ratio
	)

fl_engine_send_window_metrics_event: @engine: an #FlEngine. @display_id: the display this view is rendering on. @view_id: the view that the event occured on. @min_width: minimum width of view in pixels. @min_height: minimum height of view in pixels. @max_width: maximum width of view in pixels. @max_height: maximum height of view in pixels. @pixel_ratio: scale factor for view.

Sends a window metrics event to the engine.

Definition at line 1183 of file fl_engine.cc.

                                                             {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(FlutterWindowMetricsEvent);
  event.width = min_width;
  event.height = min_height;
  event.pixel_ratio = pixel_ratio;
  event.display_id = display_id;
  event.view_id = view_id;
  event.has_constraints = true;
  event.min_width_constraint = min_width;
  event.min_height_constraint = min_height;
  event.max_width_constraint = max_width;
  event.max_height_constraint = max_height;
  if (self->embedder_api.SendWindowMetricsEvent(self->engine, &event) !=
      kSuccess) {
    g_warning("Failed to send window metrics");
  }
}

References view_id.

Referenced by handle_geometry_changed(), and TEST_F().

fl_engine_set_implicit_view()

void fl_engine_set_implicit_view	(	FlEngine *	engine,
		FlRenderable *	renderable
	)

fl_engine_set_implicit_view: @engine: an #FlEngine. @renderable: the object that will render the implicit view.

Sets the object to render the implicit view.

Definition at line 957 of file fl_engine.cc.

                                                                           {
  set_renderable(self, flutter::kFlutterImplicitViewId, renderable);
}

References renderable, and set_renderable().

Referenced by fl_view_new(), and FlCompositorOpenGLTest::SetUp().

fl_engine_set_platform_message_handler()

void fl_engine_set_platform_message_handler	(	FlEngine *	engine,
		FlEnginePlatformMessageHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_engine_set_platform_message_handler: @engine: an #FlEngine. @handler: function to call when a platform message is received. @user_data: (closure): user data to pass to @handler. @destroy_notify: (allow-none): a function which gets called to free @user_data, or NULL.

Registers the function called when a platform message is received. Call fl_engine_send_platform_message_response() with the response to this message. Ownership of #FlutterPlatformMessageResponseHandle is transferred to the caller, and the message must be responded to avoid memory leaks.

Definition at line 1061 of file fl_engine.cc.

                                   {
  g_return_if_fail(FL_IS_ENGINE(self));
  g_return_if_fail(handler != nullptr);
 
  if (self->platform_message_handler_destroy_notify) {
    self->platform_message_handler_destroy_notify(
        self->platform_message_handler_data);
  }
 
  self->platform_message_handler = handler;
  self->platform_message_handler_data = user_data;
  self->platform_message_handler_destroy_notify = destroy_notify;
}

References user_data.

Referenced by fl_binary_messenger_new().

fl_engine_set_property()

static void fl_engine_set_property ( GObject *  object, guint  prop_id, const GValue *  value, GParamSpec *  pspec  )

static

Definition at line 574 of file fl_engine.cc.

                                                      {
  FlEngine* self = FL_ENGINE(object);
  switch (prop_id) {
    case PROP_BINARY_MESSENGER:
      g_set_object(&self->binary_messenger,
                   FL_BINARY_MESSENGER(g_value_get_object(value)));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
  }
}

References prop_id, pspec, and value.

Referenced by fl_engine_class_init().

fl_engine_start()

gboolean fl_engine_start	(	FlEngine *	engine,
		GError **	error
	)

fl_engine_start: @engine: an #FlEngine. @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).

Starts the Flutter engine.

Returns: TRUE on success.

Definition at line 759 of file fl_engine.cc.

                                                         {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
 
  FlutterRendererConfig config = {};
  config.type = self->renderer_type;
  switch (config.type) {
    case kSoftware:
      config.software.struct_size = sizeof(FlutterSoftwareRendererConfig);
      // No action required, as this is handled in
      // compositor_present_view_callback.
      config.software.surface_present_callback =
          [](void* user_data, const void* allocation, size_t row_bytes,
             size_t height) { return true; };
      break;
    case kOpenGL:
      config.open_gl.struct_size = sizeof(FlutterOpenGLRendererConfig);
      config.open_gl.gl_proc_resolver = fl_engine_gl_proc_resolver;
      config.open_gl.make_current = fl_engine_gl_make_current;
      config.open_gl.clear_current = fl_engine_gl_clear_current;
      config.open_gl.fbo_callback = fl_engine_gl_get_fbo;
      // No action required, as this is handled in
      // compositor_present_view_callback.
      config.open_gl.present = [](void* user_data) { return true; };
      config.open_gl.make_resource_current = fl_engine_gl_make_resource_current;
      config.open_gl.gl_external_texture_frame_callback =
          fl_engine_gl_external_texture_frame_callback;
      break;
    case kMetal:
    case kVulkan:
    default:
      g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                  "Unsupported renderer type");
      return FALSE;
  }
 
  FlutterTaskRunnerDescription platform_task_runner = {};
  platform_task_runner.struct_size = sizeof(FlutterTaskRunnerDescription);
  platform_task_runner.user_data = self;
  platform_task_runner.runs_task_on_current_thread_callback =
      fl_engine_runs_task_on_current_thread;
  platform_task_runner.post_task_callback = fl_engine_post_task;
  platform_task_runner.identifier = kPlatformTaskRunnerIdentifier;
 
  FlutterCustomTaskRunners custom_task_runners = {};
  custom_task_runners.struct_size = sizeof(FlutterCustomTaskRunners);
  custom_task_runners.platform_task_runner = &platform_task_runner;
 
  switch (fl_dart_project_get_ui_thread_policy(self->project)) {
    case FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD:
      break;
    case FL_UI_THREAD_POLICY_DEFAULT:
    case FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD:
      custom_task_runners.ui_task_runner = &platform_task_runner;
      break;
  }
 
  const std::vector<std::string> env_switches =
      flutter::GetSwitchesFromEnvironment();
 
  gboolean enable_impeller = fl_dart_project_get_enable_impeller(self->project);
  gboolean has_enable_impeller = FALSE;
  for (const auto& env_switch : env_switches) {
    if (env_switch == "--enable-impeller" ||
        env_switch == "--enable-impeller=true") {
      enable_impeller = TRUE;
      has_enable_impeller = TRUE;
    } else if (env_switch == "--enable-impeller=false") {
      enable_impeller = FALSE;
      has_enable_impeller = TRUE;
    }
  }
 
  g_autoptr(GPtrArray) command_line_args =
      g_ptr_array_new_with_free_func(g_free);
  g_ptr_array_insert(command_line_args, 0, g_strdup("flutter"));
  for (const auto& env_switch : env_switches) {
    g_ptr_array_add(command_line_args, g_strdup(env_switch.c_str()));
  }
  // Linux (and other desktop platforms) always uses SDFs.
  g_ptr_array_add(command_line_args, g_strdup("--impeller-use-sdfs"));
 
  if (enable_impeller && !has_enable_impeller) {
    g_ptr_array_add(command_line_args, g_strdup("--enable-impeller"));
  }
 
  // Forward the project's Flutter GPU setting unless an environment switch
  // already carries it (the switch is presence based, so it is only ever
  // added, never negated).
  if (fl_dart_project_get_enable_flutter_gpu(self->project)) {
    gboolean has_enable_flutter_gpu = FALSE;
    for (const auto& env_switch : env_switches) {
      if (env_switch == "--enable-flutter-gpu" ||
          env_switch == "--enable-flutter-gpu=true") {
        has_enable_flutter_gpu = TRUE;
        break;
      }
    }
    if (!has_enable_flutter_gpu) {
      g_ptr_array_add(command_line_args, g_strdup("--enable-flutter-gpu"));
    }
  }
 
  gchar** dart_entrypoint_args =
      fl_dart_project_get_dart_entrypoint_arguments(self->project);
 
  FlutterProjectArgs args = {};
  args.struct_size = sizeof(FlutterProjectArgs);
  args.assets_path = fl_dart_project_get_assets_path(self->project);
  args.icu_data_path = fl_dart_project_get_icu_data_path(self->project);
  args.command_line_argc = command_line_args->len;
  args.command_line_argv =
      reinterpret_cast<const char* const*>(command_line_args->pdata);
  args.platform_message_callback = fl_engine_platform_message_cb;
  args.update_semantics_callback2 = fl_engine_update_semantics_cb;
  args.custom_task_runners = &custom_task_runners;
  args.shutdown_dart_vm_when_done = true;
  args.on_pre_engine_restart_callback = fl_engine_on_pre_engine_restart_cb;
  args.dart_entrypoint_argc =
      dart_entrypoint_args != nullptr ? g_strv_length(dart_entrypoint_args) : 0;
  args.dart_entrypoint_argv =
      reinterpret_cast<const char* const*>(dart_entrypoint_args);
  args.engine_id = reinterpret_cast<int64_t>(self);
 
  FlutterCompositor compositor = {};
  compositor.struct_size = sizeof(FlutterCompositor);
  compositor.user_data = self;
  compositor.create_backing_store_callback =
      compositor_create_backing_store_callback;
  compositor.collect_backing_store_callback =
      compositor_collect_backing_store_callback;
  compositor.present_view_callback = compositor_present_view_callback;
  args.compositor = &compositor;
 
  if (self->embedder_api.RunsAOTCompiledDartCode()) {
    FlutterEngineAOTDataSource source = {};
    source.type = kFlutterEngineAOTDataSourceTypeElfPath;
    source.elf_path = fl_dart_project_get_aot_library_path(self->project);
    if (self->embedder_api.CreateAOTData(&source, &self->aot_data) !=
        kSuccess) {
      g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                  "Failed to create AOT data");
      return FALSE;
    }
    args.aot_data = self->aot_data;
  }
 
  FlutterEngineResult result = self->embedder_api.Initialize(
      FLUTTER_ENGINE_VERSION, &config, &args, self, &self->engine);
  if (result != kSuccess) {
    g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                "Failed to initialize Flutter engine");
    return FALSE;
  }
 
  result = self->embedder_api.RunInitialized(self->engine);
  if (result != kSuccess) {
    g_set_error(error, fl_engine_error_quark(), FL_ENGINE_ERROR_FAILED,
                "Failed to run Flutter engine");
    return FALSE;
  }
 
  setup_locales(self);
 
  g_autoptr(FlSettings) settings = fl_settings_new();
  self->settings_handler = fl_settings_handler_new(self);
  fl_settings_handler_start(self->settings_handler, settings);
 
  self->platform_handler = fl_platform_handler_new(self->binary_messenger);
 
  setup_keyboard(self);
 
  result = self->embedder_api.UpdateSemanticsEnabled(self->engine, TRUE);
  if (result != kSuccess) {
    g_warning("Failed to enable accessibility features on Flutter engine");
  }
 
  fl_display_monitor_start(self->display_monitor);
 
  return TRUE;
}

References args, compositor_collect_backing_store_callback(), compositor_create_backing_store_callback(), compositor_present_view_callback(), error, fl_dart_project_get_aot_library_path(), fl_dart_project_get_assets_path(), fl_dart_project_get_dart_entrypoint_arguments(), fl_dart_project_get_enable_flutter_gpu(), fl_dart_project_get_enable_impeller(), fl_dart_project_get_icu_data_path(), fl_dart_project_get_ui_thread_policy(), fl_display_monitor_start(), FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), fl_engine_gl_clear_current(), fl_engine_gl_external_texture_frame_callback(), fl_engine_gl_get_fbo(), fl_engine_gl_make_current(), fl_engine_gl_make_resource_current(), fl_engine_gl_proc_resolver(), fl_engine_on_pre_engine_restart_cb(), fl_engine_platform_message_cb(), fl_engine_post_task(), fl_engine_runs_task_on_current_thread(), fl_engine_update_semantics_cb(), fl_platform_handler_new(), fl_settings_handler_new(), fl_settings_handler_start(), fl_settings_new(), FL_UI_THREAD_POLICY_DEFAULT, FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD, FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD, g_autoptr(), flutter::GetSwitchesFromEnvironment(), height, kPlatformTaskRunnerIdentifier, setup_keyboard(), setup_locales(), TRUE, and user_data.

Referenced by realize_cb(), and TEST_F().

fl_engine_unregister_external_texture()

gboolean fl_engine_unregister_external_texture	(	FlEngine *	engine,
		int64_t	texture_id
	)

fl_engine_unregister_external_texture: @engine: an #FlEngine. @texture_id: the identifier of the texture that is not available anymore.

Tells the Flutter engine that an existing external texture is not available anymore.

Returns: TRUE on success.

Definition at line 1535 of file fl_engine.cc.

                                                                   {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
  return self->embedder_api.UnregisterExternalTexture(self->engine,
                                                      texture_id) == kSuccess;
}

References texture_id.

Referenced by unregister_texture().

fl_engine_update_accessibility_features()

void fl_engine_update_accessibility_features	(	FlEngine *	engine,
		int32_t	flags
	)

fl_engine_update_accessibility_features: @engine: an #FlEngine. @flags: the features to enable in the accessibility tree.

Tells the Flutter engine to update the flags on the accessibility tree.

Definition at line 1566 of file fl_engine.cc.

                                                                            {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  if (self->embedder_api.UpdateAccessibilityFeatures(
          self->engine, static_cast<FlutterAccessibilityFeature>(flags)) !=
      kSuccess) {
    g_warning("Failed to update accessibility features");
  }
}

Referenced by update_settings().

fl_engine_update_semantics_cb()

static void fl_engine_update_semantics_cb ( const FlutterSemanticsUpdate2 *  update, void *  user_data  )

static

Definition at line 510 of file fl_engine.cc.

                                                           {
  FlEngine* self = FL_ENGINE(user_data);
 
  g_signal_emit(self, fl_engine_signals[SIGNAL_UPDATE_SEMANTICS], 0, update);
}

References fl_engine_signals, SIGNAL_UPDATE_SEMANTICS, and user_data.

Referenced by fl_engine_start().

free_locale()

static void free_locale ( FlutterLocale *  locale )

static

Definition at line 225 of file fl_engine.cc.

                                               {
  g_free(const_cast<gchar*>(locale->language_code));
  g_free(const_cast<gchar*>(locale->country_code));
  g_free(locale);
}

Referenced by setup_locales().

G_DEFINE_TYPE_WITH_CODE()

G_DEFINE_TYPE_WITH_CODE	(	FlEngine	,
		fl_engine	,
		G_TYPE_OBJECT	,
		G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(), fl_engine_plugin_registry_iface_init)
	)

Definition at line 121 of file fl_engine.cc.

     { PROP_0, PROP_BINARY_MESSENGER, PROP_LAST };

References PROP_0, and PROP_LAST.

get_renderable()

static FlRenderable* get_renderable ( FlEngine *  self, int64_t  view_id  )

static

Returns the renderable with the given ID, or nullptr if no such view exists. Returns a reference to the renderable.

Definition at line 187 of file fl_engine.cc.

                                                                     {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
  GWeakRef* ref = static_cast<GWeakRef*>(g_hash_table_lookup(
      self->renderables_by_view_id, GINT_TO_POINTER(view_id)));
  if (ref == nullptr) {
    return nullptr;
  }
  return FL_RENDERABLE(g_weak_ref_get(ref));
}

References g_autoptr(), and view_id.

Referenced by compositor_present_view_callback(), and fl_engine_get_renderable().

parse_locale()

static void parse_locale ( const gchar *  locale, gchar **  language, gchar **  territory, gchar **  codeset, gchar **  modifier  )

static

Definition at line 131 of file fl_engine.cc.

                                           {
  gchar* l = g_strdup(locale);
 
  // Locales are in the form "language[_territory][.codeset][@modifier]"
  gchar* match = strrchr(l, '@');
  if (match != nullptr) {
    if (modifier != nullptr) {
      *modifier = g_strdup(match + 1);
    }
    *match = '\0';
  } else if (modifier != nullptr) {
    *modifier = nullptr;
  }
 
  match = strrchr(l, '.');
  if (match != nullptr) {
    if (codeset != nullptr) {
      *codeset = g_strdup(match + 1);
    }
    *match = '\0';
  } else if (codeset != nullptr) {
    *codeset = nullptr;
  }
 
  match = strrchr(l, '_');
  if (match != nullptr) {
    if (territory != nullptr) {
      *territory = g_strdup(match + 1);
    }
    *match = '\0';
  } else if (territory != nullptr) {
    *territory = nullptr;
  }
 
  if (language != nullptr) {
    *language = l;
  }
}

Referenced by setup_locales().

remove_renderable()

static void remove_renderable ( FlEngine *  self, int64_t  view_id  )

static

Remove a renderable that no longer exists.

Definition at line 198 of file fl_engine.cc.

                                                               {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
  g_hash_table_remove(self->renderables_by_view_id, GINT_TO_POINTER(view_id));
}

References g_autoptr(), and view_id.

Referenced by fl_engine_remove_view().

send_key_event_cb()

static void send_key_event_cb ( bool  handled, void *  user_data  )

static

Definition at line 1444 of file fl_engine.cc.

                                                             {
  g_autoptr(GTask) task = G_TASK(user_data);
  gboolean* return_value = g_new0(gboolean, 1);
  *return_value = handled;
  g_task_return_pointer(task, return_value, g_free);
}

References g_autoptr(), and user_data.

Referenced by fl_engine_send_key_event().

set_renderable()

static void set_renderable ( FlEngine *  self, int64_t  view_id, FlRenderable *  renderable  )

static

Stores a weak reference to the renderable with the given ID.

Definition at line 175 of file fl_engine.cc.

                                                     {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
  GWeakRef* ref = g_new(GWeakRef, 1);
  g_weak_ref_init(ref, G_OBJECT(renderable));
  g_hash_table_insert(self->renderables_by_view_id, GINT_TO_POINTER(view_id),
                      ref);
}

References g_autoptr(), renderable, and view_id.

Referenced by fl_engine_add_view(), and fl_engine_set_implicit_view().

setup_keyboard()

static void setup_keyboard ( FlEngine *  self )

static

Definition at line 517 of file fl_engine.cc.

                                           {
  g_clear_object(&self->keyboard_manager);
  self->keyboard_manager = fl_keyboard_manager_new(self);
 
  g_clear_object(&self->keyboard_handler);
  self->keyboard_handler =
      fl_keyboard_handler_new(self->binary_messenger, self->keyboard_manager);
 
  GtkWidget* widget =
      self->text_input_handler != nullptr
          ? fl_text_input_handler_get_widget(self->text_input_handler)
          : nullptr;
  g_clear_object(&self->text_input_handler);
  self->text_input_handler = fl_text_input_handler_new(self->binary_messenger);
  if (widget != nullptr) {
    fl_text_input_handler_set_widget(self->text_input_handler, widget);
  }
}

References fl_keyboard_handler_new(), fl_keyboard_manager_new(), fl_text_input_handler_get_widget(), fl_text_input_handler_new(), and fl_text_input_handler_set_widget().

Referenced by fl_engine_on_pre_engine_restart_cb(), and fl_engine_start().

setup_locales()

static void setup_locales ( FlEngine *  self )

static

Definition at line 232 of file fl_engine.cc.

                                          {
  const gchar* const* languages = g_get_language_names();
  g_autoptr(GPtrArray) locales_array = g_ptr_array_new_with_free_func(
      reinterpret_cast<GDestroyNotify>(free_locale));
  for (int i = 0; languages[i] != nullptr; i++) {
    g_autofree gchar* locale_string = g_strstrip(g_strdup(languages[i]));
 
    // Ignore empty locales, caused by settings like `LANGUAGE=pt_BR:`
    if (strcmp(locale_string, "") == 0) {
      continue;
    }
 
    g_autofree gchar* language = nullptr;
    g_autofree gchar* territory = nullptr;
    parse_locale(locale_string, &language, &territory, nullptr, nullptr);
 
    // Ignore duplicate locales, caused by settings like `LANGUAGE=C` (returns
    // two "C") or `LANGUAGE=en:en`
    gboolean has_locale = FALSE;
    for (guint j = 0; !has_locale && j < locales_array->len; j++) {
      FlutterLocale* locale =
          reinterpret_cast<FlutterLocale*>(g_ptr_array_index(locales_array, j));
      has_locale = g_strcmp0(locale->language_code, language) == 0 &&
                   g_strcmp0(locale->country_code, territory) == 0;
    }
    if (has_locale) {
      continue;
    }
 
    FlutterLocale* locale =
        static_cast<FlutterLocale*>(g_malloc0(sizeof(FlutterLocale)));
    g_ptr_array_add(locales_array, locale);
    locale->struct_size = sizeof(FlutterLocale);
    locale->language_code =
        reinterpret_cast<const gchar*>(g_steal_pointer(&language));
    locale->country_code =
        reinterpret_cast<const gchar*>(g_steal_pointer(&territory));
    locale->script_code = nullptr;
    locale->variant_code = nullptr;
  }
  FlutterLocale** locales =
      reinterpret_cast<FlutterLocale**>(locales_array->pdata);
  FlutterEngineResult result = self->embedder_api.UpdateLocales(
      self->engine, const_cast<const FlutterLocale**>(locales),
      locales_array->len);
  if (result != kSuccess) {
    g_warning("Failed to set up Flutter locales");
  }
}

References free_locale(), g_autoptr(), i, and parse_locale().

Referenced by fl_engine_start().

view_added_cb()

static void view_added_cb ( const FlutterAddViewResult *  result )

static

Definition at line 203 of file fl_engine.cc.

                                                              {
  g_autoptr(GTask) task = G_TASK(result->user_data);
 
  if (result->added) {
    g_task_return_boolean(task, TRUE);
  } else {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "Failed to add view");
  }
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), and TRUE.

Referenced by fl_engine_add_view().

view_removed_cb()

static void view_removed_cb ( const FlutterRemoveViewResult *  result )

static

Definition at line 214 of file fl_engine.cc.

                                                                   {
  g_autoptr(GTask) task = G_TASK(result->user_data);
 
  if (result->removed) {
    g_task_return_boolean(task, TRUE);
  } else {
    g_task_return_new_error(task, fl_engine_error_quark(),
                            FL_ENGINE_ERROR_FAILED, "Failed to remove view");
  }
}

References FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), and TRUE.

Referenced by fl_engine_remove_view().

Variable Documentation

fl_engine_signals

guint fl_engine_signals[LAST_SIGNAL]

static

Definition at line 119 of file fl_engine.cc.

Referenced by fl_engine_class_init(), fl_engine_on_pre_engine_restart_cb(), and fl_engine_update_semantics_cb().

kMousePointerDeviceId

constexpr int32_t kMousePointerDeviceId = 0

staticconstexpr

Definition at line 35 of file fl_engine.cc.

Referenced by fl_engine_send_mouse_pointer_event().

kPlatformTaskRunnerIdentifier

constexpr size_t kPlatformTaskRunnerIdentifier = 1

staticconstexpr

Definition at line 31 of file fl_engine.cc.

Referenced by fl_engine_start().

kPointerPanZoomDeviceId

constexpr int32_t kPointerPanZoomDeviceId = 1

staticconstexpr

Definition at line 36 of file fl_engine.cc.

Referenced by fl_engine_send_pointer_pan_zoom_event().