#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_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_dart_project_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/fl_windowing_handler.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_plugin_registry.h"

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	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 width, size_t 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 width, size_t 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)

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)

FlWindowingHandler *	fl_engine_get_windowing_handler (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 114 of file fl_engine.cc.

114{ SIGNAL_ON_PRE_ENGINE_RESTART, SIGNAL_UPDATE_SEMANTICS, LAST_SIGNAL };

LAST_SIGNAL

@ LAST_SIGNAL

Definition fl_engine.cc:114

SIGNAL_UPDATE_SEMANTICS

@ SIGNAL_UPDATE_SEMANTICS

Definition fl_engine.cc:114

SIGNAL_ON_PRE_ENGINE_RESTART

@ SIGNAL_ON_PRE_ENGINE_RESTART

Definition fl_engine.cc:114

Function Documentation

◆ collect_opengl_backing_store()

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

static

Definition at line 287 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(), FlutterOpenGLBackingStore::framebuffer, FlutterBackingStore::open_gl, self, and FlutterOpenGLFramebuffer::user_data.

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

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

References FlutterSoftwareBackingStore::allocation, and FlutterBackingStore::software.

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 347 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(), kOpenGL, kSoftware, self, 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 331 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(), kOpenGL, kSoftware, self, 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 362 of file fl_engine.cc.

                                        {
  FlEngine* self = static_cast<FlEngine*>(info->user_data);
 
  GWeakRef* ref = static_cast<GWeakRef*>(g_hash_table_lookup(
      self->renderables_by_view_id, GINT_TO_POINTER(info->view_id)));
  if (ref == nullptr) {
    return true;
  }
  g_autoptr(FlRenderable) renderable = FL_RENDERABLE(g_weak_ref_get(ref));
  if (renderable == nullptr) {
    return true;
  }
 
  fl_renderable_present_layers(renderable, info->layers, info->layers_count);
  return true;
}

References fl_renderable_present_layers(), g_autoptr(), FlutterPresentViewInfo::layers, FlutterPresentViewInfo::layers_count, self, FlutterPresentViewInfo::user_data, and FlutterPresentViewInfo::view_id.

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 250 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 FlutterOpenGLFramebuffer::destruction_callback, epoxy_has_gl_extension(), fl_framebuffer_get_id(), fl_framebuffer_new(), fl_opengl_manager_make_current(), FlutterOpenGLBackingStore::framebuffer, FlutterSize::height, kFlutterBackingStoreTypeOpenGL, kFlutterOpenGLTargetTypeFramebuffer, FlutterOpenGLFramebuffer::name, FlutterBackingStore::open_gl, self, FlutterBackingStoreConfig::size, FlutterOpenGLFramebuffer::target, FlutterOpenGLBackingStore::type, FlutterBackingStore::type, FlutterOpenGLFramebuffer::user_data, and FlutterSize::width.

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 299 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;
}

References FlutterSoftwareBackingStore::allocation, FlutterSoftwareBackingStore::destruction_callback, FlutterSize::height, FlutterSoftwareBackingStore::height, kFlutterBackingStoreTypeSoftware, FlutterSoftwareBackingStore::row_bytes, FlutterBackingStoreConfig::size, FlutterBackingStore::software, FlutterBackingStore::type, FlutterSoftwareBackingStore::user_data, and FlutterSize::width.

Referenced by compositor_create_backing_store_callback().

◆ fl_engine_add_view()

FlutterViewId fl_engine_add_view	(	FlEngine *	engine,
		FlRenderable *	renderable,
		size_t	width,
		size_t	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. @width: width of view in pixels. @height: 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 892 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++;
 
  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);
 
  // 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 = width;
  metrics.height = height;
  metrics.pixel_ratio = pixel_ratio;
  metrics.display_id = display_id;
  metrics.view_id = view_id;
  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 FlutterAddViewInfo::add_view_callback, callback, FlutterWindowMetricsEvent::display_id, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), g_hash_table_insert(), height, FlutterWindowMetricsEvent::height, kSuccess, FlutterWindowMetricsEvent::pixel_ratio, self, FlutterWindowMetricsEvent::struct_size, FlutterAddViewInfo::struct_size, user_data, FlutterAddViewInfo::user_data, view_added_cb(), FlutterWindowMetricsEvent::view_id, FlutterAddViewInfo::view_id, view_id, FlutterAddViewInfo::view_metrics, width, and FlutterWindowMetricsEvent::width.

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

◆ 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.

Completes request started with fl_engine_add_view().

Returns: TRUE on success.

Definition at line 941 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, and self.

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 608 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 1400 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 FlutterSendSemanticsActionInfo::action, action, data, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, kSuccess, FlutterSendSemanticsActionInfo::node_id, self, FlutterSendSemanticsActionInfo::struct_size, FlutterSendSemanticsActionInfo::view_id, and view_id.

