fl_engine_private.h File Reference

#include <glib-object.h>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_renderer.h"
#include "flutter/shell/platform/linux/fl_task_runner.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_dart_project.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"

Go to the source code of this file.

Typedefs
typedef gboolean(*	FlEnginePlatformMessageHandler) (FlEngine *engine, const gchar *channel, GBytes *message, const FlutterPlatformMessageResponseHandle *response_handle, gpointer user_data)
typedef void(*	FlEngineUpdateSemanticsNodeHandler) (FlEngine *engine, const FlutterSemanticsNode *node, gpointer user_data)
typedef void(*	FlEngineOnPreEngineRestartHandler) (FlEngine *engine, gpointer user_data)

Enumerations
enum	FlEngineError { FL_ENGINE_ERROR_FAILED }

Functions
GQuark	fl_engine_error_quark (void) G_GNUC_CONST
FlEngine *	fl_engine_new (FlDartProject *project, FlRenderer *renderer)
FlutterEngineProcTable *	fl_engine_get_embedder_api (FlEngine *engine)
void	fl_engine_set_platform_message_handler (FlEngine *engine, FlEnginePlatformMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
void	fl_engine_set_update_semantics_node_handler (FlEngine *engine, FlEngineUpdateSemanticsNodeHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
void	fl_engine_set_on_pre_engine_restart_handler (FlEngine *engine, FlEngineOnPreEngineRestartHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
gboolean	fl_engine_start (FlEngine *engine, GError **error)
void	fl_engine_send_window_metrics_event (FlEngine *engine, size_t width, size_t height, double pixel_ratio)
void	fl_engine_send_window_state_event (FlEngine *engine, gboolean visible, gboolean focused)
void	fl_engine_send_mouse_pointer_event (FlEngine *engine, FlutterPointerPhase phase, size_t timestamp, double x, double y, double scroll_delta_x, double scroll_delta_y, int64_t buttons)
void	fl_engine_send_pointer_pan_zoom_event (FlEngine *self, size_t timestamp, double x, double y, FlutterPointerPhase phase, double pan_x, double pan_y, double scale, double rotation)
void	fl_engine_send_key_event (FlEngine *engine, const FlutterKeyEvent *event, FlutterKeyEventCallback callback, void *user_data)
void	fl_engine_dispatch_semantics_action (FlEngine *engine, uint64_t id, FlutterSemanticsAction action, GBytes *data)
gboolean	fl_engine_send_platform_message_response (FlEngine *engine, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
void	fl_engine_send_platform_message (FlEngine *engine, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
GBytes *	fl_engine_send_platform_message_finish (FlEngine *engine, GAsyncResult *result, GError **error)
FlTaskRunner *	fl_engine_get_task_runner (FlEngine *engine)
void	fl_engine_execute_task (FlEngine *engine, FlutterTask *task)
gboolean	fl_engine_mark_texture_frame_available (FlEngine *engine, int64_t texture_id)
gboolean	fl_engine_register_external_texture (FlEngine *engine, int64_t texture_id)
gboolean	fl_engine_unregister_external_texture (FlEngine *engine, int64_t texture_id)
void	fl_engine_update_accessibility_features (FlEngine *engine, int32_t flags)
GPtrArray *	fl_engine_get_switches (FlEngine *engine)

Typedef Documentation

FlEngineOnPreEngineRestartHandler

typedef void(* FlEngineOnPreEngineRestartHandler) (FlEngine *engine, gpointer user_data)

FlEngineOnPreEngineRestartHandler: @engine: an #FlEngine. @user_data: (closure): data provided when registering this handler.

Function called right before the engine is restarted.

Definition at line 70 of file fl_engine_private.h.

FlEnginePlatformMessageHandler

typedef gboolean(* FlEnginePlatformMessageHandler) (FlEngine *engine, const gchar *channel, GBytes *message, const FlutterPlatformMessageResponseHandle *response_handle, gpointer user_data)

FlEnginePlatformMessageHandler: @engine: an #FlEngine. @channel: channel message received on. @message: message content received from Dart. @response_handle: a handle to respond to the message with. @user_data: (closure): data provided when registering this handler.

Function called when platform messages are received.

Returns: TRUE if message has been accepted.

Definition at line 43 of file fl_engine_private.h.

FlEngineUpdateSemanticsNodeHandler

typedef void(* FlEngineUpdateSemanticsNodeHandler) (FlEngine *engine, const FlutterSemanticsNode *node, gpointer user_data)

FlEngineUpdateSemanticsNodeHandler: @engine: an #FlEngine. @node: semantic node information. @user_data: (closure): data provided when registering this handler.

Function called when semantics node updates are received.

Definition at line 58 of file fl_engine_private.h.

Enumeration Type Documentation

FlEngineError

enum FlEngineError

FlEngineError: Errors for #FlEngine objects to set on failures.

Enumerator
FL_ENGINE_ERROR_FAILED

Definition at line 23 of file fl_engine_private.h.

             {
  // NOLINTBEGIN(readability-identifier-naming)
  FL_ENGINE_ERROR_FAILED,
  // NOLINTEND(readability-identifier-naming)
} FlEngineError;

Function Documentation

fl_engine_dispatch_semantics_action()

void fl_engine_dispatch_semantics_action	(	FlEngine *	engine,
		uint64_t	id,
		FlutterSemanticsAction	action,
		GBytes *	data
	)

fl_engine_dispatch_semantics_action: @engine: an #FlEngine. @id: the semantics action identifier. @action: the action being dispatched. @data: (allow-none): data associated with the action.

Definition at line 860 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));
  }
 
  self->embedder_api.DispatchSemanticsAction(self->engine, id, action,
                                             action_data, action_data_length);
}

References self.

Referenced by fl_accessible_node_perform_action_impl(), and TEST().

fl_engine_error_quark()

GQuark fl_engine_error_quark

(

void

)

Referenced by fl_engine_send_platform_message(), fl_engine_send_platform_message_response(), and fl_engine_start().

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 913 of file fl_engine.cc.

                                                               {
  g_return_if_fail(FL_IS_ENGINE(self));
  self->embedder_api.RunTask(self->engine, task);
}

References self.

Referenced by fl_task_runner_process_expired_tasks_locked().

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 591 of file fl_engine.cc.

                                                                   {
  return &(self->embedder_api);
}

Referenced by TEST().

fl_engine_get_switches()

GPtrArray* fl_engine_get_switches

(

FlEngine *

engine

)

fl_engine_get_switches: @project: an #FlEngine.

Determines the switches that should be passed to the Flutter engine.

Returns: an array of switches to pass to the Flutter engine.

Definition at line 935 of file fl_engine.cc.

                                                  {
  GPtrArray* switches = g_ptr_array_new_with_free_func(g_free);
  for (const auto& env_switch : flutter::GetSwitchesFromEnvironment()) {
    g_ptr_array_add(switches, g_strdup(env_switch.c_str()));
  }
  return switches;
}

References flutter::GetSwitchesFromEnvironment().

Referenced by fl_engine_start(), and TEST().

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 908 of file fl_engine.cc.

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

Referenced by fl_renderer_unblock_main_thread(), and fl_renderer_wait_for_frame().

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 881 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 self, and texture_id.

Referenced by mark_texture_frame_available().

fl_engine_new()

FlEngine* fl_engine_new	(	FlDartProject *	project,
		FlRenderer *	renderer
	)

fl_engine_new: @project: an #FlDartProject. @renderer: an #FlRenderer.

Creates new Flutter engine.

Returns: a new #FlEngine.

Definition at line 467 of file fl_engine.cc.

                                                                      {
  g_return_val_if_fail(FL_IS_DART_PROJECT(project), nullptr);
  g_return_val_if_fail(FL_IS_RENDERER(renderer), nullptr);
 
  FlEngine* self = FL_ENGINE(g_object_new(fl_engine_get_type(), nullptr));
  self->project = FL_DART_PROJECT(g_object_ref(project));
  self->renderer = FL_RENDERER(g_object_ref(renderer));
  self->binary_messenger = fl_binary_messenger_new(self);
  return self;
}

References fl_binary_messenger_new().

Referenced by fl_engine_new_headless(), fl_view_constructed(), and make_mock_engine().

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 888 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 self, and texture_id.

Referenced by register_texture().

fl_engine_send_key_event()

void fl_engine_send_key_event	(	FlEngine *	engine,
		const FlutterKeyEvent *	event,
		FlutterKeyEventCallback	callback,
		void *	user_data
	)

fl_engine_send_key_event:

Definition at line 847 of file fl_engine.cc.

                                               {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  self->embedder_api.SendKeyEvent(self->engine, event, callback, user_data);
}

References callback, event, self, and user_data.

Referenced by fl_view_keyboard_delegate_iface_init().

fl_engine_send_mouse_pointer_event()

void fl_engine_send_mouse_pointer_event	(	FlEngine *	engine,
		FlutterPointerPhase	phase,
		size_t	timestamp,
		double	x,
		double	y,
		double	scroll_delta_x,
		double	scroll_delta_y,
		int64_t	buttons
	)

fl_engine_send_mouse_pointer_event: @engine: an #FlEngine. @phase: mouse phase. @timestamp: time when event occurred in microseconds. @x: x location of mouse cursor. @y: y location of mouse cursor. @scroll_delta_x: x offset of scroll. @scroll_delta_y: y offset of scroll. @buttons: buttons that are pressed.

Sends a mouse pointer event to the engine.

Definition at line 778 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 = kFlutterPointerDeviceKindMouse;
  fl_event.buttons = buttons;
  fl_event.device = kMousePointerDeviceId;
  // TODO(dkwingsmt): Assign the correct view ID once the Linux embedder
  // supports multiple views.
  // https://github.com/flutter/flutter/issues/138178
  fl_event.view_id = flutter::kFlutterImplicitViewId;
  self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1);
}

