12 #include "flutter/common/constants.h"
14 #include "flutter/shell/platform/embedder/embedder.h"
115 FlPluginRegistryInterface* iface);
125 G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(),
136 gchar* l = g_strdup(locale);
139 gchar* match = strrchr(l,
'@');
140 if (match !=
nullptr) {
141 if (modifier !=
nullptr) {
142 *modifier = g_strdup(match + 1);
145 }
else if (modifier !=
nullptr) {
149 match = strrchr(l,
'.');
150 if (match !=
nullptr) {
151 if (codeset !=
nullptr) {
152 *codeset = g_strdup(match + 1);
155 }
else if (codeset !=
nullptr) {
159 match = strrchr(l,
'_');
160 if (match !=
nullptr) {
161 if (territory !=
nullptr) {
162 *territory = g_strdup(match + 1);
165 }
else if (territory !=
nullptr) {
166 *territory =
nullptr;
169 if (language !=
nullptr) {
178 g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->renderables_mutex);
179 GWeakRef* ref = g_new(GWeakRef, 1);
181 g_hash_table_insert(self->renderables_by_view_id, GINT_TO_POINTER(
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) {
194 return FL_RENDERABLE(g_weak_ref_get(ref));
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));
204 g_autoptr(GTask) task = G_TASK(result->user_data);
207 g_task_return_boolean(task,
TRUE);
215 g_autoptr(GTask) task = G_TASK(result->user_data);
217 if (result->removed) {
218 g_task_return_boolean(task,
TRUE);
226 g_free(
const_cast<gchar*
>(locale->language_code));
227 g_free(
const_cast<gchar*
>(locale->country_code));
233 const gchar*
const* languages = g_get_language_names();
234 g_autoptr(GPtrArray) locales_array = g_ptr_array_new_with_free_func(
236 for (
int i = 0; languages[
i] !=
nullptr;
i++) {
237 g_autofree gchar* locale_string = g_strstrip(g_strdup(languages[
i]));
240 if (strcmp(locale_string,
"") == 0) {
244 g_autofree gchar* language =
nullptr;
245 g_autofree gchar* territory =
nullptr;
246 parse_locale(locale_string, &language, &territory,
nullptr,
nullptr);
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;
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;
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),
277 if (result != kSuccess) {
278 g_warning(
"Failed to set up Flutter locales");
284 const FlutterBackingStoreConfig* config,
285 FlutterBackingStore* backing_store_out) {
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;
298 general_format, config->size.width, config->size.height,
301 g_warning(
"Failed to create backing store");
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 =
310 backing_store_out->open_gl.framebuffer.target =
312 backing_store_out->open_gl.framebuffer.destruction_callback = [](
void* p) {
323 const FlutterBackingStore* backing_store) {
329 g_object_unref(backing_store->open_gl.framebuffer.user_data);
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) {
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) {
359 const FlutterBackingStore* backing_store) {
360 free(
const_cast<void*
>(backing_store->software.allocation));
366 const FlutterBackingStoreConfig* config,
367 FlutterBackingStore* backing_store_out,
369 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
370 switch (self->renderer_type) {
382 const FlutterBackingStore* backing_store,
384 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
385 switch (self->renderer_type) {
397 const FlutterPresentViewInfo* info) {
398 FlEngine*
self =
static_cast<FlEngine*
>(info->user_data);
412 return reinterpret_cast<void*
>(eglGetProcAddress(name));
416 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
421 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
431 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
441 FlutterOpenGLTexture* opengl_texture) {
442 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
443 if (!self->texture_registrar) {
449 if (texture ==
nullptr) {
450 g_warning(
"Unable to find texture %" G_GINT64_FORMAT,
texture_id);
456 if (FL_IS_TEXTURE_GL(texture)) {
458 opengl_texture, &
error);
459 }
else if (FL_IS_PIXEL_BUFFER_TEXTURE(texture)) {
464 g_warning(
"Unsupported texture type %" G_GINT64_FORMAT,
texture_id);
469 g_warning(
"%s",
error->message);
478 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
479 return self->thread == g_thread_self();
484 uint64_t target_time_nanos,
486 FlEngine*
self =
static_cast<FlEngine*
>(
user_data);
496 gboolean handled = FALSE;
497 if (self->platform_message_handler !=
nullptr) {
500 handled =
self->platform_message_handler(
502 self->platform_message_handler_data);
520 g_clear_object(&self->keyboard_manager);
523 g_clear_object(&self->keyboard_handler);
524 self->keyboard_handler =
528 self->text_input_handler !=
nullptr
531 g_clear_object(&self->text_input_handler);
533 if (widget !=
nullptr) {
557 g_task_return_pointer(task, g_bytes_new(data, data_length),
558 reinterpret_cast<GDestroyNotify
>(g_bytes_unref));
563 FlPluginRegistry* registry,
565 FlEngine*
self = FL_ENGINE(registry);
568 self->texture_registrar);
572 FlPluginRegistryInterface* iface) {
580 FlEngine*
self = FL_ENGINE(
object);
582 case PROP_BINARY_MESSENGER:
583 g_set_object(&self->binary_messenger,
584 FL_BINARY_MESSENGER(g_value_get_object(
value)));
587 G_OBJECT_WARN_INVALID_PROPERTY_ID(
object,
prop_id,
pspec);
593 FlEngine*
self = FL_ENGINE(
object);
595 if (self->engine !=
nullptr) {
596 if (self->embedder_api.Shutdown(self->engine) != kSuccess) {
597 g_warning(
"Failed to shutdown Flutter engine");
599 self->engine =
nullptr;
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");
606 self->aot_data =
nullptr;
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);
627 g_mutex_locker_new(&self->renderables_mutex);
628 g_clear_pointer(&self->renderables_by_view_id, g_hash_table_unref);
630 g_mutex_clear(&self->renderables_mutex);
632 if (self->platform_message_handler_destroy_notify) {
633 self->platform_message_handler_destroy_notify(
634 self->platform_message_handler_data);
636 self->platform_message_handler_data =
nullptr;
637 self->platform_message_handler_destroy_notify =
nullptr;
639 G_OBJECT_CLASS(fl_engine_parent_class)->dispose(
object);
646 g_object_class_install_property(
647 G_OBJECT_CLASS(klass), PROP_BINARY_MESSENGER,
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)));
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);
663 self->thread = g_thread_self();
665 self->embedder_api.struct_size =
sizeof(FlutterEngineProcTable);
666 if (FlutterEngineGetProcAddresses(&self->embedder_api) != kSuccess) {
667 g_warning(
"Failed get get engine function pointers");
672 self->display_monitor =
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);
690 FlBinaryMessenger* binary_messenger) {
691 g_return_val_if_fail(FL_IS_DART_PROJECT(project),
nullptr);
693 FlEngine*
self = FL_ENGINE(g_object_new(fl_engine_get_type(),
nullptr));
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;
700 "Using the software renderer. Not all features are supported. This is "
703 "To switch back to the default renderer, unset the "
704 "FLUTTER_LINUX_RENDERER environment variable.");
706 if (renderer !=
nullptr && strcmp(renderer,
"opengl") != 0) {
707 g_warning(
"Unknown renderer type '%s', defaulting to opengl", renderer);
709 self->renderer_type = kOpenGL;
712 if (binary_messenger !=
nullptr) {
713 self->binary_messenger =
714 FL_BINARY_MESSENGER(g_object_ref(binary_messenger));
719 self->mouse_cursor_handler =
727 void* engine =
reinterpret_cast<void*
>(
id);
728 g_return_val_if_fail(FL_IS_ENGINE(engine),
nullptr);
729 return FL_ENGINE(engine);
737 FlBinaryMessenger* binary_messenger) {
747 g_return_val_if_fail(FL_IS_ENGINE(
self),
static_cast<FlutterRendererType
>(0));
748 return self->renderer_type;
752 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
753 return self->opengl_manager;
757 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
758 return self->display_monitor;
762 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
764 FlutterRendererConfig config = {};
765 config.type =
self->renderer_type;
766 switch (config.type) {
768 config.software.struct_size =
sizeof(FlutterSoftwareRendererConfig);
771 config.software.surface_present_callback =
772 [](
void*
user_data,
const void* allocation,
size_t row_bytes,
773 size_t height) {
return true; };
776 config.open_gl.struct_size =
sizeof(FlutterOpenGLRendererConfig);
783 config.open_gl.present = [](
void*
user_data) {
return true; };
785 config.open_gl.gl_external_texture_frame_callback =
792 "Unsupported renderer type");
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 =
804 FlutterCustomTaskRunners custom_task_runners = {};
805 custom_task_runners.struct_size =
sizeof(FlutterCustomTaskRunners);
806 custom_task_runners.platform_task_runner = &platform_task_runner;
813 custom_task_runners.ui_task_runner = &platform_task_runner;
817 const std::vector<std::string> env_switches =
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;
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()));
840 g_ptr_array_add(command_line_args, g_strdup(
"--impeller-use-sdfs"));
842 if (enable_impeller && !has_enable_impeller) {
843 g_ptr_array_add(command_line_args, g_strdup(
"--enable-impeller"));
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;
858 if (!has_enable_flutter_gpu) {
859 g_ptr_array_add(command_line_args, g_strdup(
"--enable-flutter-gpu"));
863 gchar** dart_entrypoint_args =
866 FlutterProjectArgs
args = {};
867 args.struct_size =
sizeof(FlutterProjectArgs);
870 args.command_line_argc = command_line_args->len;
871 args.command_line_argv =
872 reinterpret_cast<const char* const*
>(command_line_args->pdata);
875 args.custom_task_runners = &custom_task_runners;
876 args.shutdown_dart_vm_when_done =
true;
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);
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 =
892 args.compositor = &compositor;
894 if (self->embedder_api.RunsAOTCompiledDartCode()) {
895 FlutterEngineAOTDataSource source = {};
896 source.type = kFlutterEngineAOTDataSourceTypeElfPath;
898 if (self->embedder_api.CreateAOTData(&source, &self->aot_data) !=
901 "Failed to create AOT data");
904 args.aot_data =
self->aot_data;
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");
915 result =
self->embedder_api.RunInitialized(self->engine);
916 if (result != kSuccess) {
918 "Failed to run Flutter engine");
932 result =
self->embedder_api.UpdateSemanticsEnabled(self->engine,
TRUE);
933 if (result != kSuccess) {
934 g_warning(
"Failed to enable accessibility features on Flutter engine");
943 return &(
self->embedder_api);
947 const FlutterEngineDisplay* displays,
948 size_t displays_length) {
949 g_return_if_fail(FL_IS_ENGINE(
self));
951 FlutterEngineResult result =
self->embedder_api.NotifyDisplayUpdate(
952 self->engine, kFlutterEngineDisplaysUpdateTypeStartup, displays,
954 if (result != kSuccess) {
955 g_warning(
"Failed to notify display update to Flutter engine: %d", result);
970 GCancellable* cancellable,
971 GAsyncReadyCallback callback,
973 g_return_val_if_fail(FL_IS_ENGINE(
self), -1);
977 FlutterViewId
view_id =
self->next_view_id;
978 self->next_view_id++;
984 FlutterEngineDisplayId display_id = 0;
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;
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);
1001 info.view_metrics = &metrics;
1002 info.user_data = g_object_ref(task);
1004 FlutterEngineResult result =
self->embedder_api.AddView(self->engine, &info);
1005 if (result != kSuccess) {
1010 g_object_unref(task);
1017 GAsyncResult* result,
1019 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1020 return g_task_propagate_boolean(G_TASK(result),
error);
1024 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1031 GCancellable* cancellable,
1032 GAsyncReadyCallback callback,
1034 g_return_if_fail(FL_IS_ENGINE(
self));
1040 FlutterRemoveViewInfo info;
1041 info.struct_size =
sizeof(FlutterRemoveViewInfo);
1043 info.user_data = g_object_ref(task);
1045 FlutterEngineResult result =
1046 self->embedder_api.RemoveView(self->engine, &info);
1047 if (result != kSuccess) {
1052 g_object_unref(task);
1057 GAsyncResult* result,
1059 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1060 return g_task_propagate_boolean(G_TASK(result),
error);
1067 GDestroyNotify destroy_notify) {
1068 g_return_if_fail(FL_IS_ENGINE(
self));
1069 g_return_if_fail(handler !=
nullptr);
1071 if (self->platform_message_handler_destroy_notify) {
1072 self->platform_message_handler_destroy_notify(
1073 self->platform_message_handler_data);
1076 self->platform_message_handler = handler;
1077 self->platform_message_handler_data =
user_data;
1078 self->platform_message_handler_destroy_notify = destroy_notify;
1084 const FlutterPlatformMessageResponseHandle* handle,
1087 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1088 g_return_val_if_fail(handle !=
nullptr, FALSE);
1090 if (self->engine ==
nullptr) {
1092 "No engine to send response to");
1096 gsize data_length = 0;
1097 const uint8_t* data =
nullptr;
1098 if (response !=
nullptr) {
1100 static_cast<const uint8_t*
>(g_bytes_get_data(response, &data_length));
1102 FlutterEngineResult result =
self->embedder_api.SendPlatformMessageResponse(
1103 self->engine, handle, data, data_length);
1105 if (result != kSuccess) {
1107 "Failed to send platform message response");
1115 const gchar* channel,
1117 GCancellable* cancellable,
1118 GAsyncReadyCallback callback,
1120 g_return_if_fail(FL_IS_ENGINE(
self));
1122 GTask* task =
nullptr;
1123 FlutterPlatformMessageResponseHandle* response_handle =
nullptr;
1124 if (callback !=
nullptr) {
1125 task = g_task_new(
self, cancellable, callback,
user_data);
1127 if (self->engine ==
nullptr) {
1130 g_object_unref(task);
1134 FlutterEngineResult result =
1135 self->embedder_api.PlatformMessageCreateResponseHandle(
1138 if (result != kSuccess) {
1141 "Failed to create response handle");
1142 g_object_unref(task);
1145 }
else if (self->engine ==
nullptr) {
1149 FlutterPlatformMessage fl_message = {};
1150 fl_message.struct_size =
sizeof(fl_message);
1151 fl_message.channel = channel;
1152 fl_message.message =
1154 ?
static_cast<const uint8_t*
>(g_bytes_get_data(
message,
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);
1161 if (result != kSuccess && task !=
nullptr) {
1164 "Failed to send platform messages");
1165 g_object_unref(task);
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");
1177 GAsyncResult* result,
1179 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1180 g_return_val_if_fail(g_task_is_valid(result,
self), FALSE);
1182 return static_cast<GBytes*
>(g_task_propagate_pointer(G_TASK(result),
error));
1186 g_return_if_fail(FL_IS_ENGINE(
self));
1188 if (self->engine ==
nullptr) {
1192 if (self->embedder_api.ScheduleFrame(self->engine) != kSuccess) {
1193 g_warning(
"Failed to schedule frame");
1198 FlutterEngineDisplayId display_id,
1204 double pixel_ratio) {
1205 g_return_if_fail(FL_IS_ENGINE(
self));
1207 if (self->engine ==
nullptr) {
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;
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) !=
1225 g_warning(
"Failed to send window metrics");
1231 FlutterPointerPhase phase,
1235 FlutterPointerDeviceKind device_kind,
1236 double scroll_delta_x,
1237 double scroll_delta_y,
1241 g_return_if_fail(FL_IS_ENGINE(
self));
1243 if (self->engine ==
nullptr) {
1247 FlutterPointerEvent fl_event = {};
1248 fl_event.struct_size =
sizeof(fl_event);
1249 fl_event.phase = phase;
1250 fl_event.timestamp = timestamp;
1253 if (scroll_delta_x != 0 || scroll_delta_y != 0) {
1254 fl_event.signal_kind = kFlutterPointerSignalKindScroll;
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;
1266 fl_event.pressure = pressure;
1267 fl_event.pressure_min = 0.0;
1268 fl_event.pressure_max = 1.0;
1271 fl_event.rotation = rotation * G_PI / 180.0;
1272 if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
1274 g_warning(
"Failed to send pointer event");
1284 g_return_if_fail(FL_IS_ENGINE(
self));
1286 if (self->engine ==
nullptr) {
1290 FlutterPointerEvent
event = {};
1291 event.timestamp = timestamp;
1294 event.device_kind = kFlutterPointerDeviceKindTouch;
1295 event.device = device;
1298 event.phase = FlutterPointerPhase::kUp;
1299 event.struct_size =
sizeof(event);
1301 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1303 g_warning(
"Failed to send pointer event");
1313 g_return_if_fail(FL_IS_ENGINE(
self));
1315 if (self->engine ==
nullptr) {
1319 FlutterPointerEvent
event = {};
1320 event.timestamp = timestamp;
1323 event.device_kind = kFlutterPointerDeviceKindTouch;
1324 event.device = device;
1325 event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
1327 event.phase = FlutterPointerPhase::kDown;
1328 event.struct_size =
sizeof(event);
1330 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1332 g_warning(
"Failed to send pointer event");
1342 g_return_if_fail(FL_IS_ENGINE(
self));
1344 if (self->engine ==
nullptr) {
1348 FlutterPointerEvent
event = {};
1349 event.timestamp = timestamp;
1352 event.device_kind = kFlutterPointerDeviceKindTouch;
1353 event.device = device;
1354 event.buttons = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
1356 event.phase = FlutterPointerPhase::kMove;
1357 event.struct_size =
sizeof(event);
1359 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1361 g_warning(
"Failed to send pointer event");
1371 g_return_if_fail(FL_IS_ENGINE(
self));
1373 if (self->engine ==
nullptr) {
1377 FlutterPointerEvent
event = {};
1378 event.timestamp = timestamp;
1381 event.device_kind = kFlutterPointerDeviceKindTouch;
1382 event.device = device;
1385 event.phase = FlutterPointerPhase::kCancel;
1386 event.struct_size =
sizeof(event);
1388 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1390 g_warning(
"Failed to send touch cancel event");
1400 g_return_if_fail(FL_IS_ENGINE(
self));
1402 if (self->engine ==
nullptr) {
1406 FlutterPointerEvent
event = {};
1407 event.timestamp = timestamp;
1410 event.device_kind = kFlutterPointerDeviceKindTouch;
1411 event.device = device;
1414 event.phase = FlutterPointerPhase::kAdd;
1415 event.struct_size =
sizeof(event);
1417 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1419 g_warning(
"Failed to send pointer event");
1429 g_return_if_fail(FL_IS_ENGINE(
self));
1431 if (self->engine ==
nullptr) {
1435 FlutterPointerEvent
event = {};
1436 event.timestamp = timestamp;
1439 event.device_kind = kFlutterPointerDeviceKindTouch;
1440 event.device = device;
1443 event.phase = FlutterPointerPhase::kRemove;
1444 event.struct_size =
sizeof(event);
1446 if (self->embedder_api.SendPointerEvent(self->engine, &event, 1) !=
1448 g_warning(
"Failed to send pointer event");
1457 FlutterPointerPhase phase,
1462 g_return_if_fail(FL_IS_ENGINE(
self));
1464 if (self->engine ==
nullptr) {
1468 FlutterPointerEvent fl_event = {};
1469 fl_event.struct_size =
sizeof(fl_event);
1470 fl_event.timestamp = timestamp;
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;
1479 fl_event.device_kind = kFlutterPointerDeviceKindTrackpad;
1481 if (self->embedder_api.SendPointerEvent(self->engine, &fl_event, 1) !=
1483 g_warning(
"Failed to send pointer event");
1489 gboolean* return_value = g_new0(gboolean, 1);
1490 *return_value = handled;
1491 g_task_return_pointer(task, return_value, g_free);
1495 const FlutterKeyEvent* event,
1496 GCancellable* cancellable,
1497 GAsyncReadyCallback callback,
1499 g_return_if_fail(FL_IS_ENGINE(
self));
1503 if (self->engine ==
nullptr) {
1510 g_object_ref(task)) != kSuccess) {
1513 g_object_unref(task);
1518 GAsyncResult* result,
1521 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1522 g_return_val_if_fail(g_task_is_valid(result,
self), FALSE);
1524 g_autofree gboolean* return_value =
1525 static_cast<gboolean*
>(g_task_propagate_pointer(G_TASK(result),
error));
1526 if (return_value ==
nullptr) {
1530 *handled = *return_value;
1537 FlutterSemanticsAction action,
1539 g_return_if_fail(FL_IS_ENGINE(
self));
1541 if (self->engine ==
nullptr) {
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));
1552 FlutterSendSemanticsActionInfo info;
1553 info.struct_size =
sizeof(FlutterSendSemanticsActionInfo);
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");
1566 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1567 return self->embedder_api.MarkExternalTextureFrameAvailable(
1573 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1574 return self->embedder_api.RegisterExternalTexture(self->engine,
texture_id) ==
1580 g_return_val_if_fail(FL_IS_ENGINE(
self), FALSE);
1581 return self->embedder_api.UnregisterExternalTexture(self->engine,
1587 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1588 return self->binary_messenger;
1592 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1593 return self->task_runner;
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");
1605 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1606 return self->texture_registrar;
1610 g_return_if_fail(FL_IS_ENGINE(
self));
1612 if (self->engine ==
nullptr) {
1616 if (self->embedder_api.UpdateAccessibilityFeatures(
1617 self->engine,
static_cast<FlutterAccessibilityFeature
>(flags)) !=
1619 g_warning(
"Failed to update accessibility features");
1624 g_return_if_fail(FL_IS_ENGINE(
self));
1629 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1630 return self->keyboard_manager;
1634 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1635 return self->text_input_handler;
1639 g_return_val_if_fail(FL_IS_ENGINE(
self),
nullptr);
1640 return self->mouse_cursor_handler;
FlAccessibilityHandler * fl_accessibility_handler_new(FlEngine *engine)
g_autoptr(FlEngine) engine
FlRenderable * renderable
const char FlTextDirection FlAssertiveness gpointer user_data
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)
G_MODULE_EXPORT FlTextureRegistrar * fl_engine_get_texture_registrar(FlEngine *self)
FlMouseCursorHandler * fl_engine_get_mouse_cursor_handler(FlEngine *self)
static bool fl_engine_runs_task_on_current_thread(void *user_data)
static void fl_engine_on_pre_engine_restart_cb(void *user_data)
void fl_engine_send_mouse_pointer_event(FlEngine *self, FlutterViewId view_id, FlutterPointerPhase phase, size_t timestamp, double x, double y, FlutterPointerDeviceKind device_kind, double scroll_delta_x, double scroll_delta_y, int64_t buttons, double rotation, double pressure)
void fl_engine_set_platform_message_handler(FlEngine *self, FlEnginePlatformMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
static FlPluginRegistrar * fl_engine_get_registrar_for_plugin(FlPluginRegistry *registry, const gchar *name)
G_DEFINE_TYPE_WITH_CODE(FlEngine, fl_engine, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(), fl_engine_plugin_registry_iface_init)) enum
static void view_added_cb(const FlutterAddViewResult *result)
static bool compositor_create_backing_store_callback(const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out, void *user_data)
static bool fl_engine_gl_make_current(void *user_data)
gboolean fl_engine_send_key_event_finish(FlEngine *self, GAsyncResult *result, gboolean *handled, GError **error)
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
void fl_engine_dispatch_semantics_action(FlEngine *self, FlutterViewId view_id, uint64_t node_id, FlutterSemanticsAction action, GBytes *data)
static FlEngine * fl_engine_new_full(FlDartProject *project, FlBinaryMessenger *binary_messenger)
static void parse_locale(const gchar *locale, gchar **language, gchar **territory, gchar **codeset, gchar **modifier)
static void set_renderable(FlEngine *self, int64_t view_id, FlRenderable *renderable)
Stores a weak reference to the renderable with the given ID.
void fl_engine_send_touch_up_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void fl_engine_send_window_metrics_event(FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio)
void fl_engine_notify_display_update(FlEngine *self, const FlutterEngineDisplay *displays, size_t displays_length)
static bool collect_opengl_backing_store(FlEngine *self, const FlutterBackingStore *backing_store)
static bool compositor_present_view_callback(const FlutterPresentViewInfo *info)
FlOpenGLManager * fl_engine_get_opengl_manager(FlEngine *self)
static bool compositor_collect_backing_store_callback(const FlutterBackingStore *backing_store, void *user_data)
FlutterRendererType fl_engine_get_renderer_type(FlEngine *self)
static void remove_renderable(FlEngine *self, int64_t view_id)
Remove a renderable that no longer exists.
static void fl_engine_dispose(GObject *object)
gboolean fl_engine_mark_texture_frame_available(FlEngine *self, int64_t texture_id)
static bool create_opengl_backing_store(FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
gboolean fl_engine_remove_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
FlTaskRunner * fl_engine_get_task_runner(FlEngine *self)
FlKeyboardManager * fl_engine_get_keyboard_manager(FlEngine *self)
FlDisplayMonitor * fl_engine_get_display_monitor(FlEngine *self)
FlRenderable * fl_engine_get_renderable(FlEngine *self, FlutterViewId view_id)
static guint fl_engine_signals[LAST_SIGNAL]
static void fl_engine_platform_message_response_cb(const uint8_t *data, size_t data_length, void *user_data)
gboolean fl_engine_send_platform_message_response(FlEngine *self, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
static void fl_engine_init(FlEngine *self)
static void fl_engine_post_task(FlutterTask task, uint64_t target_time_nanos, void *user_data)
FlTextInputHandler * fl_engine_get_text_input_handler(FlEngine *self)
void fl_engine_set_implicit_view(FlEngine *self, FlRenderable *renderable)
static uint32_t fl_engine_gl_get_fbo(void *user_data)
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)
static void view_removed_cb(const FlutterRemoveViewResult *result)
gboolean fl_engine_unregister_external_texture(FlEngine *self, int64_t texture_id)
void fl_engine_send_platform_message(FlEngine *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
gboolean fl_engine_register_external_texture(FlEngine *self, int64_t texture_id)
FlEngine * fl_engine_for_id(int64_t id)
static void * fl_engine_gl_proc_resolver(void *user_data, const char *name)
void fl_engine_send_touch_move_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
static void fl_engine_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
void fl_engine_send_touch_add_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
@ SIGNAL_UPDATE_SEMANTICS
@ SIGNAL_ON_PRE_ENGINE_RESTART
void fl_engine_remove_view(FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
G_MODULE_EXPORT FlBinaryMessenger * fl_engine_get_binary_messenger(FlEngine *self)
gboolean fl_engine_add_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
void fl_engine_send_key_event(FlEngine *self, const FlutterKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
static void setup_keyboard(FlEngine *self)
static void free_locale(FlutterLocale *locale)
void fl_engine_request_app_exit(FlEngine *self)
static void setup_locales(FlEngine *self)
void fl_engine_send_pointer_pan_zoom_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, FlutterPointerPhase phase, double pan_x, double pan_y, double scale, double rotation)
static void fl_engine_update_semantics_cb(const FlutterSemanticsUpdate2 *update, void *user_data)
static bool fl_engine_gl_make_resource_current(void *user_data)
G_MODULE_EXPORT FlEngine * fl_engine_new_headless(FlDartProject *project)
static FlRenderable * get_renderable(FlEngine *self, int64_t view_id)
void fl_engine_update_accessibility_features(FlEngine *self, int32_t flags)
static void fl_engine_platform_message_cb(const FlutterPlatformMessage *message, void *user_data)
void fl_engine_send_touch_remove_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void fl_engine_send_touch_cancel_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
void fl_engine_execute_task(FlEngine *self, FlutterTask *task)
void fl_engine_send_touch_down_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, int32_t device)
gboolean fl_engine_start(FlEngine *self, GError **error)
static void send_key_event_cb(bool handled, void *user_data)
void fl_engine_schedule_frame(FlEngine *self)
static bool collect_software_backing_store(FlEngine *self, const FlutterBackingStore *backing_store)
static constexpr size_t kPlatformTaskRunnerIdentifier
FlEngine * fl_engine_new_with_binary_messenger(FlBinaryMessenger *binary_messenger)
static constexpr int32_t kPointerPanZoomDeviceId
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
static constexpr int32_t kMousePointerDeviceId
static void fl_engine_class_init(FlEngineClass *klass)
static bool fl_engine_gl_clear_current(void *user_data)
GBytes * fl_engine_send_platform_message_finish(FlEngine *self, GAsyncResult *result, GError **error)
static void fl_engine_plugin_registry_iface_init(FlPluginRegistryInterface *iface)
static bool create_software_backing_store(FlEngine *self, const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
GQuark fl_engine_error_quark(void) G_GNUC_CONST
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)
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
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()
void fl_settings_handler_start(FlSettingsHandler *self, FlSettings *settings)
FlSettingsHandler * fl_settings_handler_new(FlEngine *engine)
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
FlEnginePlatformMessageHandler platform_message_handler
FlMouseCursorHandler * mouse_cursor_handler
GDestroyNotify platform_message_handler_destroy_notify
FlutterViewId next_view_id
FlAccessibilityHandler * accessibility_handler
FlSettingsHandler * settings_handler
gpointer platform_message_handler_data
FlOpenGLManager * opengl_manager
FlPlatformHandler * platform_handler
FLUTTER_API_SYMBOL(FlutterEngine) engine
FlutterRendererType renderer_type
FlBinaryMessenger * binary_messenger
FlDisplayMonitor * display_monitor
GHashTable * renderables_by_view_id
FlKeyboardManager * keyboard_manager
FlTextureRegistrar * texture_registrar
FlutterEngineAOTData aot_data
FlutterEngineProcTable embedder_api
FlTextInputHandler * text_input_handler
FlKeyboardHandler * keyboard_handler