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