References kMousePointerDeviceId, and self.

Referenced by check_pointer_inside(), fl_view_scrolling_delegate_iface_init(), leave_notify_event_cb(), motion_notify_event_cb(), send_pointer_button_event(), and TEST().

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 680 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");
      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) {
    self->embedder_api.PlatformMessageReleaseResponseHandle(self->engine,
                                                            response_handle);
  }
}

References callback, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), fl_engine_platform_message_response_cb(), result, self, and user_data.

Referenced by send_on_channel(), and TEST().

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.

Completes request started with fl_engine_send_platform_message().

Returns: message response on success or NULL on error.

Definition at line 739 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, and result.

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.

Responds to a platform message.

Returns: TRUE on success.

Definition at line 648 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(), result, self, and TRUE.

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

fl_engine_send_pointer_pan_zoom_event()

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

Definition at line 813 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;
  // TODO(dkwingsmt): Assign the correct view ID once the Linux embedder
  // supports multiple views.
  // https://github.com/flutter/flutter/issues/138178
  fl_event.view_id = flutter::kFlutterImplicitViewId;
  self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1);
}

References kPointerPanZoomDeviceId, and self.

Referenced by fl_view_scrolling_delegate_iface_init(), and TEST().

fl_engine_send_window_metrics_event()

void fl_engine_send_window_metrics_event	(	FlEngine *	engine,
		size_t	width,
		size_t	height,
		double	pixel_ratio
	)

