Flutter Linux Embedder
fl_engine.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
7 #include <epoxy/egl.h>
8 #include <gmodule.h>
9 
10 #include <cstring>
11 
12 #include "flutter/common/constants.h"
14 #include "flutter/shell/platform/embedder/embedder.h"
29 
30 // Unique number associated with platform tasks.
31 static constexpr size_t kPlatformTaskRunnerIdentifier = 1;
32 
33 // Use different device ID for mouse and pan/zoom events, since we can't
34 // differentiate the actual device (mouse v.s. trackpad)
35 static constexpr int32_t kMousePointerDeviceId = 0;
36 static constexpr int32_t kPointerPanZoomDeviceId = 1;
37 
38 struct _FlEngine {
39  GObject parent_instance;
40 
41  // Thread the GLib main loop is running on.
42  GThread* thread;
43 
44  // The project this engine is running.
45  FlDartProject* project;
46 
47  // Watches for monitors changes to update engine.
48  FlDisplayMonitor* display_monitor;
49 
50  // Type of rendering performed.
51  FlutterRendererType renderer_type;
52 
53  // Manages OpenGL contexts.
54  FlOpenGLManager* opengl_manager;
55 
56  // Messenger used to send and receive platform messages.
57  FlBinaryMessenger* binary_messenger;
58 
59  // Implements the flutter/settings channel.
60  FlSettingsHandler* settings_handler;
61 
62  // Implements the flutter/platform channel.
63  FlPlatformHandler* platform_handler;
64 
65  // Implements the flutter/accessibility channel.
66  FlAccessibilityHandler* accessibility_handler;
67 
68  // Process keyboard events.
69  FlKeyboardManager* keyboard_manager;
70 
71  // Implements the flutter/textinput channel.
72  FlTextInputHandler* text_input_handler;
73 
74  // Implements the flutter/keyboard channel.
75  FlKeyboardHandler* keyboard_handler;
76 
77  // Implements the flutter/mousecursor channel.
78  FlMouseCursorHandler* mouse_cursor_handler;
79 
80  // Manages textures rendered by native code.
81  FlTextureRegistrar* texture_registrar;
82 
83  // Schedules tasks to be run on the appropriate thread.
84  FlTaskRunner* task_runner;
85 
86  // Ahead of time data used to make engine run faster.
87  FlutterEngineAOTData aot_data;
88 
89  // The Flutter engine.
90  FLUTTER_API_SYMBOL(FlutterEngine) engine;
91 
92  // Function table for engine API, used to intercept engine calls for testing
93  // purposes.
94  FlutterEngineProcTable embedder_api;
95 
96  // Next ID to use for a view.
97  FlutterViewId next_view_id;
98 
99  // Objects rendering the views.
101 
102  // Mutex to protect access to renderables_by_view_id which is accessed by both
103  // engine threads and GTK.
105 
106  // Function to call when a platform message is received.
110 };
111 
112 G_DEFINE_QUARK(fl_engine_error_quark, fl_engine_error)
113 
115  FlPluginRegistryInterface* iface);
116 
118 
120 
122  FlEngine,
123  fl_engine,
124  G_TYPE_OBJECT,
125  G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(),
127 
128 enum { PROP_0, PROP_BINARY_MESSENGER, PROP_LAST };
129 
130 // Parse a locale into its components.
131 static void parse_locale(const gchar* locale,
132  gchar** language,
133  gchar** territory,
134  gchar** codeset,
135  gchar** modifier) {
136  gchar* l = g_strdup(locale);
137 
138  // Locales are in the form "language[_territory][.codeset][@modifier]"
139  gchar* match = strrchr(l, '@');
140  if (match != nullptr) {
141  if (modifier != nullptr) {
142  *modifier = g_strdup(match + 1);
143  }
144  *match = '\0';
145  } else if (modifier != nullptr) {
146  *modifier = nullptr;
147  }
148 
149  match = strrchr(l, '.');
150  if (match != nullptr) {
151  if (codeset != nullptr) {
152  *codeset = g_strdup(match + 1);
153  }
154  *match = '\0';
155  } else if (codeset != nullptr) {
156  *codeset = nullptr;
157  }
158 
159  match = strrchr(l, '_');
160  if (match != nullptr) {
161  if (territory != nullptr) {
162  *territory = g_strdup(match + 1);
163  }
164  *match = '\0';
165  } else if (territory != nullptr) {
166  *territory = nullptr;
167  }
168 
169  if (language != nullptr) {
170  *language = l;
171  }
172 }
173 
174 /// Stores a weak reference to the renderable with the given ID.
175 static void set_renderable(FlEngine* self,
176  int64_t view_id,
177  FlRenderable* renderable) {
178  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
179  GWeakRef* ref = g_new(GWeakRef, 1);
180  g_weak_ref_init(ref, G_OBJECT(renderable));
181  g_hash_table_insert(self->renderables_by_view_id, GINT_TO_POINTER(view_id),
182  ref);
183 }
184 
185 /// Returns the renderable with the given ID, or nullptr if no such view exists.
186 /// Returns a reference to the renderable.
187 static FlRenderable* get_renderable(FlEngine* self, int64_t view_id) {
188  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
189  GWeakRef* ref = static_cast<GWeakRef*>(g_hash_table_lookup(
190  self->renderables_by_view_id, GINT_TO_POINTER(view_id)));
191  if (ref == nullptr) {
192  return nullptr;
193  }
194  return FL_RENDERABLE(g_weak_ref_get(ref));
195 }
196 
197 /// Remove a renderable that no longer exists.
198 static void remove_renderable(FlEngine* self, int64_t view_id) {
199  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
200  g_hash_table_remove(self->renderables_by_view_id, GINT_TO_POINTER(view_id));
201 }
202 
203 static void view_added_cb(const FlutterAddViewResult* result) {
204  g_autoptr(GTask) task = G_TASK(result->user_data);
205 
206  if (result->added) {
207  g_task_return_boolean(task, TRUE);
208  } else {
209  g_task_return_new_error(task, fl_engine_error_quark(),
210  FL_ENGINE_ERROR_FAILED, "Failed to add view");
211  }
212 }
213 
214 static void view_removed_cb(const FlutterRemoveViewResult* result) {
215  g_autoptr(GTask) task = G_TASK(result->user_data);
216 
217  if (result->removed) {
218  g_task_return_boolean(task, TRUE);
219  } else {
220  g_task_return_new_error(task, fl_engine_error_quark(),
221  FL_ENGINE_ERROR_FAILED, "Failed to remove view");
222  }
223 }
224 
225 static void free_locale(FlutterLocale* locale) {
226  g_free(const_cast<gchar*>(locale->language_code));
227  g_free(const_cast<gchar*>(locale->country_code));
228  g_free(locale);
229 }
230 
231 // Passes locale information to the Flutter engine.
232 static void setup_locales(FlEngine* self) {
233  const gchar* const* languages = g_get_language_names();
234  g_autoptr(GPtrArray) locales_array = g_ptr_array_new_with_free_func(
235  reinterpret_cast<GDestroyNotify>(free_locale));
236  for (int i = 0; languages[i] != nullptr; i++) {
237  g_autofree gchar* locale_string = g_strstrip(g_strdup(languages[i]));
238 
239  // Ignore empty locales, caused by settings like `LANGUAGE=pt_BR:`
240  if (strcmp(locale_string, "") == 0) {
241  continue;
242  }
243 
244  g_autofree gchar* language = nullptr;
245  g_autofree gchar* territory = nullptr;
246  parse_locale(locale_string, &language, &territory, nullptr, nullptr);
247 
248  // Ignore duplicate locales, caused by settings like `LANGUAGE=C` (returns
249  // two "C") or `LANGUAGE=en:en`
250  gboolean has_locale = FALSE;
251  for (guint j = 0; !has_locale && j < locales_array->len; j++) {
252  FlutterLocale* locale =
253  reinterpret_cast<FlutterLocale*>(g_ptr_array_index(locales_array, j));
254  has_locale = g_strcmp0(locale->language_code, language) == 0 &&
255  g_strcmp0(locale->country_code, territory) == 0;
256  }
257  if (has_locale) {
258  continue;
259  }
260 
261  FlutterLocale* locale =
262  static_cast<FlutterLocale*>(g_malloc0(sizeof(FlutterLocale)));
263  g_ptr_array_add(locales_array, locale);
264  locale->struct_size = sizeof(FlutterLocale);
265  locale->language_code =
266  reinterpret_cast<const gchar*>(g_steal_pointer(&language));
267  locale->country_code =
268  reinterpret_cast<const gchar*>(g_steal_pointer(&territory));
269  locale->script_code = nullptr;
270  locale->variant_code = nullptr;
271  }
272  FlutterLocale** locales =
273  reinterpret_cast<FlutterLocale**>(locales_array->pdata);
274  FlutterEngineResult result = self->embedder_api.UpdateLocales(
275  self->engine, const_cast<const FlutterLocale**>(locales),
276  locales_array->len);
277  if (result != kSuccess) {
278  g_warning("Failed to set up Flutter locales");
279  }
280 }
281 
283  FlEngine* self,
284  const FlutterBackingStoreConfig* config,
285  FlutterBackingStore* backing_store_out) {
286  if (!fl_opengl_manager_make_current(self->opengl_manager)) {
287  return false;
288  }
289 
290  GLint general_format = GL_RGBA;
291  GLint sized_format = GL_RGBA8;
292  if (epoxy_has_gl_extension("GL_EXT_texture_format_BGRA8888")) {
293  general_format = GL_BGRA_EXT;
294  sized_format = GL_BGRA8_EXT;
295  }
296 
297  FlFramebuffer* framebuffer = fl_framebuffer_new_multisample(
298  general_format, config->size.width, config->size.height,
299  fl_dart_project_get_enable_impeller(self->project));
300  if (!framebuffer) {
301  g_warning("Failed to create backing store");
302  return false;
303  }
304 
305  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
306  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
307  backing_store_out->open_gl.framebuffer.user_data = framebuffer;
308  backing_store_out->open_gl.framebuffer.name =
309  fl_framebuffer_get_id(framebuffer);
310  backing_store_out->open_gl.framebuffer.target =
311  fl_framebuffer_get_texture_id(framebuffer) != 0 ? sized_format : GL_RGBA8;
312  backing_store_out->open_gl.framebuffer.destruction_callback = [](void* p) {
313  // Backing store destroyed in fl_compositor_opengl_collect_backing_store(),
314  // set on FlutterCompositor.collect_backing_store_callback during engine
315  // start.
316  };
317 
318  return true;
319 }
320 
322  FlEngine* self,
323  const FlutterBackingStore* backing_store) {
324  if (!fl_opengl_manager_make_current(self->opengl_manager)) {
325  return false;
326  }
327 
328  // OpenGL context is required when destroying #FlFramebuffer.
329  g_object_unref(backing_store->open_gl.framebuffer.user_data);
330  return true;
331 }
332 
334  FlEngine* self,
335  const FlutterBackingStoreConfig* config,
336  FlutterBackingStore* backing_store_out) {
337  size_t allocation_length = config->size.width * config->size.height * 4;
338  uint8_t* allocation = static_cast<uint8_t*>(malloc(allocation_length));
339  if (allocation == nullptr) {
340  return false;
341  }
342 
343  backing_store_out->type = kFlutterBackingStoreTypeSoftware;
344  backing_store_out->software.allocation = allocation;
345  backing_store_out->software.height = config->size.height;
346  backing_store_out->software.row_bytes = config->size.width * 4;
347  backing_store_out->software.user_data = nullptr;
348  backing_store_out->software.destruction_callback = [](void* p) {
349  // Backing store destroyed in
350  // fl_compositor_software_collect_backing_store(), set on
351  // FlutterCompositor.collect_backing_store_callback during engine start.
352  };
353 
354  return true;
355 }
356 
358  FlEngine* self,
359  const FlutterBackingStore* backing_store) {
360  free(const_cast<void*>(backing_store->software.allocation));
361  return true;
362 }
363 
364 // Called when engine needs a backing store for a specific #FlutterLayer.
366  const FlutterBackingStoreConfig* config,
367  FlutterBackingStore* backing_store_out,
368  void* user_data) {
369  FlEngine* self = static_cast<FlEngine*>(user_data);
370  switch (self->renderer_type) {
371  case kOpenGL:
372  return create_opengl_backing_store(self, config, backing_store_out);
373  case kSoftware:
374  return create_software_backing_store(self, config, backing_store_out);
375  default:
376  return false;
377  }
378 }
379 
380 // Called when the backing store is to be released.
382  const FlutterBackingStore* backing_store,
383  void* user_data) {
384  FlEngine* self = static_cast<FlEngine*>(user_data);
385  switch (self->renderer_type) {
386  case kOpenGL:
387  return collect_opengl_backing_store(self, backing_store);
388  case kSoftware:
389  return collect_software_backing_store(self, backing_store);
390  default:
391  return false;
392  }
393 }
394 
395 // Called when embedder should composite contents of each layer onto the screen.
397  const FlutterPresentViewInfo* info) {
398  FlEngine* self = static_cast<FlEngine*>(info->user_data);
399 
400  g_autoptr(FlRenderable) renderable = get_renderable(self, info->view_id);
401  if (renderable == nullptr) {
402  return true;
403  }
404 
405  fl_renderable_present_layers(renderable, info->layers, info->layers_count);
406  return true;
407 }
408 
409 // Flutter engine rendering callbacks.
410 
411 static void* fl_engine_gl_proc_resolver(void* user_data, const char* name) {
412  return reinterpret_cast<void*>(eglGetProcAddress(name));
413 }
414 
416  FlEngine* self = static_cast<FlEngine*>(user_data);
417  return fl_opengl_manager_make_current(self->opengl_manager);
418 }
419 
421  FlEngine* self = static_cast<FlEngine*>(user_data);
422  return fl_opengl_manager_clear_current(self->opengl_manager);
423 }
424 
425 static uint32_t fl_engine_gl_get_fbo(void* user_data) {
426  // There is only one frame buffer object - always return that.
427  return 0;
428 }
429 
431  FlEngine* self = static_cast<FlEngine*>(user_data);
432  return fl_opengl_manager_make_resource_current(self->opengl_manager);
433 }
434 
435 // Called by the engine to retrieve an external texture.
437  void* user_data,
438  int64_t texture_id,
439  size_t width,
440  size_t height,
441  FlutterOpenGLTexture* opengl_texture) {
442  FlEngine* self = static_cast<FlEngine*>(user_data);
443  if (!self->texture_registrar) {
444  return false;
445  }
446 
447  FlTexture* texture =
448  fl_texture_registrar_lookup_texture(self->texture_registrar, texture_id);
449  if (texture == nullptr) {
450  g_warning("Unable to find texture %" G_GINT64_FORMAT, texture_id);
451  return false;
452  }
453 
454  gboolean result;
455  g_autoptr(GError) error = nullptr;
456  if (FL_IS_TEXTURE_GL(texture)) {
457  result = fl_texture_gl_populate(FL_TEXTURE_GL(texture), width, height,
458  opengl_texture, &error);
459  } else if (FL_IS_PIXEL_BUFFER_TEXTURE(texture)) {
460  result =
461  fl_pixel_buffer_texture_populate(FL_PIXEL_BUFFER_TEXTURE(texture),
462  width, height, opengl_texture, &error);
463  } else {
464  g_warning("Unsupported texture type %" G_GINT64_FORMAT, texture_id);
465  return false;
466  }
467 
468  if (!result) {
469  g_warning("%s", error->message);
470  return false;
471  }
472 
473  return true;
474 }
475 
476 // Called by the engine to determine if it is on the GTK thread.
478  FlEngine* self = static_cast<FlEngine*>(user_data);
479  return self->thread == g_thread_self();
480 }
481 
482 // Called when the engine has a task to perform in the GTK thread.
483 static void fl_engine_post_task(FlutterTask task,
484  uint64_t target_time_nanos,
485  void* user_data) {
486  FlEngine* self = static_cast<FlEngine*>(user_data);
487 
488  fl_task_runner_post_flutter_task(self->task_runner, task, target_time_nanos);
489 }
490 
491 // Called when a platform message is received from the engine.
492 static void fl_engine_platform_message_cb(const FlutterPlatformMessage* message,
493  void* user_data) {
494  FlEngine* self = FL_ENGINE(user_data);
495 
496  gboolean handled = FALSE;
497  if (self->platform_message_handler != nullptr) {
498  g_autoptr(GBytes) data =
499  g_bytes_new(message->message, message->message_size);
500  handled = self->platform_message_handler(
501  self, message->channel, data, message->response_handle,
502  self->platform_message_handler_data);
503  }
504 
505  if (!handled) {
506  fl_engine_send_platform_message_response(self, message->response_handle,
507  nullptr, nullptr);
508  }
509 }
510 
511 // Called when a semantic node update is received from the engine.
512 static void fl_engine_update_semantics_cb(const FlutterSemanticsUpdate2* update,
513  void* user_data) {
514  FlEngine* self = FL_ENGINE(user_data);
515 
516  g_signal_emit(self, fl_engine_signals[SIGNAL_UPDATE_SEMANTICS], 0, update);
517 }
518 
519 static void setup_keyboard(FlEngine* self) {
520  g_clear_object(&self->keyboard_manager);
521  self->keyboard_manager = fl_keyboard_manager_new(self);
522 
523  g_clear_object(&self->keyboard_handler);
524  self->keyboard_handler =
525  fl_keyboard_handler_new(self->binary_messenger, self->keyboard_manager);
526 
527  GtkWidget* widget =
528  self->text_input_handler != nullptr
529  ? fl_text_input_handler_get_widget(self->text_input_handler)
530  : nullptr;
531  g_clear_object(&self->text_input_handler);
532  self->text_input_handler = fl_text_input_handler_new(self->binary_messenger);
533  if (widget != nullptr) {
534  fl_text_input_handler_set_widget(self->text_input_handler, widget);
535  }
536 }
537 
538 // Called right before the engine is restarted.
539 //
540 // This method should reset states to as if the engine has just been started,
541 // which usually indicates the user has requested a hot restart (Shift-R in the
542 // Flutter CLI.)
544  FlEngine* self = FL_ENGINE(user_data);
545 
546  setup_keyboard(self);
547 
548  g_signal_emit(self, fl_engine_signals[SIGNAL_ON_PRE_ENGINE_RESTART], 0);
549 }
550 
551 // Called when a response to a sent platform message is received from the
552 // engine.
553 static void fl_engine_platform_message_response_cb(const uint8_t* data,
554  size_t data_length,
555  void* user_data) {
556  g_autoptr(GTask) task = G_TASK(user_data);
557  g_task_return_pointer(task, g_bytes_new(data, data_length),
558  reinterpret_cast<GDestroyNotify>(g_bytes_unref));
559 }
560 
561 // Implements FlPluginRegistry::get_registrar_for_plugin.
562 static FlPluginRegistrar* fl_engine_get_registrar_for_plugin(
563  FlPluginRegistry* registry,
564  const gchar* name) {
565  FlEngine* self = FL_ENGINE(registry);
566 
567  return fl_plugin_registrar_new(nullptr, self->binary_messenger,
568  self->texture_registrar);
569 }
570 
572  FlPluginRegistryInterface* iface) {
573  iface->get_registrar_for_plugin = fl_engine_get_registrar_for_plugin;
574 }
575 
576 static void fl_engine_set_property(GObject* object,
577  guint prop_id,
578  const GValue* value,
579  GParamSpec* pspec) {
580  FlEngine* self = FL_ENGINE(object);
581  switch (prop_id) {
582  case PROP_BINARY_MESSENGER:
583  g_set_object(&self->binary_messenger,
584  FL_BINARY_MESSENGER(g_value_get_object(value)));
585  break;
586  default:
587  G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
588  break;
589  }
590 }
591 
592 static void fl_engine_dispose(GObject* object) {
593  FlEngine* self = FL_ENGINE(object);
594 
595  if (self->engine != nullptr) {
596  if (self->embedder_api.Shutdown(self->engine) != kSuccess) {
597  g_warning("Failed to shutdown Flutter engine");
598  }
599  self->engine = nullptr;
600  }
601 
602  if (self->aot_data != nullptr) {
603  if (self->embedder_api.CollectAOTData(self->aot_data) != kSuccess) {
604  g_warning("Failed to send collect AOT data");
605  }
606  self->aot_data = nullptr;
607  }
608 
609  fl_binary_messenger_shutdown(self->binary_messenger);
610  fl_texture_registrar_shutdown(self->texture_registrar);
611 
612  g_clear_object(&self->project);
613  g_clear_object(&self->display_monitor);
614  g_clear_object(&self->opengl_manager);
615  g_clear_object(&self->texture_registrar);
616  g_clear_object(&self->binary_messenger);
617  g_clear_object(&self->settings_handler);
618  g_clear_object(&self->platform_handler);
619  g_clear_object(&self->accessibility_handler);
620  g_clear_object(&self->keyboard_manager);
621  g_clear_object(&self->text_input_handler);
622  g_clear_object(&self->keyboard_handler);
623  g_clear_object(&self->mouse_cursor_handler);
624  g_clear_object(&self->task_runner);
625  {
626  g_autoptr(GMutexLocker) locker =
627  g_mutex_locker_new(&self->renderables_mutex);
628  g_clear_pointer(&self->renderables_by_view_id, g_hash_table_unref);
629  }
630  g_mutex_clear(&self->renderables_mutex);
631 
632  if (self->platform_message_handler_destroy_notify) {
633  self->platform_message_handler_destroy_notify(
634  self->platform_message_handler_data);
635  }
636  self->platform_message_handler_data = nullptr;
637  self->platform_message_handler_destroy_notify = nullptr;
638 
639  G_OBJECT_CLASS(fl_engine_parent_class)->dispose(object);
640 }
641 
642 static void fl_engine_class_init(FlEngineClass* klass) {
643  G_OBJECT_CLASS(klass)->dispose = fl_engine_dispose;
644  G_OBJECT_CLASS(klass)->set_property = fl_engine_set_property;
645 
646  g_object_class_install_property(
647  G_OBJECT_CLASS(klass), PROP_BINARY_MESSENGER,
648  g_param_spec_object(
649  "binary-messenger", "messenger", "Binary messenger",
650  fl_binary_messenger_get_type(),
651  static_cast<GParamFlags>(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
652  G_PARAM_STATIC_STRINGS)));
653 
655  "on-pre-engine-restart", fl_engine_get_type(), G_SIGNAL_RUN_LAST, 0,
656  nullptr, nullptr, nullptr, G_TYPE_NONE, 0);
658  "update-semantics", fl_engine_get_type(), G_SIGNAL_RUN_LAST, 0, nullptr,
659  nullptr, nullptr, G_TYPE_NONE, 1, G_TYPE_POINTER);
660 }
661 
662 static void fl_engine_init(FlEngine* self) {
663  self->thread = g_thread_self();
664 
665  self->embedder_api.struct_size = sizeof(FlutterEngineProcTable);
666  if (FlutterEngineGetProcAddresses(&self->embedder_api) != kSuccess) {
667  g_warning("Failed get get engine function pointers");
668  }
669 
670  self->opengl_manager = fl_opengl_manager_new();
671 
672  self->display_monitor =
673  fl_display_monitor_new(self, gdk_display_get_default());
674  self->task_runner = fl_task_runner_new(self);
675 
676  // Implicit view is 0, so start at 1.
677  self->next_view_id = 1;
678  g_mutex_init(&self->renderables_mutex);
679  self->renderables_by_view_id = g_hash_table_new_full(
680  g_direct_hash, g_direct_equal, nullptr, [](gpointer value) {
681  GWeakRef* ref = static_cast<GWeakRef*>(value);
682  g_weak_ref_clear(ref);
683  free(ref);
684  });
685 
686  self->texture_registrar = fl_texture_registrar_new(self);
687 }
688 
689 static FlEngine* fl_engine_new_full(FlDartProject* project,
690  FlBinaryMessenger* binary_messenger) {
691  g_return_val_if_fail(FL_IS_DART_PROJECT(project), nullptr);
692 
693  FlEngine* self = FL_ENGINE(g_object_new(fl_engine_get_type(), nullptr));
694 
695  self->project = FL_DART_PROJECT(g_object_ref(project));
696  const gchar* renderer = g_getenv("FLUTTER_LINUX_RENDERER");
697  if (g_strcmp0(renderer, "software") == 0) {
698  self->renderer_type = kSoftware;
699  g_warning(
700  "Using the software renderer. Not all features are supported. This is "
701  "not recommended.\n"
702  "\n"
703  "To switch back to the default renderer, unset the "
704  "FLUTTER_LINUX_RENDERER environment variable.");
705  } else {
706  if (renderer != nullptr && strcmp(renderer, "opengl") != 0) {
707  g_warning("Unknown renderer type '%s', defaulting to opengl", renderer);
708  }
709  self->renderer_type = kOpenGL;
710  }
711 
712  if (binary_messenger != nullptr) {
713  self->binary_messenger =
714  FL_BINARY_MESSENGER(g_object_ref(binary_messenger));
715  } else {
716  self->binary_messenger = fl_binary_messenger_new(self);
717  }
718  self->keyboard_manager = fl_keyboard_manager_new(self);
719  self->mouse_cursor_handler =
720  fl_mouse_cursor_handler_new(self->binary_messenger);
721  self->accessibility_handler = fl_accessibility_handler_new(self);
722 
723  return self;
724 }
725 
726 FlEngine* fl_engine_for_id(int64_t id) {
727  void* engine = reinterpret_cast<void*>(id);
728  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
729  return FL_ENGINE(engine);
730 }
731 
732 G_MODULE_EXPORT FlEngine* fl_engine_new(FlDartProject* project) {
733  return fl_engine_new_full(project, nullptr);
734 }
735 
737  FlBinaryMessenger* binary_messenger) {
738  g_autoptr(FlDartProject) project = fl_dart_project_new();
739  return fl_engine_new_full(project, binary_messenger);
740 }
741 
742 G_MODULE_EXPORT FlEngine* fl_engine_new_headless(FlDartProject* project) {
743  return fl_engine_new(project);
744 }
745 
746 FlutterRendererType fl_engine_get_renderer_type(FlEngine* self) {
747  g_return_val_if_fail(FL_IS_ENGINE(self), static_cast<FlutterRendererType>(0));
748  return self->renderer_type;
749 }
750 
751 FlOpenGLManager* fl_engine_get_opengl_manager(FlEngine* self) {
752  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
753  return self->opengl_manager;
754 }
755 
756 FlDisplayMonitor* fl_engine_get_display_monitor(FlEngine* self) {
757  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
758  return self->display_monitor;
759 }
760 
761 gboolean fl_engine_start(FlEngine* self, GError** error) {
762  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
763 
764  FlutterRendererConfig config = {};
765  config.type = self->renderer_type;
766  switch (config.type) {
767  case kSoftware:
768  config.software.struct_size = sizeof(FlutterSoftwareRendererConfig);
769  // No action required, as this is handled in
770  // compositor_present_view_callback.
771  config.software.surface_present_callback =
772  [](void* user_data, const void* allocation, size_t row_bytes,
773  size_t height) { return true; };
774  break;
775  case kOpenGL:
776  config.open_gl.struct_size = sizeof(FlutterOpenGLRendererConfig);
777  config.open_gl.gl_proc_resolver = fl_engine_gl_proc_resolver;
778  config.open_gl.make_current = fl_engine_gl_make_current;
779  config.open_gl.clear_current = fl_engine_gl_clear_current;
780  config.open_gl.fbo_callback = fl_engine_gl_get_fbo;
781  // No action required, as this is handled in
782  // compositor_present_view_callback.
783  config.open_gl.present = [](void* user_data) { return true; };
784  config.open_gl.make_resource_current = fl_engine_gl_make_resource_current;
785  config.open_gl.gl_external_texture_frame_callback =
787  break;
788  case kMetal:
789  case kVulkan:
790  default:
792  "Unsupported renderer type");
793  return FALSE;
794  }
795 
796  FlutterTaskRunnerDescription platform_task_runner = {};
797  platform_task_runner.struct_size = sizeof(FlutterTaskRunnerDescription);
798  platform_task_runner.user_data = self;
799  platform_task_runner.runs_task_on_current_thread_callback =
801  platform_task_runner.post_task_callback = fl_engine_post_task;
802  platform_task_runner.identifier = kPlatformTaskRunnerIdentifier;
803 
804  FlutterCustomTaskRunners custom_task_runners = {};
805  custom_task_runners.struct_size = sizeof(FlutterCustomTaskRunners);
806  custom_task_runners.platform_task_runner = &platform_task_runner;
807 
808  switch (fl_dart_project_get_ui_thread_policy(self->project)) {
810  break;
813  custom_task_runners.ui_task_runner = &platform_task_runner;
814  break;
815  }
816 
817  const std::vector<std::string> env_switches =
819 
820  gboolean enable_impeller = fl_dart_project_get_enable_impeller(self->project);
821  gboolean has_enable_impeller = FALSE;
822  for (const auto& env_switch : env_switches) {
823  if (env_switch == "--enable-impeller" ||
824  env_switch == "--enable-impeller=true") {
825  enable_impeller = TRUE;
826  has_enable_impeller = TRUE;
827  } else if (env_switch == "--enable-impeller=false") {
828  enable_impeller = FALSE;
829  has_enable_impeller = TRUE;
830  }
831  }
832 
833  g_autoptr(GPtrArray) command_line_args =
834  g_ptr_array_new_with_free_func(g_free);
835  g_ptr_array_insert(command_line_args, 0, g_strdup("flutter"));
836  for (const auto& env_switch : env_switches) {
837  g_ptr_array_add(command_line_args, g_strdup(env_switch.c_str()));
838  }
839  // Linux (and other desktop platforms) always uses SDFs.
840  g_ptr_array_add(command_line_args, g_strdup("--impeller-use-sdfs"));
841 
842  if (enable_impeller && !has_enable_impeller) {
843  g_ptr_array_add(command_line_args, g_strdup("--enable-impeller"));
844  }
845 
846  // Forward the project's Flutter GPU setting unless an environment switch
847  // already carries it (the switch is presence based, so it is only ever
848  // added, never negated).
849  if (fl_dart_project_get_enable_flutter_gpu(self->project)) {
850  gboolean has_enable_flutter_gpu = FALSE;
851  for (const auto& env_switch : env_switches) {
852  if (env_switch == "--enable-flutter-gpu" ||
853  env_switch == "--enable-flutter-gpu=true") {
854  has_enable_flutter_gpu = TRUE;
855  break;
856  }
857  }
858  if (!has_enable_flutter_gpu) {
859  g_ptr_array_add(command_line_args, g_strdup("--enable-flutter-gpu"));
860  }
861  }
862 
863  gchar** dart_entrypoint_args =
865 
866  FlutterProjectArgs args = {};
867  args.struct_size = sizeof(FlutterProjectArgs);
868  args.assets_path = fl_dart_project_get_assets_path(self->project);
869  args.icu_data_path = fl_dart_project_get_icu_data_path(self->project);
870  args.command_line_argc = command_line_args->len;
871  args.command_line_argv =
872  reinterpret_cast<const char* const*>(command_line_args->pdata);
873  args.platform_message_callback = fl_engine_platform_message_cb;
874  args.update_semantics_callback2 = fl_engine_update_semantics_cb;
875  args.custom_task_runners = &custom_task_runners;
876  args.shutdown_dart_vm_when_done = true;
877  args.on_pre_engine_restart_callback = fl_engine_on_pre_engine_restart_cb;
878  args.dart_entrypoint_argc =
879  dart_entrypoint_args != nullptr ? g_strv_length(dart_entrypoint_args) : 0;
880  args.dart_entrypoint_argv =
881  reinterpret_cast<const char* const*>(dart_entrypoint_args);
882  args.engine_id = reinterpret_cast<int64_t>(self);
883 
884  FlutterCompositor compositor = {};
885  compositor.struct_size = sizeof(FlutterCompositor);
886  compositor.user_data = self;
887  compositor.create_backing_store_callback =
889  compositor.collect_backing_store_callback =
891  compositor.present_view_callback = compositor_present_view_callback;
892  args.compositor = &compositor;
893 
894  if (self->embedder_api.RunsAOTCompiledDartCode()) {
895  FlutterEngineAOTDataSource source = {};
896  source.type = kFlutterEngineAOTDataSourceTypeElfPath;
897  source.elf_path = fl_dart_project_get_aot_library_path(self->project);
898  if (self->embedder_api.CreateAOTData(&source, &self->aot_data) !=
899  kSuccess) {
901  "Failed to create AOT data");
902  return FALSE;
903  }
904  args.aot_data = self->aot_data;
905  }
906 
907  FlutterEngineResult result = self->embedder_api.Initialize(
908  FLUTTER_ENGINE_VERSION, &config, &args, self, &self->engine);
909  if (result != kSuccess) {
911  "Failed to initialize Flutter engine");
912  return FALSE;
913  }
914 
915  result = self->embedder_api.RunInitialized(self->engine);
916  if (result != kSuccess) {
918  "Failed to run Flutter engine");
919  return FALSE;
920  }
921 
922  setup_locales(self);
923 
924  g_autoptr(FlSettings) settings = fl_settings_new();
925  self->settings_handler = fl_settings_handler_new(self);
926  fl_settings_handler_start(self->settings_handler, settings);
927 
928  self->platform_handler = fl_platform_handler_new(self->binary_messenger);
929 
930  setup_keyboard(self);
931 
932  result = self->embedder_api.UpdateSemanticsEnabled(self->engine, TRUE);
933  if (result != kSuccess) {
934  g_warning("Failed to enable accessibility features on Flutter engine");
935  }
936 
937  fl_display_monitor_start(self->display_monitor);
938 
939  return TRUE;
940 }
941 
942 FlutterEngineProcTable* fl_engine_get_embedder_api(FlEngine* self) {
943  return &(self->embedder_api);
944 }
945 
947  const FlutterEngineDisplay* displays,
948  size_t displays_length) {
949  g_return_if_fail(FL_IS_ENGINE(self));
950 
951  FlutterEngineResult result = self->embedder_api.NotifyDisplayUpdate(
952  self->engine, kFlutterEngineDisplaysUpdateTypeStartup, displays,
953  displays_length);
954  if (result != kSuccess) {
955  g_warning("Failed to notify display update to Flutter engine: %d", result);
956  }
957 }
958 
959 void fl_engine_set_implicit_view(FlEngine* self, FlRenderable* renderable) {
960  set_renderable(self, flutter::kFlutterImplicitViewId, renderable);
961 }
962 
963 FlutterViewId fl_engine_add_view(FlEngine* self,
964  FlRenderable* renderable,
965  size_t min_width,
966  size_t min_height,
967  size_t max_width,
968  size_t max_height,
969  double pixel_ratio,
970  GCancellable* cancellable,
971  GAsyncReadyCallback callback,
972  gpointer user_data) {
973  g_return_val_if_fail(FL_IS_ENGINE(self), -1);
974 
975  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
976 
977  FlutterViewId view_id = self->next_view_id;
978  self->next_view_id++;
979 
981 
982  // We don't know which display this view will open on, so set to zero and this
983  // will be updated in a following FlutterWindowMetricsEvent
984  FlutterEngineDisplayId display_id = 0;
985 
986  FlutterWindowMetricsEvent metrics = {};
987  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
988  metrics.width = min_width;
989  metrics.height = min_height;
990  metrics.pixel_ratio = pixel_ratio;
991  metrics.display_id = display_id;
992  metrics.view_id = view_id;
993  metrics.has_constraints = true;
994  metrics.min_width_constraint = min_width;
995  metrics.min_height_constraint = min_height;
996  metrics.max_width_constraint = max_width;
997  metrics.max_height_constraint = max_height;
998  FlutterAddViewInfo info;
999  info.struct_size = sizeof(FlutterAddViewInfo);
1000  info.view_id = view_id;
1001  info.view_metrics = &metrics;
1002  info.user_data = g_object_ref(task);
1003  info.add_view_callback = view_added_cb;
1004  FlutterEngineResult result = self->embedder_api.AddView(self->engine, &info);
1005  if (result != kSuccess) {
1006  g_task_return_new_error(task, fl_engine_error_quark(),
1007  FL_ENGINE_ERROR_FAILED, "AddView returned %d",
1008  result);
1009  // This would have been done in the callback, but that won't occur now.
1010  g_object_unref(task);
1011  }
1012 
1013  return view_id;
1014 }
1015 
1016 gboolean fl_engine_add_view_finish(FlEngine* self,
1017  GAsyncResult* result,
1018  GError** error) {
1019  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1020  return g_task_propagate_boolean(G_TASK(result), error);
1021 }
1022 
1023 FlRenderable* fl_engine_get_renderable(FlEngine* self, FlutterViewId view_id) {
1024  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1025 
1026  return get_renderable(self, view_id);
1027 }
1028 
1029 void fl_engine_remove_view(FlEngine* self,
1030  FlutterViewId view_id,
1031  GCancellable* cancellable,
1032  GAsyncReadyCallback callback,
1033  gpointer user_data) {
1034  g_return_if_fail(FL_IS_ENGINE(self));
1035 
1036  remove_renderable(self, view_id);
1037 
1038  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
1039 
1040  FlutterRemoveViewInfo info;
1041  info.struct_size = sizeof(FlutterRemoveViewInfo);
1042  info.view_id = view_id;
1043  info.user_data = g_object_ref(task);
1044  info.remove_view_callback = view_removed_cb;
1045  FlutterEngineResult result =
1046  self->embedder_api.RemoveView(self->engine, &info);
1047  if (result != kSuccess) {
1048  g_task_return_new_error(task, fl_engine_error_quark(),
1049  FL_ENGINE_ERROR_FAILED, "RemoveView returned %d",
1050  result);
1051  // This would have been done in the callback, but that won't occur now.
1052  g_object_unref(task);
1053  }
1054 }
1055 
1056 gboolean fl_engine_remove_view_finish(FlEngine* self,
1057  GAsyncResult* result,
1058  GError** error) {
1059  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1060  return g_task_propagate_boolean(G_TASK(result), error);
1061 }
1062 
1064  FlEngine* self,
1066  gpointer user_data,
1067  GDestroyNotify destroy_notify) {
1068  g_return_if_fail(FL_IS_ENGINE(self));
1069  g_return_if_fail(handler != nullptr);
1070 
1071  if (self->platform_message_handler_destroy_notify) {
1072  self->platform_message_handler_destroy_notify(
1073  self->platform_message_handler_data);
1074  }
1075 
1076  self->platform_message_handler = handler;
1077  self->platform_message_handler_data = user_data;
1078  self->platform_message_handler_destroy_notify = destroy_notify;
1079 }
1080 
1081 // Note: This function can be called from any thread.
1083  FlEngine* self,
1084  const FlutterPlatformMessageResponseHandle* handle,
1085  GBytes* response,
1086  GError** error) {
1087  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1088  g_return_val_if_fail(handle != nullptr, FALSE);
1089 
1090  if (self->engine == nullptr) {
1092  "No engine to send response to");
1093  return FALSE;
1094  }
1095 
1096  gsize data_length = 0;
1097  const uint8_t* data = nullptr;
1098  if (response != nullptr) {
1099  data =
1100  static_cast<const uint8_t*>(g_bytes_get_data(response, &data_length));
1101  }
1102  FlutterEngineResult result = self->embedder_api.SendPlatformMessageResponse(
1103  self->engine, handle, data, data_length);
1104 
1105  if (result != kSuccess) {
1107  "Failed to send platform message response");
1108  return FALSE;
1109  }
1110 
1111  return TRUE;
1112 }
1113 
1115  const gchar* channel,
1116  GBytes* message,
1117  GCancellable* cancellable,
1118  GAsyncReadyCallback callback,
1119  gpointer user_data) {
1120  g_return_if_fail(FL_IS_ENGINE(self));
1121 
1122  GTask* task = nullptr;
1123  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
1124  if (callback != nullptr) {
1125  task = g_task_new(self, cancellable, callback, user_data);
1126 
1127  if (self->engine == nullptr) {
1128  g_task_return_new_error(task, fl_engine_error_quark(),
1129  FL_ENGINE_ERROR_FAILED, "No engine to send to");
1130  g_object_unref(task);
1131  return;
1132  }
1133 
1134  FlutterEngineResult result =
1135  self->embedder_api.PlatformMessageCreateResponseHandle(
1136  self->engine, fl_engine_platform_message_response_cb, task,
1137  &response_handle);
1138  if (result != kSuccess) {
1139  g_task_return_new_error(task, fl_engine_error_quark(),
1141  "Failed to create response handle");
1142  g_object_unref(task);
1143  return;
1144  }
1145  } else if (self->engine == nullptr) {
1146  return;
1147  }
1148 
1149  FlutterPlatformMessage fl_message = {};
1150  fl_message.struct_size = sizeof(fl_message);
1151  fl_message.channel = channel;
1152  fl_message.message =
1153  message != nullptr
1154  ? static_cast<const uint8_t*>(g_bytes_get_data(message, nullptr))
1155  : nullptr;
1156  fl_message.message_size = message != nullptr ? g_bytes_get_size(message) : 0;
1157  fl_message.response_handle = response_handle;
1158  FlutterEngineResult result =
1159  self->embedder_api.SendPlatformMessage(self->engine, &fl_message);
1160 
1161  if (result != kSuccess && task != nullptr) {
1162  g_task_return_new_error(task, fl_engine_error_quark(),
1164  "Failed to send platform messages");
1165  g_object_unref(task);
1166  }
1167 
1168  if (response_handle != nullptr) {
1169  if (self->embedder_api.PlatformMessageReleaseResponseHandle(
1170  self->engine, response_handle) != kSuccess) {
1171  g_warning("Failed to release response handle");
1172  }
1173  }
1174 }
1175 
1177  GAsyncResult* result,
1178  GError** error) {
1179  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1180  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
1181 
1182  return static_cast<GBytes*>(g_task_propagate_pointer(G_TASK(result), error));
1183 }
1184 
1185 void fl_engine_schedule_frame(FlEngine* self) {
1186  g_return_if_fail(FL_IS_ENGINE(self));
1187 
1188  if (self->engine == nullptr) {
1189  return;
1190  }
1191 
1192  if (self->embedder_api.ScheduleFrame(self->engine) != kSuccess) {
1193  g_warning("Failed to schedule frame");
1194  }
1195 }
1196 
1198  FlutterEngineDisplayId display_id,
1199  FlutterViewId view_id,
1200  size_t min_width,
1201  size_t min_height,
1202  size_t max_width,
1203  size_t max_height,
1204  double pixel_ratio) {
1205  g_return_if_fail(FL_IS_ENGINE(self));
1206 
1207  if (self->engine == nullptr) {
1208  return;
1209  }
1210 
1211  FlutterWindowMetricsEvent event = {};
1212  event.struct_size = sizeof(FlutterWindowMetricsEvent);
1213  event.width = min_width;
1214  event.height = min_height;
1215  event.pixel_ratio = pixel_ratio;
1216  event.display_id = display_id;
1217  event.view_id = view_id;
1218  event.has_constraints = true;
1219  event.min_width_constraint = min_width;
1220  event.min_height_constraint = min_height;
1221  event.max_width_constraint = max_width;
1222  event.max_height_constraint = max_height;
1223  if (self->embedder_api.SendWindowMetricsEvent(self->engine, &event) !=
1224  kSuccess) {
1225  g_warning("Failed to send window metrics");
1226  }
1227 }
1228 
1230  FlutterViewId view_id,
1231  FlutterPointerPhase phase,
1232  size_t timestamp,
1233  double x,
1234  double y,
1235  FlutterPointerDeviceKind device_kind,
1236  double scroll_delta_x,
1237  double scroll_delta_y,
1238  int64_t buttons,
1239  double rotation,
1240  double pressure) {
1241  g_return_if_fail(FL_IS_ENGINE(self));
1242 
1243  if (self->engine == nullptr) {
1244  return;
1245  }
1246 
1247  FlutterPointerEvent fl_event = {};
1248  fl_event.struct_size = sizeof(fl_event);
1249  fl_event.phase = phase;
1250  fl_event.timestamp = timestamp;
1251  fl_event.x = x;
1252  fl_event.y = y;
1253  if (scroll_delta_x != 0 || scroll_delta_y != 0) {
1254  fl_event.signal_kind = kFlutterPointerSignalKindScroll;
1255  }
1256  fl_event.scroll_delta_x = scroll_delta_x;
1257  fl_event.scroll_delta_y = scroll_delta_y;
1258  fl_event.device_kind = device_kind;
1259  fl_event.buttons = buttons;
1260  fl_event.device = kMousePointerDeviceId;
1261  fl_event.view_id = view_id;
1262  // GDK reports tablet pressure through GDK_AXIS_PRESSURE. The GDK input device
1263  // documentation defines pressure as normalized from 0.0 to 1.0, which matches
1264  // Flutter's expected pressure range.
1265  // See: https://refspecs.linuxbase.org/gtk/2.6/gdk/gdk-Input-Devices.html
1266  fl_event.pressure = pressure;
1267  fl_event.pressure_min = 0.0;
1268  fl_event.pressure_max = 1.0;
1269  // GTK reports rotation in degrees, so convert it to radians for
1270  // FlutterPointerEvent.rotation.
1271  fl_event.rotation = rotation * G_PI / 180.0;
1272  if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
1273  kSuccess) {
1274  g_warning("Failed to send pointer event");
1275  }
1276 }
1277 
1278 void fl_engine_send_touch_up_event(FlEngine* self,
1279  FlutterViewId view_id,
1280  size_t timestamp,
1281  double x,
1282  double y,
1283  int32_t device) {
1284  g_return_if_fail(FL_IS_ENGINE(self));
1285 
1286  if (self->engine == nullptr) {
1287  return;
1288  }
1289 
1290  FlutterPointerEvent event = {};
1291  event.timestamp = timestamp;
1292  event.x = x;
1293  event.y = y;
1294  event.device_kind = kFlutterPointerDeviceKindTouch;
1295  event.device = device;
1296  event.buttons = 0;
1297  event.view_id = view_id;
1298  event.phase = FlutterPointerPhase::kUp;
1299  event.struct_size = sizeof(event);
1300 
1301  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1302  kSuccess) {
1303  g_warning("Failed to send pointer event");
1304  }
1305 }
1306 
1308  FlutterViewId view_id,
1309  size_t timestamp,
1310  double x,
1311  double y,
1312  int32_t device) {
1313  g_return_if_fail(FL_IS_ENGINE(self));
1314 
1315  if (self->engine == nullptr) {
1316  return;
1317  }
1318 
1319  FlutterPointerEvent event = {};
1320  event.timestamp = timestamp;
1321  event.x = x;
1322  event.y = y;
1323  event.device_kind = kFlutterPointerDeviceKindTouch;
1324  event.device = device;
1325  event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
1326  event.view_id = view_id;
1327  event.phase = FlutterPointerPhase::kDown;
1328  event.struct_size = sizeof(event);
1329 
1330  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1331  kSuccess) {
1332  g_warning("Failed to send pointer event");
1333  }
1334 }
1335 
1337  FlutterViewId view_id,
1338  size_t timestamp,
1339  double x,
1340  double y,
1341  int32_t device) {
1342  g_return_if_fail(FL_IS_ENGINE(self));
1343 
1344  if (self->engine == nullptr) {
1345  return;
1346  }
1347 
1348  FlutterPointerEvent event = {};
1349  event.timestamp = timestamp;
1350  event.x = x;
1351  event.y = y;
1352  event.device_kind = kFlutterPointerDeviceKindTouch;
1353  event.device = device;
1354  event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
1355  event.view_id = view_id;
1356  event.phase = FlutterPointerPhase::kMove;
1357  event.struct_size = sizeof(event);
1358 
1359  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1360  kSuccess) {
1361  g_warning("Failed to send pointer event");
1362  }
1363 }
1364 
1366  FlutterViewId view_id,
1367  size_t timestamp,
1368  double x,
1369  double y,
1370  int32_t device) {
1371  g_return_if_fail(FL_IS_ENGINE(self));
1372 
1373  if (self->engine == nullptr) {
1374  return;
1375  }
1376 
1377  FlutterPointerEvent event = {};
1378  event.timestamp = timestamp;
1379  event.x = x;
1380  event.y = y;
1381  event.device_kind = kFlutterPointerDeviceKindTouch;
1382  event.device = device;
1383  event.buttons = 0;
1384  event.view_id = view_id;
1385  event.phase = FlutterPointerPhase::kCancel;
1386  event.struct_size = sizeof(event);
1387 
1388  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1389  kSuccess) {
1390  g_warning("Failed to send touch cancel event");
1391  }
1392 }
1393 
1395  FlutterViewId view_id,
1396  size_t timestamp,
1397  double x,
1398  double y,
1399  int32_t device) {
1400  g_return_if_fail(FL_IS_ENGINE(self));
1401 
1402  if (self->engine == nullptr) {
1403  return;
1404  }
1405 
1406  FlutterPointerEvent event = {};
1407  event.timestamp = timestamp;
1408  event.x = x;
1409  event.y = y;
1410  event.device_kind = kFlutterPointerDeviceKindTouch;
1411  event.device = device;
1412  event.buttons = 0;
1413  event.view_id = view_id;
1414  event.phase = FlutterPointerPhase::kAdd;
1415  event.struct_size = sizeof(event);
1416 
1417  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1418  kSuccess) {
1419  g_warning("Failed to send pointer event");
1420  }
1421 }
1422 
1424  FlutterViewId view_id,
1425  size_t timestamp,
1426  double x,
1427  double y,
1428  int32_t device) {
1429  g_return_if_fail(FL_IS_ENGINE(self));
1430 
1431  if (self->engine == nullptr) {
1432  return;
1433  }
1434 
1435  FlutterPointerEvent event = {};
1436  event.timestamp = timestamp;
1437  event.x = x;
1438  event.y = y;
1439  event.device_kind = kFlutterPointerDeviceKindTouch;
1440  event.device = device;
1441  event.buttons = 0;
1442  event.view_id = view_id;
1443  event.phase = FlutterPointerPhase::kRemove;
1444  event.struct_size = sizeof(event);
1445 
1446  if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1447  kSuccess) {
1448  g_warning("Failed to send pointer event");
1449  }
1450 }
1451 
1453  FlutterViewId view_id,
1454  size_t timestamp,
1455  double x,
1456  double y,
1457  FlutterPointerPhase phase,
1458  double pan_x,
1459  double pan_y,
1460  double scale,
1461  double rotation) {
1462  g_return_if_fail(FL_IS_ENGINE(self));
1463 
1464  if (self->engine == nullptr) {
1465  return;
1466  }
1467 
1468  FlutterPointerEvent fl_event = {};
1469  fl_event.struct_size = sizeof(fl_event);
1470  fl_event.timestamp = timestamp;
1471  fl_event.x = x;
1472  fl_event.y = y;
1473  fl_event.phase = phase;
1474  fl_event.pan_x = pan_x;
1475  fl_event.pan_y = pan_y;
1476  fl_event.scale = scale;
1477  fl_event.rotation = rotation;
1478  fl_event.device = kPointerPanZoomDeviceId;
1479  fl_event.device_kind = kFlutterPointerDeviceKindTrackpad;
1480  fl_event.view_id = view_id;
1481  if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
1482  kSuccess) {
1483  g_warning("Failed to send pointer event");
1484  }
1485 }
1486 
1487 static void send_key_event_cb(bool handled, void* user_data) {
1488  g_autoptr(GTask) task = G_TASK(user_data);
1489  gboolean* return_value = g_new0(gboolean, 1);
1490  *return_value = handled;
1491  g_task_return_pointer(task, return_value, g_free);
1492 }
1493 
1494 void fl_engine_send_key_event(FlEngine* self,
1495  const FlutterKeyEvent* event,
1496  GCancellable* cancellable,
1497  GAsyncReadyCallback callback,
1498  gpointer user_data) {
1499  g_return_if_fail(FL_IS_ENGINE(self));
1500 
1501  g_autoptr(GTask) task = g_task_new(self, cancellable, callback, user_data);
1502 
1503  if (self->engine == nullptr) {
1504  g_task_return_new_error(task, fl_engine_error_quark(),
1505  FL_ENGINE_ERROR_FAILED, "No engine");
1506  return;
1507  }
1508 
1509  if (self->embedder_api.SendKeyEvent(self->engine, event, send_key_event_cb,
1510  g_object_ref(task)) != kSuccess) {
1511  g_task_return_new_error(task, fl_engine_error_quark(),
1512  FL_ENGINE_ERROR_FAILED, "Failed to send key event");
1513  g_object_unref(task);
1514  }
1515 }
1516 
1517 gboolean fl_engine_send_key_event_finish(FlEngine* self,
1518  GAsyncResult* result,
1519  gboolean* handled,
1520  GError** error) {
1521  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1522  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
1523 
1524  g_autofree gboolean* return_value =
1525  static_cast<gboolean*>(g_task_propagate_pointer(G_TASK(result), error));
1526  if (return_value == nullptr) {
1527  return FALSE;
1528  }
1529 
1530  *handled = *return_value;
1531  return TRUE;
1532 }
1533 
1535  FlutterViewId view_id,
1536  uint64_t node_id,
1537  FlutterSemanticsAction action,
1538  GBytes* data) {
1539  g_return_if_fail(FL_IS_ENGINE(self));
1540 
1541  if (self->engine == nullptr) {
1542  return;
1543  }
1544 
1545  const uint8_t* action_data = nullptr;
1546  size_t action_data_length = 0;
1547  if (data != nullptr) {
1548  action_data = static_cast<const uint8_t*>(
1549  g_bytes_get_data(data, &action_data_length));
1550  }
1551 
1552  FlutterSendSemanticsActionInfo info;
1553  info.struct_size = sizeof(FlutterSendSemanticsActionInfo);
1554  info.view_id = view_id;
1555  info.node_id = node_id;
1556  info.action = action;
1557  info.data = action_data;
1558  info.data_length = action_data_length;
1559  if (self->embedder_api.SendSemanticsAction(self->engine, &info) != kSuccess) {
1560  g_warning("Failed to send semantics action");
1561  }
1562 }
1563 
1565  int64_t texture_id) {
1566  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1567  return self->embedder_api.MarkExternalTextureFrameAvailable(
1568  self->engine, texture_id) == kSuccess;
1569 }
1570 
1571 gboolean fl_engine_register_external_texture(FlEngine* self,
1572  int64_t texture_id) {
1573  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1574  return self->embedder_api.RegisterExternalTexture(self->engine, texture_id) ==
1575  kSuccess;
1576 }
1577 
1579  int64_t texture_id) {
1580  g_return_val_if_fail(FL_IS_ENGINE(self), FALSE);
1581  return self->embedder_api.UnregisterExternalTexture(self->engine,
1582  texture_id) == kSuccess;
1583 }
1584 
1585 G_MODULE_EXPORT FlBinaryMessenger* fl_engine_get_binary_messenger(
1586  FlEngine* self) {
1587  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1588  return self->binary_messenger;
1589 }
1590 
1591 FlTaskRunner* fl_engine_get_task_runner(FlEngine* self) {
1592  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1593  return self->task_runner;
1594 }
1595 
1596 void fl_engine_execute_task(FlEngine* self, FlutterTask* task) {
1597  g_return_if_fail(FL_IS_ENGINE(self));
1598  if (self->embedder_api.RunTask(self->engine, task) != kSuccess) {
1599  g_warning("Failed to run task");
1600  }
1601 }
1602 
1603 G_MODULE_EXPORT FlTextureRegistrar* fl_engine_get_texture_registrar(
1604  FlEngine* self) {
1605  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1606  return self->texture_registrar;
1607 }
1608 
1609 void fl_engine_update_accessibility_features(FlEngine* self, int32_t flags) {
1610  g_return_if_fail(FL_IS_ENGINE(self));
1611 
1612  if (self->engine == nullptr) {
1613  return;
1614  }
1615 
1616  if (self->embedder_api.UpdateAccessibilityFeatures(
1617  self->engine, static_cast<FlutterAccessibilityFeature>(flags)) !=
1618  kSuccess) {
1619  g_warning("Failed to update accessibility features");
1620  }
1621 }
1622 
1623 void fl_engine_request_app_exit(FlEngine* self) {
1624  g_return_if_fail(FL_IS_ENGINE(self));
1625  fl_platform_handler_request_app_exit(self->platform_handler);
1626 }
1627 
1628 FlKeyboardManager* fl_engine_get_keyboard_manager(FlEngine* self) {
1629  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1630  return self->keyboard_manager;
1631 }
1632 
1633 FlTextInputHandler* fl_engine_get_text_input_handler(FlEngine* self) {
1634  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1635  return self->text_input_handler;
1636 }
1637 
1638 FlMouseCursorHandler* fl_engine_get_mouse_cursor_handler(FlEngine* self) {
1639  g_return_val_if_fail(FL_IS_ENGINE(self), nullptr);
1640  return self->mouse_cursor_handler;
1641 }
FlAccessibilityHandler * fl_accessibility_handler_new(FlEngine *engine)
const char * message
g_autoptr(FlEngine) engine
FlRenderable * renderable
const char FlTextDirection FlAssertiveness gpointer user_data
@ PROP_LAST
@ PROP_0
G_DEFINE_QUARK(fl_binary_messenger_codec_error_quark, fl_binary_messenger_codec_error) G_DECLARE_FINAL_TYPE(FlBinaryMessengerImpl
FlBinaryMessenger * fl_binary_messenger_new(FlEngine *engine)
void fl_binary_messenger_shutdown(FlBinaryMessenger *self)
G_MODULE_EXPORT FlDartProject * fl_dart_project_new()
G_MODULE_EXPORT const gchar * fl_dart_project_get_aot_library_path(FlDartProject *self)
G_MODULE_EXPORT gboolean fl_dart_project_get_enable_impeller(FlDartProject *project)
G_MODULE_EXPORT gchar ** fl_dart_project_get_dart_entrypoint_arguments(FlDartProject *self)
G_MODULE_EXPORT gboolean fl_dart_project_get_enable_flutter_gpu(FlDartProject *project)
G_MODULE_EXPORT const gchar * fl_dart_project_get_icu_data_path(FlDartProject *self)
G_MODULE_EXPORT const gchar * fl_dart_project_get_assets_path(FlDartProject *self)
G_MODULE_EXPORT FlUIThreadPolicy fl_dart_project_get_ui_thread_policy(FlDartProject *project)
@ FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD
@ FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD
@ FL_UI_THREAD_POLICY_DEFAULT
void fl_display_monitor_start(FlDisplayMonitor *self)
FlDisplayMonitor * fl_display_monitor_new(FlEngine *engine, GdkDisplay *display)
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)
Definition: fl_engine.cc:436
G_MODULE_EXPORT FlTextureRegistrar * fl_engine_get_texture_registrar(FlEngine *self)
Definition: fl_engine.cc:1603
FlMouseCursorHandler * fl_engine_get_mouse_cursor_handler(FlEngine *self)
Definition: fl_engine.cc:1638
static bool fl_engine_runs_task_on_current_thread(void *user_data)
Definition: fl_engine.cc:477
static void fl_engine_on_pre_engine_restart_cb(void *user_data)
Definition: fl_engine.cc:543
void fl_engine_send_mouse_pointer_event(FlEngine *self, FlutterViewId view_id, FlutterPointerPhase phase, size_t timestamp, double x, double y, FlutterPointerDeviceKind device_kind, double scroll_delta_x, double scroll_delta_y, int64_t buttons, double rotation, double pressure)
Definition: fl_engine.cc:1229
void fl_engine_set_platform_message_handler(FlEngine *self, FlEnginePlatformMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
Definition: fl_engine.cc:1063
static FlPluginRegistrar * fl_engine_get_registrar_for_plugin(FlPluginRegistry *registry, const gchar *name)
Definition: fl_engine.cc:562
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
Definition: fl_engine.cc:121
static void view_added_cb(const FlutterAddViewResult *result)
Definition: fl_engine.cc:203
static bool compositor_create_backing_store_callback(const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out, void *user_data)
Definition: fl_engine.cc:365
static bool fl_engine_gl_make_current(void *user_data)
Definition: fl_engine.cc:415
gboolean fl_engine_send_key_event_finish(FlEngine *self, GAsyncResult *result, gboolean *handled, GError **error)
Definition: fl_engine.cc:1517
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:942
void fl_engine_dispatch_semantics_action(FlEngine *self, FlutterViewId view_id, uint64_t node_id, FlutterSemanticsAction action, GBytes *data)
Definition: fl_engine.cc:1534
static FlEngine * fl_engine_new_full(FlDartProject *project, FlBinaryMessenger *binary_messenger)
Definition: fl_engine.cc:689
static void parse_locale(const gchar *locale, gchar **language, gchar **territory, gchar **codeset, gchar **modifier)
Definition: fl_engine.cc:131
static void set_renderable(FlEngine *self, int64_t view_id, FlRenderable *renderable)
Stores a weak reference to the renderable with the given ID.
Definition: fl_engine.cc:175
void fl_engine_send_touch_up_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1278
void fl_engine_send_window_metrics_event(FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio)
Definition: fl_engine.cc:1197
void fl_engine_notify_display_update(FlEngine *self, const FlutterEngineDisplay *displays, size_t displays_length)
Definition: fl_engine.cc:946
static bool collect_opengl_backing_store(FlEngine *self, const FlutterBackingStore *backing_store)
Definition: fl_engine.cc:321
static bool compositor_present_view_callback(const FlutterPresentViewInfo *info)
Definition: fl_engine.cc:396
FlOpenGLManager * fl_engine_get_opengl_manager(FlEngine *self)
Definition: fl_engine.cc:751
static bool compositor_collect_backing_store_callback(const FlutterBackingStore *backing_store, void *user_data)
Definition: fl_engine.cc:381
FlutterRendererType fl_engine_get_renderer_type(FlEngine *self)
Definition: fl_engine.cc:746
static void remove_renderable(FlEngine *self, int64_t view_id)
Remove a renderable that no longer exists.
Definition: fl_engine.cc:198
static void fl_engine_dispose(GObject *object)
Definition: fl_engine.cc:592
gboolean fl_engine_mark_texture_frame_available(FlEngine *self, int64_t texture_id)
Definition: fl_engine.cc:1564
static bool create_opengl_backing_store(FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
Definition: fl_engine.cc:282
gboolean fl_engine_remove_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1056
FlTaskRunner * fl_engine_get_task_runner(FlEngine *self)
Definition: fl_engine.cc:1591
FlKeyboardManager * fl_engine_get_keyboard_manager(FlEngine *self)
Definition: fl_engine.cc:1628
FlDisplayMonitor * fl_engine_get_display_monitor(FlEngine *self)
Definition: fl_engine.cc:756
FlRenderable * fl_engine_get_renderable(FlEngine *self, FlutterViewId view_id)
Definition: fl_engine.cc:1023
static guint fl_engine_signals[LAST_SIGNAL]
Definition: fl_engine.cc:119
static void fl_engine_platform_message_response_cb(const uint8_t *data, size_t data_length, void *user_data)
Definition: fl_engine.cc:553
gboolean fl_engine_send_platform_message_response(FlEngine *self, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
Definition: fl_engine.cc:1082
static void fl_engine_init(FlEngine *self)
Definition: fl_engine.cc:662
static void fl_engine_post_task(FlutterTask task, uint64_t target_time_nanos, void *user_data)
Definition: fl_engine.cc:483
FlTextInputHandler * fl_engine_get_text_input_handler(FlEngine *self)
Definition: fl_engine.cc:1633
void fl_engine_set_implicit_view(FlEngine *self, FlRenderable *renderable)
Definition: fl_engine.cc:959
static uint32_t fl_engine_gl_get_fbo(void *user_data)
Definition: fl_engine.cc:425
FlutterViewId fl_engine_add_view(FlEngine *self, FlRenderable *renderable, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:963
static void view_removed_cb(const FlutterRemoveViewResult *result)
Definition: fl_engine.cc:214
gboolean fl_engine_unregister_external_texture(FlEngine *self, int64_t texture_id)
Definition: fl_engine.cc:1578
void fl_engine_send_platform_message(FlEngine *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1114
gboolean fl_engine_register_external_texture(FlEngine *self, int64_t texture_id)
Definition: fl_engine.cc:1571
FlEngine * fl_engine_for_id(int64_t id)
Definition: fl_engine.cc:726
static void * fl_engine_gl_proc_resolver(void *user_data, const char *name)
Definition: fl_engine.cc:411
void fl_engine_send_touch_move_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1336
static void fl_engine_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
Definition: fl_engine.cc:576
void fl_engine_send_touch_add_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1394
@ LAST_SIGNAL
Definition: fl_engine.cc:117
@ SIGNAL_UPDATE_SEMANTICS
Definition: fl_engine.cc:117
@ SIGNAL_ON_PRE_ENGINE_RESTART
Definition: fl_engine.cc:117
void fl_engine_remove_view(FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1029
G_MODULE_EXPORT FlBinaryMessenger * fl_engine_get_binary_messenger(FlEngine *self)
Definition: fl_engine.cc:1585
gboolean fl_engine_add_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1016
void fl_engine_send_key_event(FlEngine *self, const FlutterKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1494
static void setup_keyboard(FlEngine *self)
Definition: fl_engine.cc:519
static void free_locale(FlutterLocale *locale)
Definition: fl_engine.cc:225
void fl_engine_request_app_exit(FlEngine *self)
Definition: fl_engine.cc:1623
static void setup_locales(FlEngine *self)
Definition: fl_engine.cc:232
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)
Definition: fl_engine.cc:1452
static void fl_engine_update_semantics_cb(const FlutterSemanticsUpdate2 *update, void *user_data)
Definition: fl_engine.cc:512
static bool fl_engine_gl_make_resource_current(void *user_data)
Definition: fl_engine.cc:430
G_MODULE_EXPORT FlEngine * fl_engine_new_headless(FlDartProject *project)
Definition: fl_engine.cc:742
static FlRenderable * get_renderable(FlEngine *self, int64_t view_id)
Definition: fl_engine.cc:187
void fl_engine_update_accessibility_features(FlEngine *self, int32_t flags)
Definition: fl_engine.cc:1609
static void fl_engine_platform_message_cb(const FlutterPlatformMessage *message, void *user_data)
Definition: fl_engine.cc:492
void fl_engine_send_touch_remove_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1423
void fl_engine_send_touch_cancel_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1365
void fl_engine_execute_task(FlEngine *self, FlutterTask *task)
Definition: fl_engine.cc:1596
void fl_engine_send_touch_down_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
Definition: fl_engine.cc:1307
gboolean fl_engine_start(FlEngine *self, GError **error)
Definition: fl_engine.cc:761
static void send_key_event_cb(bool handled, void *user_data)
Definition: fl_engine.cc:1487
void fl_engine_schedule_frame(FlEngine *self)
Definition: fl_engine.cc:1185
static bool collect_software_backing_store(FlEngine *self, const FlutterBackingStore *backing_store)
Definition: fl_engine.cc:357
static constexpr size_t kPlatformTaskRunnerIdentifier
Definition: fl_engine.cc:31
FlEngine * fl_engine_new_with_binary_messenger(FlBinaryMessenger *binary_messenger)
Definition: fl_engine.cc:736
static constexpr int32_t kPointerPanZoomDeviceId
Definition: fl_engine.cc:36
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
Definition: fl_engine.cc:732
static constexpr int32_t kMousePointerDeviceId
Definition: fl_engine.cc:35
static void fl_engine_class_init(FlEngineClass *klass)
Definition: fl_engine.cc:642
static bool fl_engine_gl_clear_current(void *user_data)
Definition: fl_engine.cc:420
GBytes * fl_engine_send_platform_message_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1176
static void fl_engine_plugin_registry_iface_init(FlPluginRegistryInterface *iface)
Definition: fl_engine.cc:571
static bool create_software_backing_store(FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
Definition: fl_engine.cc:333
GQuark fl_engine_error_quark(void) G_GNUC_CONST
@ FL_ENGINE_ERROR_FAILED
gboolean(* FlEnginePlatformMessageHandler)(FlEngine *engine, const gchar *channel, GBytes *message, const FlutterPlatformMessageResponseHandle *response_handle, gpointer user_data)
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
GLuint fl_framebuffer_get_id(FlFramebuffer *self)
GLuint fl_framebuffer_get_texture_id(FlFramebuffer *self)
FlFramebuffer * fl_framebuffer_new_multisample(GLint format, size_t width, size_t height, gboolean use_msaa)
FlKeyboardHandler * fl_keyboard_handler_new(FlBinaryMessenger *messenger, FlKeyboardManager *keyboard_manager)
FlKeyboardManager * fl_keyboard_manager_new(FlEngine *engine)
FlMouseCursorHandler * fl_mouse_cursor_handler_new(FlBinaryMessenger *messenger)
FlOpenGLManager * fl_opengl_manager_new()
gboolean fl_opengl_manager_make_resource_current(FlOpenGLManager *self)
gboolean fl_opengl_manager_clear_current(FlOpenGLManager *self)
gboolean fl_opengl_manager_make_current(FlOpenGLManager *self)
int64_t id
gboolean fl_pixel_buffer_texture_populate(FlPixelBufferTexture *texture, uint32_t width, uint32_t height, FlutterOpenGLTexture *opengl_texture, GError **error)
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
const uint8_t uint32_t uint32_t GError ** error
FlPlatformHandler * fl_platform_handler_new(FlBinaryMessenger *messenger)
void fl_platform_handler_request_app_exit(FlPlatformHandler *self)
FlPluginRegistrar * fl_plugin_registrar_new(FlView *view, FlBinaryMessenger *messenger, FlTextureRegistrar *texture_registrar)
void fl_renderable_present_layers(FlRenderable *self, const FlutterLayer **layers, size_t layers_count)
FlSettings * fl_settings_new()
Definition: fl_settings.cc:55
void fl_settings_handler_start(FlSettingsHandler *self, FlSettings *settings)
FlSettingsHandler * fl_settings_handler_new(FlEngine *engine)
uint8_t value
guint prop_id
guint const GValue GParamSpec * pspec
G_BEGIN_DECLS FlSubsurface size_t size_t gint scale
void fl_task_runner_post_flutter_task(FlTaskRunner *self, FlutterTask task, uint64_t target_time_nanos)
FlTaskRunner * fl_task_runner_new(FlEngine *engine)
FlTextInputHandler * fl_text_input_handler_new(FlBinaryMessenger *messenger)
void fl_text_input_handler_set_widget(FlTextInputHandler *self, GtkWidget *widget)
GtkWidget * fl_text_input_handler_get_widget(FlTextInputHandler *self)
gboolean fl_texture_gl_populate(FlTextureGL *self, uint32_t width, uint32_t height, FlutterOpenGLTexture *opengl_texture, GError **error)
void fl_texture_registrar_shutdown(FlTextureRegistrar *self)
FlTextureRegistrar * fl_texture_registrar_new(FlEngine *engine)
FlTexture * fl_texture_registrar_lookup_texture(FlTextureRegistrar *self, int64_t texture_id)
G_BEGIN_DECLS FlutterViewId view_id
std::vector< std::string > GetSwitchesFromEnvironment()
FlTaskRunner * task_runner
Definition: fl_engine.cc:84
FlEnginePlatformMessageHandler platform_message_handler
Definition: fl_engine.cc:107
FlMouseCursorHandler * mouse_cursor_handler
Definition: fl_engine.cc:78
GDestroyNotify platform_message_handler_destroy_notify
Definition: fl_engine.cc:109
FlutterViewId next_view_id
Definition: fl_engine.cc:97
FlAccessibilityHandler * accessibility_handler
Definition: fl_engine.cc:66
FlSettingsHandler * settings_handler
Definition: fl_engine.cc:60
gpointer platform_message_handler_data
Definition: fl_engine.cc:108
FlOpenGLManager * opengl_manager
Definition: fl_engine.cc:54
GThread * thread
Definition: fl_engine.cc:42
FlPlatformHandler * platform_handler
Definition: fl_engine.cc:63
FLUTTER_API_SYMBOL(FlutterEngine) engine
FlutterRendererType renderer_type
Definition: fl_engine.cc:51
FlBinaryMessenger * binary_messenger
Definition: fl_engine.cc:57
FlDisplayMonitor * display_monitor
Definition: fl_engine.cc:48
GHashTable * renderables_by_view_id
Definition: fl_engine.cc:100
FlDartProject * project
Definition: fl_engine.cc:45
FlKeyboardManager * keyboard_manager
Definition: fl_engine.cc:69
GMutex renderables_mutex
Definition: fl_engine.cc:104
GObject parent_instance
Definition: fl_engine.cc:39
FlTextureRegistrar * texture_registrar
Definition: fl_engine.cc:81
FlutterEngineAOTData aot_data
Definition: fl_engine.cc:87
FlutterEngineProcTable embedder_api
Definition: fl_engine.cc:94
FlTextInputHandler * text_input_handler
Definition: fl_engine.cc:72
FlKeyboardHandler * keyboard_handler
Definition: fl_engine.cc:75
int64_t texture_id