Referenced by fl_accessible_node_perform_action_impl(), and TEST().

◆ fl_engine_dispose()

static void fl_engine_dispose ( GObject * object )

static

Definition at line 563 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->windowing_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_clear_pointer(&self->renderables_by_view_id, g_hash_table_unref);
 
  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(), kSuccess, and self.

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 1462 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");
  }
}

References kSuccess, and self.

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 691 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 engine, and id.

Referenced by TEST().

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

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

References self.

Referenced by fl_keyboard_manager_new(), fl_settings_handler_new(), fl_view_get_registrar_for_plugin(), fl_windowing_handler_new(), realize_cb(), TEST(), TEST(), TEST(), and TEST().

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

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

References self.

Referenced by handle_geometry_changed(), and TEST().

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

                                                                   {
  return &(self->embedder_api);
}

References self.

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

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

References self.

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

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

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

References self.

Referenced by cursor_changed_cb(), fl_view_dispose(), setup_cursor(), and TEST().

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

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

References self.

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 533 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(), and self.

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

                                                                              {
  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
 
  GWeakRef* ref = static_cast<GWeakRef*>(g_hash_table_lookup(
      self->renderables_by_view_id, GINT_TO_POINTER(view_id)));
  return FL_RENDERABLE(g_weak_ref_get(ref));
}

References self, 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 711 of file fl_engine.cc.

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

References self.

Referenced by realize_cb().

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

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

References self.

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

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

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

References self.

Referenced by fl_view_focus_in_event(), and handle_key_event().

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

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

References self.

Referenced by fl_view_get_registrar_for_plugin().

◆ fl_engine_get_windowing_handler()

FlWindowingHandler * fl_engine_get_windowing_handler ( FlEngine * engine )

fl_engine_get_windowing_handler: @engine: an #FlEngine.

Gets the windowing handler used by this engine.

Returns: an #FlWindowingHandler.

Definition at line 1494 of file fl_engine.cc.

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

References self.

Referenced by fl_application_activate(), and TEST().

◆ fl_engine_gl_clear_current()

static bool fl_engine_gl_clear_current ( void * user_data )

static

Definition at line 391 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(), self, 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 407 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, self, texture, 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 396 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 386 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(), self, 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 401 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(), self, 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 382 of file fl_engine.cc.

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

References name.

Referenced by fl_engine_start().

◆ fl_engine_init()

static void fl_engine_init ( FlEngine * self )

static

Definition at line 628 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;
  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(), FlutterEngineGetProcAddresses(), gdk_display_get_default(), kSuccess, self, 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 1430 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 kSuccess, self, and 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 697 of file fl_engine.cc.

                                                                {
  return fl_engine_new_full(project, nullptr);
}

References fl_engine_new_full().

◆ fl_engine_new_full()

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

static

Definition at line 654 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->windowing_handler = fl_windowing_handler_new(self);
 
  return self;
}

References fl_binary_messenger_new(), fl_keyboard_manager_new(), fl_mouse_cursor_handler_new(), fl_windowing_handler_new(), kOpenGL, kSoftware, and self.

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 707 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 701 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 TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ 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 872 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);
  }
}

References displays, kFlutterEngineDisplaysUpdateTypeStartup, kSuccess, and self.

Referenced by notify_display_update(), and TEST().

◆ fl_engine_on_pre_engine_restart_cb()

static void fl_engine_on_pre_engine_restart_cb ( void * user_data )

static

Definition at line 514 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, g_signal_emit(), self, 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 463 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 data, fl_engine_send_platform_message_response(), g_autoptr(), message, self, 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 524 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 data, 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 542 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 454 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(), self, 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 1437 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 kSuccess, self, and 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 956 of file fl_engine.cc.

                                               {
  g_return_if_fail(FL_IS_ENGINE(self));
 
  g_hash_table_remove(self->renderables_by_view_id, GINT_TO_POINTER(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 callback, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), kSuccess, FlutterRemoveViewInfo::remove_view_callback, self, FlutterRemoveViewInfo::struct_size, user_data, FlutterRemoveViewInfo::user_data, FlutterRemoveViewInfo::view_id, view_id, and view_removed_cb().

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

◆ 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.

Completes request started with fl_engine_remove_view().

Returns: TRUE on succcess.

Definition at line 983 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, and self.

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 1489 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(), and self.

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

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

References self, and 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 1360 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 callback, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), kSuccess, self, 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(), TEST(), TEST(), and TEST().

◆ 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.

Completes request started with fl_engine_send_key_event().

Returns: TRUE on success.

Definition at line 1383 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, self, and TRUE.

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

◆ 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
	)

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.