fl_engine_send_window_metrics_event: @engine: an #FlEngine. @width: width of the window in pixels. @height: height of the window in pixels. @pixel_ratio: scale factor for window.

Sends a window metrics event to the engine.

Definition at line 760 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 = width;
  event.height = height;
  event.pixel_ratio = pixel_ratio;
  self->embedder_api.SendWindowMetricsEvent(self->engine, &event);
}

References event, height, self, and width.

Referenced by handle_geometry_changed(), and TEST().

fl_engine_send_window_state_event()

void fl_engine_send_window_state_event	(	FlEngine *	engine,
		gboolean	visible,
		gboolean	focused
	)

fl_engine_send_window_state_event: @engine: an #FlEngine. @visible: whether the window is currently visible or not. @focused: whether the window is currently focused or not.

Sends a window state event to the engine.

Definition at line 748 of file fl_engine.cc.

                                                         {
  if (visible && focused) {
    set_app_lifecycle_state(self, flutter::AppLifecycleState::kResumed);
  } else if (visible) {
    set_app_lifecycle_state(self, flutter::AppLifecycleState::kInactive);
  } else {
    set_app_lifecycle_state(self, flutter::AppLifecycleState::kHidden);
  }
}

References flutter::kHidden, flutter::kInactive, flutter::kResumed, and set_app_lifecycle_state().

