12 #include "flutter/fml/logging.h"
13 #include "flutter/fml/paths.h"
14 #include "flutter/fml/platform/win/wstring_conversion.h"
18 #include "flutter/shell/platform/embedder/embedder_struct_macros.h"
26 #include "flutter/third_party/accessibility/ax/ax_node.h"
38 static std::chrono::nanoseconds SnapToNextTick(
39 std::chrono::nanoseconds value,
40 std::chrono::nanoseconds tick_phase,
41 std::chrono::nanoseconds tick_interval) {
42 std::chrono::nanoseconds offset = (tick_phase - value) % tick_interval;
43 if (offset != std::chrono::nanoseconds::zero())
44 offset = offset + tick_interval;
45 return value + offset;
52 FlutterRendererConfig GetOpenGLRendererConfig() {
53 FlutterRendererConfig config = {};
54 config.type = kOpenGL;
55 config.open_gl.struct_size =
sizeof(config.open_gl);
56 config.open_gl.make_current = [](
void*
user_data) ->
bool {
57 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
58 if (!host->egl_manager()) {
61 return host->egl_manager()->render_context()->MakeCurrent();
63 config.open_gl.clear_current = [](
void*
user_data) ->
bool {
64 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
65 if (!host->egl_manager()) {
68 return host->egl_manager()->render_context()->ClearCurrent();
70 config.open_gl.present = [](
void*
user_data) ->
bool { FML_UNREACHABLE(); };
71 config.open_gl.fbo_reset_after_present =
true;
72 config.open_gl.fbo_with_frame_info_callback =
73 [](
void*
user_data,
const FlutterFrameInfo* info) -> uint32_t {
76 config.open_gl.gl_proc_resolver = [](
void*
user_data,
77 const char* what) ->
void* {
78 return reinterpret_cast<void*
>(eglGetProcAddress(what));
80 config.open_gl.make_resource_current = [](
void*
user_data) ->
bool {
81 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
82 if (!host->egl_manager()) {
85 return host->egl_manager()->resource_context()->MakeCurrent();
87 config.open_gl.gl_external_texture_frame_callback =
89 FlutterOpenGLTexture* texture) ->
bool {
90 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
91 if (!host->texture_registrar()) {
94 return host->texture_registrar()->PopulateTexture(
texture_id, width, height,
104 FlutterRendererConfig GetSoftwareRendererConfig() {
105 FlutterRendererConfig config = {};
106 config.type = kSoftware;
107 config.software.struct_size =
sizeof(config.software);
108 config.software.surface_present_callback =
109 [](
void*
user_data,
const void* allocation,
size_t row_bytes,
119 const FlutterPlatformMessage& engine_message) {
122 message.channel = engine_message.channel;
123 message.message = engine_message.message;
124 message.message_size = engine_message.message_size;
125 message.response_handle = engine_message.response_handle;
131 FlutterLocale CovertToFlutterLocale(
const LanguageInfo& info) {
132 FlutterLocale locale = {};
133 locale.struct_size =
sizeof(FlutterLocale);
134 locale.language_code = info.language.c_str();
135 if (!info.region.empty()) {
136 locale.country_code = info.region.c_str();
138 if (!info.script.empty()) {
139 locale.script_code = info.script.c_str();
148 std::shared_ptr<WindowsProcTable> windows_proc_table)
150 windows_proc_table_(std::move(windows_proc_table)),
151 aot_data_(nullptr, nullptr),
153 if (windows_proc_table_ ==
nullptr) {
154 windows_proc_table_ = std::make_shared<WindowsProcTable>();
159 embedder_api_.struct_size =
sizeof(FlutterEngineProcTable);
160 FlutterEngineGetProcAddresses(&embedder_api_);
163 std::make_unique<TaskRunner>(
164 embedder_api_.GetCurrentTime, [
this](
const auto* task) {
167 <<
"Cannot post an engine task when engine is not running.";
170 if (embedder_api_.RunTask(engine_, task) != kSuccess) {
171 FML_LOG(ERROR) <<
"Failed to post an engine task.";
178 messenger_->SetEngine(
this);
179 plugin_registrar_ = std::make_unique<FlutterDesktopPluginRegistrar>();
180 plugin_registrar_->engine =
this;
183 std::make_unique<BinaryMessengerImpl>(messenger_->ToRef());
184 message_dispatcher_ =
185 std::make_unique<IncomingMessageDispatcher>(messenger_->ToRef());
188 std::make_unique<FlutterWindowsTextureRegistrar>(
this, gl_);
191 auto& switches = project_->GetSwitches();
192 enable_impeller_ = std::find(switches.begin(), switches.end(),
193 "--enable-impeller=true") != switches.end();
196 window_proc_delegate_manager_ = std::make_unique<WindowProcDelegateManager>();
197 window_proc_delegate_manager_->RegisterTopLevelWindowProcDelegate(
198 [](HWND hwnd, UINT msg, WPARAM wpar, LPARAM lpar,
void*
user_data,
203 BASE_DCHECK(that->lifecycle_manager_);
204 return that->lifecycle_manager_->WindowProc(hwnd, msg, wpar, lpar,
207 static_cast<void*
>(
this));
212 internal_plugin_registrar_ =
213 std::make_unique<PluginRegistrar>(plugin_registrar_.get());
215 accessibility_plugin_ = std::make_unique<AccessibilityPlugin>(
this);
217 accessibility_plugin_.get());
220 std::make_unique<CursorHandler>(messenger_wrapper_.get(),
this);
222 std::make_unique<PlatformHandler>(messenger_wrapper_.get(),
this);
223 settings_plugin_ = std::make_unique<SettingsPlugin>(messenger_wrapper_.get(),
227 FlutterWindowsEngine::~FlutterWindowsEngine() {
228 messenger_->SetEngine(
nullptr);
232 void FlutterWindowsEngine::SetSwitches(
233 const std::vector<std::string>& switches) {
234 project_->SetSwitches(switches);
237 bool FlutterWindowsEngine::Run() {
241 bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
242 if (!project_->HasValidPaths()) {
243 FML_LOG(ERROR) <<
"Missing or unresolvable paths to assets.";
246 std::string assets_path_string = project_->assets_path().u8string();
247 std::string icu_path_string = project_->icu_path().u8string();
248 if (embedder_api_.RunsAOTCompiledDartCode()) {
249 aot_data_ = project_->LoadAotData(embedder_api_);
251 FML_LOG(ERROR) <<
"Unable to start engine without AOT data.";
259 std::string executable_name = GetExecutableName();
260 std::vector<const char*> argv = {executable_name.c_str()};
261 std::vector<std::string> switches = project_->GetSwitches();
263 switches.begin(), switches.end(), std::back_inserter(argv),
264 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
266 const std::vector<std::string>& entrypoint_args =
267 project_->dart_entrypoint_arguments();
268 std::vector<const char*> entrypoint_argv;
270 entrypoint_args.begin(), entrypoint_args.end(),
271 std::back_inserter(entrypoint_argv),
272 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
275 FlutterTaskRunnerDescription platform_task_runner = {};
276 platform_task_runner.struct_size =
sizeof(FlutterTaskRunnerDescription);
277 platform_task_runner.user_data = task_runner_.get();
278 platform_task_runner.runs_task_on_current_thread_callback =
282 platform_task_runner.post_task_callback = [](FlutterTask task,
283 uint64_t target_time_nanos,
288 FlutterCustomTaskRunners custom_task_runners = {};
289 custom_task_runners.struct_size =
sizeof(FlutterCustomTaskRunners);
290 custom_task_runners.platform_task_runner = &platform_task_runner;
291 custom_task_runners.thread_priority_setter =
294 FlutterProjectArgs args = {};
295 args.struct_size =
sizeof(FlutterProjectArgs);
296 args.shutdown_dart_vm_when_done =
true;
297 args.assets_path = assets_path_string.c_str();
298 args.icu_data_path = icu_path_string.c_str();
299 args.command_line_argc =
static_cast<int>(argv.size());
300 args.command_line_argv = argv.empty() ? nullptr : argv.data();
308 if (!project_->dart_entrypoint().empty() && !entrypoint.empty() &&
309 project_->dart_entrypoint() != entrypoint) {
310 FML_LOG(ERROR) <<
"Conflicting entrypoints were specified in "
311 "FlutterDesktopEngineProperties.dart_entrypoint and "
312 "FlutterDesktopEngineRun(engine, entry_point). ";
315 if (!entrypoint.empty()) {
316 args.custom_dart_entrypoint = entrypoint.data();
317 }
else if (!project_->dart_entrypoint().empty()) {
318 args.custom_dart_entrypoint = project_->dart_entrypoint().c_str();
320 args.dart_entrypoint_argc =
static_cast<int>(entrypoint_argv.size());
321 args.dart_entrypoint_argv =
322 entrypoint_argv.empty() ? nullptr : entrypoint_argv.data();
323 args.platform_message_callback =
324 [](
const FlutterPlatformMessage* engine_message,
329 args.vsync_callback = [](
void*
user_data, intptr_t baton) ->
void {
333 args.on_pre_engine_restart_callback = [](
void*
user_data) {
337 args.update_semantics_callback2 = [](
const FlutterSemanticsUpdate2* update,
349 if (!accessibility_bridge) {
353 for (
size_t i = 0; i < update->node_count; i++) {
354 const FlutterSemanticsNode2* node = update->nodes[i];
355 accessibility_bridge->AddFlutterSemanticsNodeUpdate(*node);
358 for (
size_t i = 0; i < update->custom_action_count; i++) {
359 const FlutterSemanticsCustomAction2*
action = update->custom_actions[i];
360 accessibility_bridge->AddFlutterSemanticsCustomActionUpdate(*
action);
363 accessibility_bridge->CommitUpdates();
365 args.root_isolate_create_callback = [](
void*
user_data) {
367 if (host->root_isolate_create_callback_) {
368 host->root_isolate_create_callback_();
371 args.channel_update_callback = [](
const FlutterChannelUpdate* update,
374 if (SAFE_ACCESS(update, channel,
nullptr) !=
nullptr) {
375 std::string channel_name(update->channel);
376 host->OnChannelUpdate(std::move(channel_name),
377 SAFE_ACCESS(update, listening,
false));
381 args.custom_task_runners = &custom_task_runners;
383 if (!platform_view_plugin_) {
384 platform_view_plugin_ = std::make_unique<PlatformViewPlugin>(
385 messenger_wrapper_.get(), task_runner_.get());
388 auto resolver = [](
const char* name) ->
void* {
389 return reinterpret_cast<void*
>(::eglGetProcAddress(name));
394 compositor_ = std::make_unique<CompositorOpenGL>(
this, resolver);
396 compositor_ = std::make_unique<CompositorSoftware>(
this);
399 FlutterCompositor compositor = {};
400 compositor.struct_size =
sizeof(FlutterCompositor);
401 compositor.user_data =
this;
402 compositor.create_backing_store_callback =
403 [](
const FlutterBackingStoreConfig* config,
404 FlutterBackingStore* backing_store_out,
void*
user_data) ->
bool {
407 return host->compositor_->CreateBackingStore(*config, backing_store_out);
410 compositor.collect_backing_store_callback =
411 [](
const FlutterBackingStore* backing_store,
void*
user_data) ->
bool {
414 return host->compositor_->CollectBackingStore(backing_store);
417 compositor.present_view_callback =
418 [](
const FlutterPresentViewInfo* info) ->
bool {
421 return host->compositor_->Present(info->view_id, info->layers,
424 args.compositor = &compositor;
427 args.aot_data = aot_data_.get();
432 FML_DCHECK(!egl_manager_ || !egl_manager_->HasContextCurrent());
434 FlutterRendererConfig renderer_config;
436 if (enable_impeller_) {
440 FML_LOG(ERROR) <<
"Could not create surface manager. Impeller backend "
441 "does not support software rendering.";
444 renderer_config = GetOpenGLRendererConfig();
447 egl_manager_ ? GetOpenGLRendererConfig() : GetSoftwareRendererConfig();
450 auto result = embedder_api_.Run(FLUTTER_ENGINE_VERSION, &renderer_config,
451 &args,
this, &engine_);
452 if (result != kSuccess || engine_ ==
nullptr) {
453 FML_LOG(ERROR) <<
"Failed to start Flutter engine: error " << result;
458 FlutterEngineDisplay display = {};
459 display.struct_size =
sizeof(FlutterEngineDisplay);
460 display.display_id = 0;
461 display.single_display =
true;
462 display.refresh_rate =
463 1.0 / (
static_cast<double>(FrameInterval().count()) / 1000000000.0);
465 std::vector<FlutterEngineDisplay> displays = {display};
466 embedder_api_.NotifyDisplayUpdate(engine_,
467 kFlutterEngineDisplaysUpdateTypeStartup,
468 displays.data(), displays.size());
473 settings_plugin_->StartWatching();
474 settings_plugin_->SendSettings();
479 bool FlutterWindowsEngine::Stop() {
481 for (
const auto& [
callback, registrar] :
482 plugin_registrar_destruction_callbacks_) {
485 FlutterEngineResult result = embedder_api_.Shutdown(engine_);
487 return (result == kSuccess);
492 std::unique_ptr<FlutterWindowsView> FlutterWindowsEngine::CreateView(
493 std::unique_ptr<WindowBindingHandler> window) {
496 auto view = std::make_unique<FlutterWindowsView>(
500 InitializeKeyboard();
502 return std::move(view);
505 void FlutterWindowsEngine::OnVsync(intptr_t baton) {
506 std::chrono::nanoseconds current_time =
507 std::chrono::nanoseconds(embedder_api_.GetCurrentTime());
508 std::chrono::nanoseconds frame_interval = FrameInterval();
509 auto next = SnapToNextTick(current_time, start_time_, frame_interval);
510 embedder_api_.OnVsync(engine_, baton, next.count(),
511 (next + frame_interval).count());
514 std::chrono::nanoseconds FlutterWindowsEngine::FrameInterval() {
515 if (frame_interval_override_.has_value()) {
516 return frame_interval_override_.value();
518 uint64_t interval = 16600000;
520 DWM_TIMING_INFO timing_info = {};
521 timing_info.cbSize =
sizeof(timing_info);
522 HRESULT result = DwmGetCompositionTimingInfo(NULL, &timing_info);
523 if (result == S_OK && timing_info.rateRefresh.uiDenominator > 0 &&
524 timing_info.rateRefresh.uiNumerator > 0) {
525 interval =
static_cast<double>(timing_info.rateRefresh.uiDenominator *
527 static_cast<double>(timing_info.rateRefresh.uiNumerator);
530 return std::chrono::nanoseconds(interval);
534 auto iterator = views_.find(view_id);
535 if (iterator == views_.end()) {
539 return iterator->second;
544 return plugin_registrar_.get();
547 void FlutterWindowsEngine::AddPluginRegistrarDestructionCallback(
550 plugin_registrar_destruction_callbacks_[
callback] = registrar;
553 void FlutterWindowsEngine::SendWindowMetricsEvent(
554 const FlutterWindowMetricsEvent& event) {
556 embedder_api_.SendWindowMetricsEvent(engine_, &event);
560 void FlutterWindowsEngine::SendPointerEvent(
const FlutterPointerEvent& event) {
562 embedder_api_.SendPointerEvent(engine_, &event, 1);
566 void FlutterWindowsEngine::SendKeyEvent(
const FlutterKeyEvent& event,
574 bool FlutterWindowsEngine::SendPlatformMessage(
577 const size_t message_size,
580 FlutterPlatformMessageResponseHandle* response_handle =
nullptr;
581 if (reply !=
nullptr &&
user_data !=
nullptr) {
582 FlutterEngineResult result =
583 embedder_api_.PlatformMessageCreateResponseHandle(
584 engine_, reply,
user_data, &response_handle);
585 if (result != kSuccess) {
586 FML_LOG(ERROR) <<
"Failed to create response handle";
591 FlutterPlatformMessage platform_message = {
592 sizeof(FlutterPlatformMessage),
599 FlutterEngineResult message_result =
600 embedder_api_.SendPlatformMessage(engine_, &platform_message);
601 if (response_handle !=
nullptr) {
602 embedder_api_.PlatformMessageReleaseResponseHandle(engine_,
605 return message_result == kSuccess;
608 void FlutterWindowsEngine::SendPlatformMessageResponse(
611 size_t data_length) {
612 embedder_api_.SendPlatformMessageResponse(engine_, handle, data, data_length);
615 void FlutterWindowsEngine::HandlePlatformMessage(
616 const FlutterPlatformMessage* engine_message) {
617 if (engine_message->struct_size !=
sizeof(FlutterPlatformMessage)) {
618 FML_LOG(ERROR) <<
"Invalid message size received. Expected: "
619 <<
sizeof(FlutterPlatformMessage) <<
" but received "
620 << engine_message->struct_size;
624 auto message = ConvertToDesktopMessage(*engine_message);
626 message_dispatcher_->HandleMessage(
message, [
this] {}, [
this] {});
629 void FlutterWindowsEngine::ReloadSystemFonts() {
630 embedder_api_.ReloadSystemFonts(engine_);
633 void FlutterWindowsEngine::ScheduleFrame() {
634 embedder_api_.ScheduleFrame(engine_);
637 void FlutterWindowsEngine::SetNextFrameCallback(fml::closure
callback) {
638 next_frame_callback_ = std::move(
callback);
640 embedder_api_.SetNextFrameCallback(
648 self->task_runner_->PostTask(std::move(self->next_frame_callback_));
654 if (lifecycle_manager_) {
655 lifecycle_manager_->SetLifecycleState(state);
659 void FlutterWindowsEngine::SendSystemLocales() {
660 std::vector<LanguageInfo> languages =
662 std::vector<FlutterLocale> flutter_locales;
663 flutter_locales.reserve(languages.size());
664 for (
const auto& info : languages) {
665 flutter_locales.push_back(CovertToFlutterLocale(info));
668 std::vector<const FlutterLocale*> flutter_locale_list;
669 flutter_locale_list.reserve(flutter_locales.size());
670 std::transform(flutter_locales.begin(), flutter_locales.end(),
671 std::back_inserter(flutter_locale_list),
672 [](
const auto& arg) ->
const auto* { return &arg; });
673 embedder_api_.UpdateLocales(engine_, flutter_locale_list.data(),
674 flutter_locale_list.size());
677 void FlutterWindowsEngine::InitializeKeyboard() {
678 if (views_.empty()) {
679 FML_LOG(ERROR) <<
"Cannot initialize keyboard on Windows headless mode.";
682 auto internal_plugin_messenger = internal_plugin_registrar_->messenger();
683 KeyboardKeyEmbedderHandler::GetKeyStateHandler get_key_state = GetKeyState;
684 KeyboardKeyEmbedderHandler::MapVirtualKeyToScanCode map_vk_to_scan =
685 [](UINT virtual_key,
bool extended) {
686 return MapVirtualKey(virtual_key,
687 extended ? MAPVK_VK_TO_VSC_EX : MAPVK_VK_TO_VSC);
689 keyboard_key_handler_ = std::move(CreateKeyboardKeyHandler(
690 internal_plugin_messenger, get_key_state, map_vk_to_scan));
692 std::move(CreateTextInputPlugin(internal_plugin_messenger));
695 std::unique_ptr<KeyboardHandlerBase>
696 FlutterWindowsEngine::CreateKeyboardKeyHandler(
700 auto keyboard_key_handler = std::make_unique<KeyboardKeyHandler>(messenger);
701 keyboard_key_handler->AddDelegate(
702 std::make_unique<KeyboardKeyEmbedderHandler>(
703 [
this](
const FlutterKeyEvent& event, FlutterKeyEventCallback
callback,
707 get_key_state, map_vk_to_scan));
708 keyboard_key_handler->AddDelegate(
709 std::make_unique<KeyboardKeyChannelHandler>(messenger));
710 keyboard_key_handler->InitKeyboardChannel();
711 return keyboard_key_handler;
714 std::unique_ptr<TextInputPlugin> FlutterWindowsEngine::CreateTextInputPlugin(
716 return std::make_unique<TextInputPlugin>(messenger,
this);
719 bool FlutterWindowsEngine::RegisterExternalTexture(int64_t
texture_id) {
720 return (embedder_api_.RegisterExternalTexture(engine_,
texture_id) ==
724 bool FlutterWindowsEngine::UnregisterExternalTexture(int64_t
texture_id) {
725 return (embedder_api_.UnregisterExternalTexture(engine_,
texture_id) ==
729 bool FlutterWindowsEngine::MarkExternalTextureFrameAvailable(
731 return (embedder_api_.MarkExternalTextureFrameAvailable(
735 bool FlutterWindowsEngine::PostRasterThreadTask(fml::closure
callback)
const {
739 auto captures =
new Captures();
740 captures->callback = std::move(
callback);
741 if (embedder_api_.PostRenderThreadTask(
744 auto captures = reinterpret_cast<Captures*>(opaque);
745 captures->callback();
748 captures) == kSuccess) {
755 bool FlutterWindowsEngine::DispatchSemanticsAction(
757 FlutterSemanticsAction
action,
758 fml::MallocMapping data) {
759 return (embedder_api_.DispatchSemanticsAction(engine_, target,
action,
761 data.GetSize()) == kSuccess);
764 void FlutterWindowsEngine::UpdateSemanticsEnabled(
bool enabled) {
765 if (engine_ && semantics_enabled_ != enabled) {
766 semantics_enabled_ = enabled;
767 embedder_api_.UpdateSemanticsEnabled(engine_, enabled);
768 for (
auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
769 iterator->second->UpdateSemanticsEnabled(enabled);
774 void FlutterWindowsEngine::OnPreEngineRestart() {
776 if (!views_.empty()) {
777 InitializeKeyboard();
781 std::string FlutterWindowsEngine::GetExecutableName()
const {
782 std::pair<bool, std::string> result = fml::paths::GetExecutablePath();
784 const std::string& executable_path = result.second;
785 size_t last_separator = executable_path.find_last_of(
"/\\");
786 if (last_separator == std::string::npos ||
787 last_separator == executable_path.size() - 1) {
788 return executable_path;
790 return executable_path.substr(last_separator + 1);
795 void FlutterWindowsEngine::UpdateAccessibilityFeatures() {
796 UpdateHighContrastMode();
799 void FlutterWindowsEngine::UpdateHighContrastMode() {
800 high_contrast_enabled_ = windows_proc_table_->GetHighContrastEnabled();
802 SendAccessibilityFeatures();
803 settings_plugin_->UpdateHighContrastMode(high_contrast_enabled_);
806 void FlutterWindowsEngine::SendAccessibilityFeatures() {
809 if (high_contrast_enabled_) {
811 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast;
814 embedder_api_.UpdateAccessibilityFeatures(
815 engine_,
static_cast<FlutterAccessibilityFeature
>(flags));
818 void FlutterWindowsEngine::RequestApplicationQuit(HWND hwnd,
822 platform_handler_->RequestAppExit(hwnd, wparam, lparam, exit_type, 0);
825 void FlutterWindowsEngine::OnQuit(std::optional<HWND> hwnd,
826 std::optional<WPARAM> wparam,
827 std::optional<LPARAM> lparam,
829 lifecycle_manager_->Quit(hwnd, wparam, lparam, exit_code);
832 void FlutterWindowsEngine::OnDwmCompositionChanged() {
833 for (
auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
834 iterator->second->OnDwmCompositionChanged();
838 void FlutterWindowsEngine::OnWindowStateEvent(HWND hwnd,
840 lifecycle_manager_->OnWindowStateEvent(hwnd, event);
843 std::optional<LRESULT> FlutterWindowsEngine::ProcessExternalWindowMessage(
848 if (lifecycle_manager_) {
849 return lifecycle_manager_->ExternalWindowMessage(hwnd,
message, wparam,
855 void FlutterWindowsEngine::OnChannelUpdate(std::string name,
bool listening) {
856 if (name ==
"flutter/platform" && listening) {
857 lifecycle_manager_->BeginProcessingExit();
858 }
else if (name ==
"flutter/lifecycle" && listening) {
859 lifecycle_manager_->BeginProcessingLifecycle();