Sends a mouse pointer event to the engine.

Definition at line 1136 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;
  if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
      kSuccess) {
    g_warning("Failed to send pointer event");
  }
}

References FlutterPointerEvent::buttons, FlutterPointerEvent::device, FlutterPointerEvent::device_kind, kFlutterPointerSignalKindScroll, kMousePointerDeviceId, kSuccess, FlutterPointerEvent::phase, FlutterPointerEvent::scroll_delta_x, FlutterPointerEvent::scroll_delta_y, self, FlutterPointerEvent::signal_kind, FlutterPointerEvent::struct_size, FlutterPointerEvent::timestamp, FlutterPointerEvent::view_id, view_id, x, FlutterPointerEvent::x, FlutterPointerEvent::y, 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().

◆ 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 1041 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) {
    if (self->embedder_api.PlatformMessageReleaseResponseHandle(
            self->engine, response_handle) != kSuccess) {
      g_warning("Failed to release response handle");
    }
  }
}

References callback, FlutterPlatformMessage::channel, channel, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), fl_engine_platform_message_response_cb(), kSuccess, FlutterPlatformMessage::message, message, FlutterPlatformMessage::message_size, FlutterPlatformMessage::response_handle, self, FlutterPlatformMessage::struct_size, 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 1102 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 self.

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 1009 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 data, error, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), kSuccess, 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 *	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 1318 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 FlutterPointerEvent::device, FlutterPointerEvent::device_kind, kFlutterPointerDeviceKindTrackpad, kPointerPanZoomDeviceId, kSuccess, FlutterPointerEvent::pan_x, FlutterPointerEvent::pan_y, FlutterPointerEvent::phase, FlutterPointerEvent::rotation, FlutterPointerEvent::scale, self, FlutterPointerEvent::struct_size, FlutterPointerEvent::timestamp, FlutterPointerEvent::view_id, view_id, x, FlutterPointerEvent::x, FlutterPointerEvent::y, 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().

◆ 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 1260 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 device, kAdd, kFlutterPointerDeviceKindTouch, kSuccess, self, FlutterPointerEvent::timestamp, 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 1202 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 device, kDown, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindTouch, kSuccess, self, FlutterPointerEvent::timestamp, 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 1231 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 device, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindTouch, kMove, kSuccess, self, FlutterPointerEvent::timestamp, 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 1289 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 device, kFlutterPointerDeviceKindTouch, kRemove, kSuccess, self, FlutterPointerEvent::timestamp, 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 1173 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 device, kFlutterPointerDeviceKindTouch, kSuccess, kUp, self, FlutterPointerEvent::timestamp, 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	width,
		size_t	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. @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 1111 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;
  event.display_id = display_id;
  event.view_id = view_id;
  if (self->embedder_api.SendWindowMetricsEvent(self->engine, &event) !=
      kSuccess) {
    g_warning("Failed to send window metrics");
  }
}

References height, kSuccess, self, FlutterWindowMetricsEvent::struct_size, view_id, and width.

Referenced by handle_geometry_changed(), and TEST().

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

                                                                           {
  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(flutter::kFlutterImplicitViewId), ref);
}

References g_hash_table_insert(), flutter::kFlutterImplicitViewId, and self.

Referenced by fl_view_new(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), 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 990 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 destroy_notify, handler, self, and 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 547 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, self, 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.

Starts the Flutter engine.

Returns: TRUE on success.

Definition at line 726 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;
  }
 
  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 : flutter::GetSwitchesFromEnvironment()) {
    g_ptr_array_add(command_line_args, g_strdup(env_switch.c_str()));
  }
 
  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;
}

◆ 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 1444 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 kSuccess, 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 1475 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");
  }
}

References kSuccess, and self.

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 483 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, g_signal_emit(), self, SIGNAL_UPDATE_SEMANTICS, and user_data.

Referenced by fl_engine_start().

◆ free_locale()

static void free_locale ( FlutterLocale * locale )

static

Definition at line 193 of file fl_engine.cc.

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

References FlutterLocale::country_code, and FlutterLocale::language_code.

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

125 { PROP_0, PROP_BINARY_MESSENGER, PROP_LAST };

PROP_LAST

@ PROP_LAST

Definition fl_accessible_node.cc:66

PROP_0

@ PROP_0

Definition fl_accessible_node.cc:66

References PROP_0, and PROP_LAST.

◆ parse_locale()

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

static

Definition at line 128 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().

◆ send_key_event_cb()

static void send_key_event_cb	(	bool	handled,
		void *	user_data
	)

static

Definition at line 1353 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().

◆ setup_keyboard()