Referenced by TEST(), and window_state_event_cb().

fl_engine_set_on_pre_engine_restart_handler()

void fl_engine_set_on_pre_engine_restart_handler	(	FlEngine *	engine,
		FlEngineOnPreEngineRestartHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_engine_set_on_pre_engine_restart_handler: @engine: an #FlEngine. @handler: function to call when the engine is restarted. @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 right before the engine is restarted.

Definition at line 630 of file fl_engine.cc.

                                   {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->on_pre_engine_restart_handler_destroy_notify) {
    self->on_pre_engine_restart_handler_destroy_notify(
        self->on_pre_engine_restart_handler_data);
  }
 
  self->on_pre_engine_restart_handler = handler;
  self->on_pre_engine_restart_handler_data = user_data;
  self->on_pre_engine_restart_handler_destroy_notify = destroy_notify;
}

References self, and user_data.

Referenced by fl_view_constructed(), fl_view_dispose(), and TEST().

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 595 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 self, and user_data.

Referenced by fl_binary_messenger_new().

fl_engine_set_update_semantics_node_handler()

void fl_engine_set_update_semantics_node_handler	(	FlEngine *	engine,
		FlEngineUpdateSemanticsNodeHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_engine_set_update_semantics_node_handler: @engine: an #FlEngine. @handler: function to call when a semantics node update 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 semantics node update is reveived.

Definition at line 613 of file fl_engine.cc.

                                   {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->update_semantics_node_handler_destroy_notify) {
    self->update_semantics_node_handler_destroy_notify(
        self->update_semantics_node_handler_data);
  }
 
  self->update_semantics_node_handler = handler;
  self->update_semantics_node_handler_data = user_data;
  self->update_semantics_node_handler_destroy_notify = destroy_notify;
}

References self, and user_data.

Referenced by fl_view_constructed(), and fl_view_dispose().

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.

Starts the Flutter engine.

Returns: TRUE on success.

Definition at line 483 of file fl_engine.cc.

                                                         {
  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
 
  self->task_runner = fl_task_runner_new(self);
 
  FlutterRendererConfig config = {};
  config.type = 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;
  config.open_gl.present = fl_engine_gl_present;
  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;
 
  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;
  custom_task_runners.render_task_runner = &platform_task_runner;
 
  g_autoptr(GPtrArray) command_line_args = fl_engine_get_switches(self);
  // FlutterProjectArgs expects a full argv, so when processing it for flags
  // the first item is treated as the executable and ignored. Add a dummy value
  // so that all switches are used.
  g_ptr_array_insert(command_line_args, 0, g_strdup("flutter"));
 
  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_node_callback = fl_engine_update_semantics_node_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);
 
  FlutterCompositor compositor = {};
  compositor.struct_size = sizeof(FlutterCompositor);
  compositor.user_data = self->renderer;
  compositor.create_backing_store_callback =
      compositor_create_backing_store_callback;
  compositor.collect_backing_store_callback =
      compositor_collect_backing_store_callback;
  compositor.present_layers_callback = compositor_present_layers_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_plugin = fl_settings_plugin_new(self);
  fl_settings_plugin_start(self->settings_plugin, settings);
 
  result = self->embedder_api.UpdateSemanticsEnabled(self->engine, TRUE);
  if (result != kSuccess) {
    g_warning("Failed to enable accessibility features on Flutter engine");
  }
 
  return TRUE;
}

References args, compositor_collect_backing_store_callback(), compositor_create_backing_store_callback(), compositor_present_layers_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_icu_data_path(), FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), fl_engine_get_switches(), 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_present(), 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_node_cb(), fl_settings_new(), fl_settings_plugin_new(), fl_settings_plugin_start(), fl_task_runner_new(), kPlatformTaskRunnerIdentifier, result, self, setup_locales(), and TRUE.

Referenced by make_mock_engine(), realize_cb(), and TEST().

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 895 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 self, and 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 924 of file fl_engine.cc.

                                                                            {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  if (self->engine == nullptr) {
    return;
  }
 
  self->embedder_api.UpdateAccessibilityFeatures(
      self->engine, static_cast<FlutterAccessibilityFeature>(flags));
}

References flags, and self.

Referenced by update_settings().