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"
24 #include "flutter/third_party/accessibility/ax/ax_node.h"
36 static std::chrono::nanoseconds SnapToNextTick(
37 std::chrono::nanoseconds value,
38 std::chrono::nanoseconds tick_phase,
39 std::chrono::nanoseconds tick_interval) {
40 std::chrono::nanoseconds offset = (tick_phase - value) % tick_interval;
41 if (offset != std::chrono::nanoseconds::zero())
42 offset = offset + tick_interval;
43 return value + offset;
50 FlutterRendererConfig GetOpenGLRendererConfig() {
51 FlutterRendererConfig config = {};
52 config.type = kOpenGL;
53 config.open_gl.struct_size =
sizeof(config.open_gl);
54 config.open_gl.make_current = [](
void*
user_data) ->
bool {
55 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
56 if (!host->surface_manager()) {
59 return host->surface_manager()->MakeCurrent();
61 config.open_gl.clear_current = [](
void*
user_data) ->
bool {
62 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
63 if (!host->surface_manager()) {
66 return host->surface_manager()->ClearContext();
68 config.open_gl.present = [](
void*
user_data) ->
bool {
69 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
73 return host->view()->SwapBuffers();
75 config.open_gl.fbo_reset_after_present =
true;
76 config.open_gl.fbo_with_frame_info_callback =
77 [](
void*
user_data,
const FlutterFrameInfo* info) -> uint32_t {
78 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
80 return host->view()->GetFrameBufferId(info->size.width,
86 config.open_gl.gl_proc_resolver = [](
void*
user_data,
87 const char* what) ->
void* {
88 return reinterpret_cast<void*
>(eglGetProcAddress(what));
90 config.open_gl.make_resource_current = [](
void*
user_data) ->
bool {
91 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
92 if (!host->surface_manager()) {
95 return host->surface_manager()->MakeResourceCurrent();
97 config.open_gl.gl_external_texture_frame_callback =
99 FlutterOpenGLTexture* texture) ->
bool {
100 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
101 if (!host->texture_registrar()) {
104 return host->texture_registrar()->PopulateTexture(
texture_id, width, height,
114 FlutterRendererConfig GetSoftwareRendererConfig() {
115 FlutterRendererConfig config = {};
116 config.type = kSoftware;
117 config.software.struct_size =
sizeof(config.software);
118 config.software.surface_present_callback = [](
void*
user_data,
119 const void* allocation,
122 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
126 return host->view()->PresentSoftwareBitmap(allocation, row_bytes, height);
133 const FlutterPlatformMessage& engine_message) {
136 message.channel = engine_message.channel;
137 message.message = engine_message.message;
138 message.message_size = engine_message.message_size;
139 message.response_handle = engine_message.response_handle;
145 FlutterLocale CovertToFlutterLocale(
const LanguageInfo& info) {
146 FlutterLocale locale = {};
147 locale.struct_size =
sizeof(FlutterLocale);
148 locale.language_code = info.language.c_str();
149 if (!info.region.empty()) {
150 locale.country_code = info.region.c_str();
152 if (!info.script.empty()) {
153 locale.script_code = info.script.c_str();
162 std::shared_ptr<WindowsProcTable> windows_proc_table)
164 windows_proc_table_(std::move(windows_proc_table)),
165 aot_data_(nullptr, nullptr),
167 if (windows_proc_table_ ==
nullptr) {
168 windows_proc_table_ = std::make_shared<WindowsProcTable>();
173 embedder_api_.struct_size =
sizeof(FlutterEngineProcTable);
174 FlutterEngineGetProcAddresses(&embedder_api_);
177 std::make_unique<TaskRunner>(
178 embedder_api_.GetCurrentTime, [
this](
const auto* task) {
181 <<
"Cannot post an engine task when engine is not running.";
184 if (embedder_api_.RunTask(engine_, task) != kSuccess) {
185 FML_LOG(ERROR) <<
"Failed to post an engine task.";
192 messenger_->SetEngine(
this);
193 plugin_registrar_ = std::make_unique<FlutterDesktopPluginRegistrar>();
194 plugin_registrar_->engine =
this;
197 std::make_unique<BinaryMessengerImpl>(messenger_->ToRef());
198 message_dispatcher_ =
199 std::make_unique<IncomingMessageDispatcher>(messenger_->ToRef());
200 message_dispatcher_->SetMessageCallback(
205 engine->HandleAccessibilityMessage(messenger,
message);
207 static_cast<void*
>(
this));
210 std::make_unique<FlutterWindowsTextureRegistrar>(
this, gl_);
213 auto& switches = project_->GetSwitches();
214 enable_impeller_ = std::find(switches.begin(), switches.end(),
215 "--enable-impeller=true") != switches.end();
218 window_proc_delegate_manager_ = std::make_unique<WindowProcDelegateManager>();
219 window_proc_delegate_manager_->RegisterTopLevelWindowProcDelegate(
220 [](HWND hwnd, UINT msg, WPARAM wpar, LPARAM lpar,
void*
user_data,
223 FlutterWindowsEngine* that =
224 static_cast<FlutterWindowsEngine*
>(
user_data);
225 BASE_DCHECK(that->lifecycle_manager_);
226 return that->lifecycle_manager_->WindowProc(hwnd, msg, wpar, lpar,
229 static_cast<void*
>(
this));
234 internal_plugin_registrar_ =
235 std::make_unique<PluginRegistrar>(plugin_registrar_.get());
237 std::make_unique<CursorHandler>(messenger_wrapper_.get(),
this);
239 std::make_unique<PlatformHandler>(messenger_wrapper_.get(),
this);
240 settings_plugin_ = std::make_unique<SettingsPlugin>(messenger_wrapper_.get(),
244 FlutterWindowsEngine::~FlutterWindowsEngine() {
245 messenger_->SetEngine(
nullptr);
249 void FlutterWindowsEngine::SetSwitches(
250 const std::vector<std::string>& switches) {
251 project_->SetSwitches(switches);
254 bool FlutterWindowsEngine::Run() {
258 bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
259 if (!project_->HasValidPaths()) {
260 FML_LOG(ERROR) <<
"Missing or unresolvable paths to assets.";
263 std::string assets_path_string = project_->assets_path().u8string();
264 std::string icu_path_string = project_->icu_path().u8string();
265 if (embedder_api_.RunsAOTCompiledDartCode()) {
266 aot_data_ = project_->LoadAotData(embedder_api_);
268 FML_LOG(ERROR) <<
"Unable to start engine without AOT data.";
276 std::string executable_name = GetExecutableName();
277 std::vector<const char*> argv = {executable_name.c_str()};
278 std::vector<std::string> switches = project_->GetSwitches();
280 switches.begin(), switches.end(), std::back_inserter(argv),
281 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
283 const std::vector<std::string>& entrypoint_args =
284 project_->dart_entrypoint_arguments();
285 std::vector<const char*> entrypoint_argv;
287 entrypoint_args.begin(), entrypoint_args.end(),
288 std::back_inserter(entrypoint_argv),
289 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
292 FlutterTaskRunnerDescription platform_task_runner = {};
293 platform_task_runner.struct_size =
sizeof(FlutterTaskRunnerDescription);
294 platform_task_runner.user_data = task_runner_.get();
295 platform_task_runner.runs_task_on_current_thread_callback =
299 platform_task_runner.post_task_callback = [](FlutterTask task,
300 uint64_t target_time_nanos,
305 FlutterCustomTaskRunners custom_task_runners = {};
306 custom_task_runners.struct_size =
sizeof(FlutterCustomTaskRunners);
307 custom_task_runners.platform_task_runner = &platform_task_runner;
308 custom_task_runners.thread_priority_setter =
311 FlutterProjectArgs args = {};
312 args.struct_size =
sizeof(FlutterProjectArgs);
313 args.shutdown_dart_vm_when_done =
true;
314 args.assets_path = assets_path_string.c_str();
315 args.icu_data_path = icu_path_string.c_str();
316 args.command_line_argc =
static_cast<int>(argv.size());
317 args.command_line_argv = argv.empty() ? nullptr : argv.data();
325 if (!project_->dart_entrypoint().empty() && !entrypoint.empty() &&
326 project_->dart_entrypoint() != entrypoint) {
327 FML_LOG(ERROR) <<
"Conflicting entrypoints were specified in "
328 "FlutterDesktopEngineProperties.dart_entrypoint and "
329 "FlutterDesktopEngineRun(engine, entry_point). ";
332 if (!entrypoint.empty()) {
333 args.custom_dart_entrypoint = entrypoint.data();
334 }
else if (!project_->dart_entrypoint().empty()) {
335 args.custom_dart_entrypoint = project_->dart_entrypoint().c_str();
337 args.dart_entrypoint_argc =
static_cast<int>(entrypoint_argv.size());
338 args.dart_entrypoint_argv =
339 entrypoint_argv.empty() ? nullptr : entrypoint_argv.data();
340 args.platform_message_callback =
341 [](
const FlutterPlatformMessage* engine_message,
346 args.vsync_callback = [](
void*
user_data, intptr_t baton) ->
void {
350 args.on_pre_engine_restart_callback = [](
void*
user_data) {
354 args.update_semantics_callback2 = [](
const FlutterSemanticsUpdate2* update,
357 auto view = host->
view();
363 if (!accessibility_bridge) {
367 for (
size_t i = 0; i < update->node_count; i++) {
368 const FlutterSemanticsNode2* node = update->nodes[i];
369 accessibility_bridge->AddFlutterSemanticsNodeUpdate(*node);
372 for (
size_t i = 0; i < update->custom_action_count; i++) {
373 const FlutterSemanticsCustomAction2*
action = update->custom_actions[i];
374 accessibility_bridge->AddFlutterSemanticsCustomActionUpdate(*
action);
377 accessibility_bridge->CommitUpdates();
379 args.root_isolate_create_callback = [](
void*
user_data) {
381 if (host->root_isolate_create_callback_) {
382 host->root_isolate_create_callback_();
385 args.channel_update_callback = [](
const FlutterChannelUpdate* update,
388 if (SAFE_ACCESS(update, channel,
nullptr) !=
nullptr) {
389 std::string channel_name(update->channel);
390 host->OnChannelUpdate(std::move(channel_name),
391 SAFE_ACCESS(update, listening,
false));
395 args.custom_task_runners = &custom_task_runners;
398 args.aot_data = aot_data_.get();
403 FML_DCHECK(!surface_manager_ || !surface_manager_->HasContextCurrent());
405 FlutterRendererConfig renderer_config;
407 if (enable_impeller_) {
410 if (!surface_manager_) {
411 FML_LOG(ERROR) <<
"Could not create surface manager. Impeller backend "
412 "does not support software rendering.";
415 renderer_config = GetOpenGLRendererConfig();
417 renderer_config = surface_manager_ ? GetOpenGLRendererConfig()
418 : GetSoftwareRendererConfig();
421 auto result = embedder_api_.Run(FLUTTER_ENGINE_VERSION, &renderer_config,
422 &args,
this, &engine_);
423 if (result != kSuccess || engine_ ==
nullptr) {
424 FML_LOG(ERROR) <<
"Failed to start Flutter engine: error " << result;
429 FlutterEngineDisplay display = {};
430 display.struct_size =
sizeof(FlutterEngineDisplay);
431 display.display_id = 0;
432 display.single_display =
true;
433 display.refresh_rate =
434 1.0 / (
static_cast<double>(FrameInterval().count()) / 1000000000.0);
436 std::vector<FlutterEngineDisplay> displays = {display};
437 embedder_api_.NotifyDisplayUpdate(engine_,
438 kFlutterEngineDisplaysUpdateTypeStartup,
439 displays.data(), displays.size());
444 settings_plugin_->StartWatching();
445 settings_plugin_->SendSettings();
450 bool FlutterWindowsEngine::Stop() {
452 for (
const auto& [
callback, registrar] :
453 plugin_registrar_destruction_callbacks_) {
456 FlutterEngineResult result = embedder_api_.Shutdown(engine_);
458 return (result == kSuccess);
465 InitializeKeyboard();
468 void FlutterWindowsEngine::OnVsync(intptr_t baton) {
469 std::chrono::nanoseconds current_time =
470 std::chrono::nanoseconds(embedder_api_.GetCurrentTime());
471 std::chrono::nanoseconds frame_interval = FrameInterval();
472 auto next = SnapToNextTick(current_time, start_time_, frame_interval);
473 embedder_api_.OnVsync(engine_, baton, next.count(),
474 (next + frame_interval).count());
477 std::chrono::nanoseconds FlutterWindowsEngine::FrameInterval() {
478 if (frame_interval_override_.has_value()) {
479 return frame_interval_override_.value();
481 uint64_t interval = 16600000;
483 DWM_TIMING_INFO timing_info = {};
484 timing_info.cbSize =
sizeof(timing_info);
485 HRESULT result = DwmGetCompositionTimingInfo(NULL, &timing_info);
486 if (result == S_OK && timing_info.rateRefresh.uiDenominator > 0 &&
487 timing_info.rateRefresh.uiNumerator > 0) {
488 interval =
static_cast<double>(timing_info.rateRefresh.uiDenominator *
490 static_cast<double>(timing_info.rateRefresh.uiNumerator);
493 return std::chrono::nanoseconds(interval);
498 return plugin_registrar_.get();
501 void FlutterWindowsEngine::AddPluginRegistrarDestructionCallback(
504 plugin_registrar_destruction_callbacks_[
callback] = registrar;
507 void FlutterWindowsEngine::SendWindowMetricsEvent(
508 const FlutterWindowMetricsEvent& event) {
510 embedder_api_.SendWindowMetricsEvent(engine_, &event);
514 void FlutterWindowsEngine::SendPointerEvent(
const FlutterPointerEvent& event) {
516 embedder_api_.SendPointerEvent(engine_, &event, 1);
520 void FlutterWindowsEngine::SendKeyEvent(
const FlutterKeyEvent& event,
528 bool FlutterWindowsEngine::SendPlatformMessage(
531 const size_t message_size,
534 FlutterPlatformMessageResponseHandle* response_handle =
nullptr;
535 if (reply !=
nullptr &&
user_data !=
nullptr) {
536 FlutterEngineResult result =
537 embedder_api_.PlatformMessageCreateResponseHandle(
538 engine_, reply,
user_data, &response_handle);
539 if (result != kSuccess) {
540 FML_LOG(ERROR) <<
"Failed to create response handle";
545 FlutterPlatformMessage platform_message = {
546 sizeof(FlutterPlatformMessage),
553 FlutterEngineResult message_result =
554 embedder_api_.SendPlatformMessage(engine_, &platform_message);
555 if (response_handle !=
nullptr) {
556 embedder_api_.PlatformMessageReleaseResponseHandle(engine_,
559 return message_result == kSuccess;
562 void FlutterWindowsEngine::SendPlatformMessageResponse(
565 size_t data_length) {
566 embedder_api_.SendPlatformMessageResponse(engine_, handle, data, data_length);
569 void FlutterWindowsEngine::HandlePlatformMessage(
570 const FlutterPlatformMessage* engine_message) {
571 if (engine_message->struct_size !=
sizeof(FlutterPlatformMessage)) {
572 FML_LOG(ERROR) <<
"Invalid message size received. Expected: "
573 <<
sizeof(FlutterPlatformMessage) <<
" but received "
574 << engine_message->struct_size;
578 auto message = ConvertToDesktopMessage(*engine_message);
580 message_dispatcher_->HandleMessage(
message, [
this] {}, [
this] {});
583 void FlutterWindowsEngine::ReloadSystemFonts() {
584 embedder_api_.ReloadSystemFonts(engine_);
587 void FlutterWindowsEngine::ScheduleFrame() {
588 embedder_api_.ScheduleFrame(engine_);
591 void FlutterWindowsEngine::SetNextFrameCallback(fml::closure
callback) {
592 next_frame_callback_ = std::move(
callback);
594 embedder_api_.SetNextFrameCallback(
602 self->task_runner_->PostTask(std::move(self->next_frame_callback_));
608 if (lifecycle_manager_) {
609 lifecycle_manager_->SetLifecycleState(state);
613 void FlutterWindowsEngine::SendSystemLocales() {
614 std::vector<LanguageInfo> languages =
616 std::vector<FlutterLocale> flutter_locales;
617 flutter_locales.reserve(languages.size());
618 for (
const auto& info : languages) {
619 flutter_locales.push_back(CovertToFlutterLocale(info));
622 std::vector<const FlutterLocale*> flutter_locale_list;
623 flutter_locale_list.reserve(flutter_locales.size());
624 std::transform(flutter_locales.begin(), flutter_locales.end(),
625 std::back_inserter(flutter_locale_list),
626 [](
const auto& arg) ->
const auto* { return &arg; });
627 embedder_api_.UpdateLocales(engine_, flutter_locale_list.data(),
628 flutter_locale_list.size());
631 void FlutterWindowsEngine::InitializeKeyboard() {
632 if (view_ ==
nullptr) {
633 FML_LOG(ERROR) <<
"Cannot initialize keyboard on Windows headless mode.";
636 auto internal_plugin_messenger = internal_plugin_registrar_->messenger();
637 KeyboardKeyEmbedderHandler::GetKeyStateHandler get_key_state = GetKeyState;
638 KeyboardKeyEmbedderHandler::MapVirtualKeyToScanCode map_vk_to_scan =
639 [](UINT virtual_key,
bool extended) {
640 return MapVirtualKey(virtual_key,
641 extended ? MAPVK_VK_TO_VSC_EX : MAPVK_VK_TO_VSC);
643 keyboard_key_handler_ = std::move(CreateKeyboardKeyHandler(
644 internal_plugin_messenger, get_key_state, map_vk_to_scan));
646 std::move(CreateTextInputPlugin(internal_plugin_messenger));
649 std::unique_ptr<KeyboardHandlerBase>
650 FlutterWindowsEngine::CreateKeyboardKeyHandler(
654 auto keyboard_key_handler = std::make_unique<KeyboardKeyHandler>(messenger);
655 keyboard_key_handler->AddDelegate(
656 std::make_unique<KeyboardKeyEmbedderHandler>(
657 [
this](
const FlutterKeyEvent& event, FlutterKeyEventCallback
callback,
661 get_key_state, map_vk_to_scan));
662 keyboard_key_handler->AddDelegate(
663 std::make_unique<KeyboardKeyChannelHandler>(messenger));
664 keyboard_key_handler->InitKeyboardChannel();
665 return keyboard_key_handler;
668 std::unique_ptr<TextInputPlugin> FlutterWindowsEngine::CreateTextInputPlugin(
670 return std::make_unique<TextInputPlugin>(messenger,
this);
673 bool FlutterWindowsEngine::RegisterExternalTexture(int64_t
texture_id) {
674 return (embedder_api_.RegisterExternalTexture(engine_,
texture_id) ==
678 bool FlutterWindowsEngine::UnregisterExternalTexture(int64_t
texture_id) {
679 return (embedder_api_.UnregisterExternalTexture(engine_,
texture_id) ==
683 bool FlutterWindowsEngine::MarkExternalTextureFrameAvailable(
685 return (embedder_api_.MarkExternalTextureFrameAvailable(
689 bool FlutterWindowsEngine::PostRasterThreadTask(fml::closure
callback)
const {
693 auto captures =
new Captures();
694 captures->callback = std::move(
callback);
695 if (embedder_api_.PostRenderThreadTask(
698 auto captures = reinterpret_cast<Captures*>(opaque);
699 captures->callback();
702 captures) == kSuccess) {
709 bool FlutterWindowsEngine::DispatchSemanticsAction(
711 FlutterSemanticsAction
action,
712 fml::MallocMapping data) {
713 return (embedder_api_.DispatchSemanticsAction(engine_, target,
action,
715 data.GetSize()) == kSuccess);
718 void FlutterWindowsEngine::UpdateSemanticsEnabled(
bool enabled) {
719 if (engine_ && semantics_enabled_ != enabled) {
720 semantics_enabled_ = enabled;
721 embedder_api_.UpdateSemanticsEnabled(engine_, enabled);
722 view_->UpdateSemanticsEnabled(enabled);
726 void FlutterWindowsEngine::OnPreEngineRestart() {
729 InitializeKeyboard();
733 std::string FlutterWindowsEngine::GetExecutableName()
const {
734 std::pair<bool, std::string> result = fml::paths::GetExecutablePath();
736 const std::string& executable_path = result.second;
737 size_t last_separator = executable_path.find_last_of(
"/\\");
738 if (last_separator == std::string::npos ||
739 last_separator == executable_path.size() - 1) {
740 return executable_path;
742 return executable_path.substr(last_separator + 1);
747 void FlutterWindowsEngine::UpdateAccessibilityFeatures() {
748 UpdateHighContrastMode();
751 void FlutterWindowsEngine::UpdateHighContrastMode() {
752 high_contrast_enabled_ = windows_proc_table_->GetHighContrastEnabled();
754 SendAccessibilityFeatures();
755 settings_plugin_->UpdateHighContrastMode(high_contrast_enabled_);
758 void FlutterWindowsEngine::SendAccessibilityFeatures() {
761 if (high_contrast_enabled_) {
763 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast;
766 embedder_api_.UpdateAccessibilityFeatures(
767 engine_,
static_cast<FlutterAccessibilityFeature
>(flags));
770 void FlutterWindowsEngine::HandleAccessibilityMessage(
773 const auto& codec = StandardMessageCodec::GetInstance();
774 auto data = codec.DecodeMessage(
message->message,
message->message_size);
776 std::string
type = std::get<std::string>(map.at(EncodableValue(
"type")));
777 if (
type.compare(
"announce") == 0) {
778 if (semantics_enabled_) {
780 std::get<EncodableMap>(map.at(EncodableValue(
"data")));
782 std::get<std::string>(data_map.at(EncodableValue(
"message")));
783 std::wstring wide_text = fml::Utf8ToWideString(
text);
784 view_->AnnounceAlert(wide_text);
787 SendPlatformMessageResponse(
message->response_handle,
788 reinterpret_cast<const uint8_t*
>(
""), 0);
791 void FlutterWindowsEngine::RequestApplicationQuit(HWND hwnd,
795 platform_handler_->RequestAppExit(hwnd, wparam, lparam, exit_type, 0);
798 void FlutterWindowsEngine::OnQuit(std::optional<HWND> hwnd,
799 std::optional<WPARAM> wparam,
800 std::optional<LPARAM> lparam,
802 lifecycle_manager_->Quit(hwnd, wparam, lparam, exit_code);
805 void FlutterWindowsEngine::OnDwmCompositionChanged() {
806 view_->OnDwmCompositionChanged();
809 void FlutterWindowsEngine::OnWindowStateEvent(HWND hwnd,
811 lifecycle_manager_->OnWindowStateEvent(hwnd, event);
814 std::optional<LRESULT> FlutterWindowsEngine::ProcessExternalWindowMessage(
819 if (lifecycle_manager_) {
820 return lifecycle_manager_->ExternalWindowMessage(hwnd,
message, wparam,
826 void FlutterWindowsEngine::OnChannelUpdate(std::string name,
bool listening) {
827 if (name ==
"flutter/platform" && listening) {
828 lifecycle_manager_->BeginProcessingExit();
829 }
else if (name ==
"flutter/lifecycle" && listening) {
830 lifecycle_manager_->BeginProcessingLifecycle();