static void setup_keyboard ( FlEngine * self )

static

Definition at line 490 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(), fl_text_input_handler_set_widget(), and self.

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 200 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 FlutterLocale::country_code, free_locale(), g_autoptr(), i, kSuccess, FlutterLocale::language_code, parse_locale(), FlutterLocale::script_code, self, FlutterLocale::struct_size, and FlutterLocale::variant_code.

Referenced by fl_engine_start().

◆ view_added_cb()

static void view_added_cb ( const FlutterAddViewResult * result )

static

Definition at line 171 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 FlutterAddViewResult::added, FL_ENGINE_ERROR_FAILED, fl_engine_error_quark(), g_autoptr(), TRUE, and FlutterAddViewResult::user_data.

Referenced by fl_engine_add_view().

◆ view_removed_cb()

static void view_removed_cb ( const FlutterRemoveViewResult * result )

static

Definition at line 182 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(), FlutterRemoveViewResult::removed, TRUE, and FlutterRemoveViewResult::user_data.

Referenced by fl_engine_remove_view().

Variable Documentation

◆ fl_engine_signals

guint fl_engine_signals[LAST_SIGNAL]

static

Definition at line 116 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 36 of file fl_engine.cc.

Referenced by fl_engine_send_mouse_pointer_event().

◆ kPlatformTaskRunnerIdentifier

constexpr size_t kPlatformTaskRunnerIdentifier = 1

staticconstexpr

Definition at line 32 of file fl_engine.cc.

Referenced by fl_engine_start().

◆ kPointerPanZoomDeviceId

constexpr int32_t kPointerPanZoomDeviceId = 1

staticconstexpr

Definition at line 37 of file fl_engine.cc.

Referenced by fl_engine_send_pointer_pan_zoom_event().

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ collect_opengl_backing_store()

◆ collect_software_backing_store()

◆ compositor_collect_backing_store_callback()

◆ compositor_create_backing_store_callback()

◆ compositor_present_view_callback()

◆ create_opengl_backing_store()

◆ create_software_backing_store()

◆ fl_engine_add_view()

◆ fl_engine_add_view_finish()

◆ fl_engine_class_init()

◆ fl_engine_dispatch_semantics_action()

◆ fl_engine_dispose()

◆ fl_engine_execute_task()

◆ fl_engine_for_id()

◆ fl_engine_get_binary_messenger()

◆ fl_engine_get_display_monitor()

◆ fl_engine_get_embedder_api()

◆ fl_engine_get_keyboard_manager()

◆ fl_engine_get_mouse_cursor_handler()

◆ fl_engine_get_opengl_manager()

◆ fl_engine_get_registrar_for_plugin()

◆ fl_engine_get_renderable()

◆ fl_engine_get_renderer_type()

◆ fl_engine_get_task_runner()

◆ fl_engine_get_text_input_handler()

◆ fl_engine_get_texture_registrar()

◆ fl_engine_get_windowing_handler()

◆ 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_init()

◆ fl_engine_mark_texture_frame_available()

◆ fl_engine_new()

◆ fl_engine_new_full()

◆ fl_engine_new_headless()

◆ fl_engine_new_with_binary_messenger()

◆ fl_engine_notify_display_update()

◆ fl_engine_on_pre_engine_restart_cb()

◆ fl_engine_platform_message_cb()

◆ fl_engine_platform_message_response_cb()

◆ fl_engine_plugin_registry_iface_init()

◆ fl_engine_post_task()

◆ fl_engine_register_external_texture()

◆ fl_engine_remove_view()

◆ fl_engine_remove_view_finish()

◆ fl_engine_request_app_exit()

◆ fl_engine_runs_task_on_current_thread()

◆ fl_engine_send_key_event()

◆ fl_engine_send_key_event_finish()

◆ fl_engine_send_mouse_pointer_event()

◆ fl_engine_send_platform_message()

◆ fl_engine_send_platform_message_finish()

◆ fl_engine_send_platform_message_response()

◆ fl_engine_send_pointer_pan_zoom_event()

◆ fl_engine_send_touch_add_event()

◆ fl_engine_send_touch_down_event()

◆ fl_engine_send_touch_move_event()

◆ fl_engine_send_touch_remove_event()

◆ fl_engine_send_touch_up_event()

◆ fl_engine_send_window_metrics_event()

◆ fl_engine_set_implicit_view()

◆ fl_engine_set_platform_message_handler()

◆ fl_engine_set_property()

◆ fl_engine_start()

◆ fl_engine_unregister_external_texture()

◆ fl_engine_update_accessibility_features()

◆ fl_engine_update_semantics_cb()

◆ free_locale()

◆ G_DEFINE_TYPE_WITH_CODE()

◆ parse_locale()