10 #include <shared_mutex>
13 #include "flutter/fml/logging.h"
14 #include "flutter/fml/paths.h"
15 #include "flutter/fml/platform/win/wstring_conversion.h"
16 #include "flutter/fml/synchronization/waitable_event.h"
20 #include "flutter/shell/platform/embedder/embedder_struct_macros.h"
29 #include "flutter/third_party/accessibility/ax/ax_node.h"
42 static std::chrono::nanoseconds SnapToNextTick(
43 std::chrono::nanoseconds value,
44 std::chrono::nanoseconds tick_phase,
45 std::chrono::nanoseconds tick_interval) {
46 std::chrono::nanoseconds offset = (tick_phase - value) % tick_interval;
47 if (offset != std::chrono::nanoseconds::zero())
48 offset = offset + tick_interval;
49 return value + offset;
56 FlutterRendererConfig GetOpenGLRendererConfig() {
57 FlutterRendererConfig config = {};
58 config.type = kOpenGL;
59 config.open_gl.struct_size =
sizeof(config.open_gl);
60 config.open_gl.make_current = [](
void*
user_data) ->
bool {
61 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
62 if (!host->egl_manager()) {
65 return host->egl_manager()->render_context()->MakeCurrent();
67 config.open_gl.clear_current = [](
void*
user_data) ->
bool {
68 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
69 if (!host->egl_manager()) {
72 return host->egl_manager()->render_context()->ClearCurrent();
74 config.open_gl.present = [](
void*
user_data) ->
bool { FML_UNREACHABLE(); };
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 {
80 config.open_gl.gl_proc_resolver = [](
void*
user_data,
81 const char* what) ->
void* {
82 return reinterpret_cast<void*
>(eglGetProcAddress(what));
84 config.open_gl.make_resource_current = [](
void*
user_data) ->
bool {
85 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
86 if (!host->egl_manager()) {
89 return host->egl_manager()->resource_context()->MakeCurrent();
91 config.open_gl.gl_external_texture_frame_callback =
93 FlutterOpenGLTexture* texture) ->
bool {
94 auto host =
static_cast<FlutterWindowsEngine*
>(
user_data);
95 if (!host->texture_registrar()) {
98 return host->texture_registrar()->PopulateTexture(
texture_id, width, height,
108 FlutterRendererConfig GetSoftwareRendererConfig() {
109 FlutterRendererConfig config = {};
110 config.type = kSoftware;
111 config.software.struct_size =
sizeof(config.software);
112 config.software.surface_present_callback =
113 [](
void*
user_data,
const void* allocation,
size_t row_bytes,
123 const FlutterPlatformMessage& engine_message) {
126 message.channel = engine_message.channel;
127 message.message = engine_message.message;
128 message.message_size = engine_message.message_size;
129 message.response_handle = engine_message.response_handle;
135 FlutterLocale CovertToFlutterLocale(
const LanguageInfo& info) {
136 FlutterLocale locale = {};
137 locale.struct_size =
sizeof(FlutterLocale);
138 locale.language_code = info.language.c_str();
139 if (!info.region.empty()) {
140 locale.country_code = info.region.c_str();
142 if (!info.script.empty()) {
143 locale.script_code = info.script.c_str();
152 std::shared_ptr<WindowsProcTable> windows_proc_table)
154 windows_proc_table_(std::move(windows_proc_table)),
155 aot_data_(nullptr, nullptr),
157 if (windows_proc_table_ ==
nullptr) {
158 windows_proc_table_ = std::make_shared<WindowsProcTable>();
163 embedder_api_.struct_size =
sizeof(FlutterEngineProcTable);
164 FlutterEngineGetProcAddresses(&embedder_api_);
167 std::make_unique<TaskRunner>(
168 embedder_api_.GetCurrentTime, [
this](
const auto* task) {
171 <<
"Cannot post an engine task when engine is not running.";
174 if (embedder_api_.RunTask(engine_, task) != kSuccess) {
175 FML_LOG(ERROR) <<
"Failed to post an engine task.";
182 messenger_->SetEngine(
this);
183 plugin_registrar_ = std::make_unique<FlutterDesktopPluginRegistrar>();
184 plugin_registrar_->engine =
this;
187 std::make_unique<BinaryMessengerImpl>(messenger_->ToRef());
188 message_dispatcher_ =
189 std::make_unique<IncomingMessageDispatcher>(messenger_->ToRef());
192 std::make_unique<FlutterWindowsTextureRegistrar>(
this, gl_);
195 auto& switches = project_->GetSwitches();
196 enable_impeller_ = std::find(switches.begin(), switches.end(),
197 "--enable-impeller=true") != switches.end();
201 window_proc_delegate_manager_ = std::make_unique<WindowProcDelegateManager>();
202 window_proc_delegate_manager_->RegisterTopLevelWindowProcDelegate(
203 [](HWND hwnd, UINT msg, WPARAM wpar, LPARAM lpar,
void*
user_data,
208 BASE_DCHECK(that->lifecycle_manager_);
210 that->lifecycle_manager_->WindowProc(hwnd, msg, wpar, lpar, result);
214 auto message_result =
215 that->window_manager_->HandleMessage(hwnd, msg, wpar, lpar);
216 if (message_result) {
217 *result = *message_result;
222 static_cast<void*
>(
this));
227 internal_plugin_registrar_ =
228 std::make_unique<PluginRegistrar>(plugin_registrar_.get());
230 accessibility_plugin_ = std::make_unique<AccessibilityPlugin>(
this);
232 accessibility_plugin_.get());
235 std::make_unique<CursorHandler>(messenger_wrapper_.get(),
this);
237 std::make_unique<PlatformHandler>(messenger_wrapper_.get(),
this);
238 window_manager_ = std::make_unique<WindowManager>(
this);
239 settings_plugin_ = std::make_unique<SettingsPlugin>(messenger_wrapper_.get(),
243 FlutterWindowsEngine::~FlutterWindowsEngine() {
244 messenger_->SetEngine(
nullptr);
252 void FlutterWindowsEngine::SetSwitches(
253 const std::vector<std::string>& switches) {
257 bool FlutterWindowsEngine::Run() {
261 bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
262 if (!project_->HasValidPaths()) {
263 FML_LOG(ERROR) <<
"Missing or unresolvable paths to assets.";
266 std::string assets_path_string = project_->assets_path().u8string();
267 std::string icu_path_string = project_->icu_path().u8string();
268 if (embedder_api_.RunsAOTCompiledDartCode()) {
269 aot_data_ = project_->LoadAotData(embedder_api_);
271 FML_LOG(ERROR) <<
"Unable to start engine without AOT data.";
279 std::string executable_name = GetExecutableName();
280 std::vector<const char*> argv = {executable_name.c_str()};
281 std::vector<std::string> switches = project_->GetSwitches();
283 switches.begin(), switches.end(), std::back_inserter(argv),
284 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
286 const std::vector<std::string>& entrypoint_args =
287 project_->dart_entrypoint_arguments();
288 std::vector<const char*> entrypoint_argv;
290 entrypoint_args.begin(), entrypoint_args.end(),
291 std::back_inserter(entrypoint_argv),
292 [](
const std::string& arg) ->
const char* { return arg.c_str(); });
295 FlutterTaskRunnerDescription platform_task_runner = {};
296 platform_task_runner.struct_size =
sizeof(FlutterTaskRunnerDescription);
297 platform_task_runner.user_data = task_runner_.get();
298 platform_task_runner.runs_task_on_current_thread_callback =
302 platform_task_runner.post_task_callback = [](FlutterTask task,
303 uint64_t target_time_nanos,
308 FlutterCustomTaskRunners custom_task_runners = {};
309 custom_task_runners.struct_size =
sizeof(FlutterCustomTaskRunners);
310 custom_task_runners.platform_task_runner = &platform_task_runner;
311 custom_task_runners.thread_priority_setter =
314 if (project_->ui_thread_policy() !=
316 custom_task_runners.ui_task_runner = &platform_task_runner;
318 FML_LOG(WARNING) <<
"Running with unmerged platform and UI threads. This "
319 "will be removed in future.";
322 FlutterProjectArgs args = {};
323 args.struct_size =
sizeof(FlutterProjectArgs);
324 args.shutdown_dart_vm_when_done =
true;
325 args.assets_path = assets_path_string.c_str();
326 args.icu_data_path = icu_path_string.c_str();
327 args.command_line_argc =
static_cast<int>(argv.size());
328 args.command_line_argv = argv.empty() ? nullptr : argv.data();
329 args.engine_id =
reinterpret_cast<int64_t
>(
this);
337 if (!project_->dart_entrypoint().empty() && !entrypoint.empty() &&
338 project_->dart_entrypoint() != entrypoint) {
339 FML_LOG(ERROR) <<
"Conflicting entrypoints were specified in "
340 "FlutterDesktopEngineProperties.dart_entrypoint and "
341 "FlutterDesktopEngineRun(engine, entry_point). ";
344 if (!entrypoint.empty()) {
345 args.custom_dart_entrypoint = entrypoint.data();
346 }
else if (!project_->dart_entrypoint().empty()) {
347 args.custom_dart_entrypoint = project_->dart_entrypoint().c_str();
349 args.dart_entrypoint_argc =
static_cast<int>(entrypoint_argv.size());
350 args.dart_entrypoint_argv =
351 entrypoint_argv.empty() ? nullptr : entrypoint_argv.data();
352 args.platform_message_callback =
353 [](
const FlutterPlatformMessage* engine_message,
358 args.vsync_callback = [](
void*
user_data, intptr_t baton) ->
void {
362 args.on_pre_engine_restart_callback = [](
void*
user_data) {
366 args.update_semantics_callback2 = [](
const FlutterSemanticsUpdate2* update,
370 auto view = host->
view(update->view_id);
376 if (!accessibility_bridge) {
380 for (
size_t i = 0; i < update->node_count; i++) {
381 const FlutterSemanticsNode2* node = update->nodes[i];
382 accessibility_bridge->AddFlutterSemanticsNodeUpdate(*node);
385 for (
size_t i = 0; i < update->custom_action_count; i++) {
386 const FlutterSemanticsCustomAction2*
action = update->custom_actions[i];
387 accessibility_bridge->AddFlutterSemanticsCustomActionUpdate(*
action);
390 accessibility_bridge->CommitUpdates();
392 args.root_isolate_create_callback = [](
void*
user_data) {
394 if (host->root_isolate_create_callback_) {
395 host->root_isolate_create_callback_();
398 args.channel_update_callback = [](
const FlutterChannelUpdate* update,
401 if (SAFE_ACCESS(update, channel,
nullptr) !=
nullptr) {
402 std::string channel_name(update->channel);
403 host->OnChannelUpdate(std::move(channel_name),
404 SAFE_ACCESS(update, listening,
false));
407 args.view_focus_change_request_callback =
408 [](
const FlutterViewFocusChangeRequest* request,
void*
user_data) {
413 args.custom_task_runners = &custom_task_runners;
415 if (!platform_view_plugin_) {
416 platform_view_plugin_ = std::make_unique<PlatformViewPlugin>(
417 messenger_wrapper_.get(), task_runner_.get());
420 auto resolver = [](
const char* name) ->
void* {
421 return reinterpret_cast<void*
>(::eglGetProcAddress(name));
427 std::make_unique<CompositorOpenGL>(
this, resolver, enable_impeller_);
429 compositor_ = std::make_unique<CompositorSoftware>();
432 FlutterCompositor compositor = {};
433 compositor.struct_size =
sizeof(FlutterCompositor);
434 compositor.user_data =
this;
435 compositor.create_backing_store_callback =
436 [](
const FlutterBackingStoreConfig* config,
437 FlutterBackingStore* backing_store_out,
void*
user_data) ->
bool {
440 return host->compositor_->CreateBackingStore(*config, backing_store_out);
443 compositor.collect_backing_store_callback =
444 [](
const FlutterBackingStore* backing_store,
void*
user_data) ->
bool {
447 return host->compositor_->CollectBackingStore(backing_store);
450 compositor.present_view_callback =
451 [](
const FlutterPresentViewInfo* info) ->
bool {
454 return host->Present(info);
456 args.compositor = &compositor;
459 args.aot_data = aot_data_.get();
464 FML_DCHECK(!egl_manager_ || !egl_manager_->HasContextCurrent());
466 FlutterRendererConfig renderer_config;
468 if (enable_impeller_) {
472 FML_LOG(ERROR) <<
"Could not create surface manager. Impeller backend "
473 "does not support software rendering.";
476 renderer_config = GetOpenGLRendererConfig();
479 egl_manager_ ? GetOpenGLRendererConfig() : GetSoftwareRendererConfig();
482 auto result = embedder_api_.Run(FLUTTER_ENGINE_VERSION, &renderer_config,
483 &args,
this, &engine_);
484 if (result != kSuccess || engine_ ==
nullptr) {
485 FML_LOG(ERROR) <<
"Failed to start Flutter engine: error " << result;
490 FlutterEngineDisplay display = {};
491 display.struct_size =
sizeof(FlutterEngineDisplay);
492 display.display_id = 0;
493 display.single_display =
true;
494 display.refresh_rate =
495 1.0 / (
static_cast<double>(FrameInterval().count()) / 1000000000.0);
497 std::vector<FlutterEngineDisplay> displays = {display};
498 embedder_api_.NotifyDisplayUpdate(engine_,
499 kFlutterEngineDisplaysUpdateTypeStartup,
500 displays.data(), displays.size());
504 settings_plugin_->StartWatching();
505 settings_plugin_->SendSettings();
507 InitializeKeyboard();
512 bool FlutterWindowsEngine::Stop() {
514 window_manager_->OnEngineShutdown();
515 for (
const auto& [
callback, registrar] :
516 plugin_registrar_destruction_callbacks_) {
519 FlutterEngineResult result = embedder_api_.Shutdown(engine_);
521 return (result == kSuccess);
526 std::unique_ptr<FlutterWindowsView> FlutterWindowsEngine::CreateView(
527 std::unique_ptr<WindowBindingHandler> window) {
528 auto view_id = next_view_id_;
529 auto view = std::make_unique<FlutterWindowsView>(
530 view_id,
this, std::move(window), windows_proc_table_);
532 view->CreateRenderSurface();
533 view->UpdateSemanticsEnabled(semantics_enabled_);
540 std::unique_lock write_lock(views_mutex_);
541 FML_DCHECK(views_.find(view_id) == views_.end());
542 views_[view_id] = view.get();
545 if (!view->IsImplicitView()) {
546 FML_DCHECK(running());
549 fml::AutoResetWaitableEvent latch;
552 Captures captures = {};
554 FlutterWindowMetricsEvent metrics = view->CreateWindowMetricsEvent();
556 FlutterAddViewInfo info = {};
557 info.struct_size =
sizeof(FlutterAddViewInfo);
558 info.view_id = view_id;
559 info.view_metrics = &metrics;
560 info.user_data = &captures;
561 info.add_view_callback = [](
const FlutterAddViewResult* result) {
562 Captures* captures =
reinterpret_cast<Captures*
>(result->user_data);
563 captures->added = result->added;
564 captures->latch.Signal();
567 FlutterEngineResult result = embedder_api_.AddView(engine_, &info);
568 if (result != kSuccess) {
570 <<
"Starting the add view operation failed. FlutterEngineAddView "
571 "returned an unexpected result: "
572 << result <<
". This indicates a bug in the Windows embedder.";
582 captures.latch.Wait();
584 if (!captures.added) {
588 FML_LOG(ERROR) <<
"FlutterEngineAddView failed to add view";
589 std::unique_lock write_lock(views_mutex_);
590 views_.erase(view_id);
595 return std::move(view);
599 FML_DCHECK(running());
606 fml::AutoResetWaitableEvent latch;
609 Captures captures = {};
611 FlutterRemoveViewInfo info = {};
612 info.struct_size =
sizeof(FlutterRemoveViewInfo);
613 info.view_id = view_id;
614 info.user_data = &captures;
615 info.remove_view_callback = [](
const FlutterRemoveViewResult* result) {
619 Captures* captures =
reinterpret_cast<Captures*
>(result->user_data);
620 captures->removed = result->removed;
621 captures->latch.Signal();
624 FlutterEngineResult result = embedder_api_.RemoveView(engine_, &info);
625 if (result != kSuccess) {
626 FML_LOG(ERROR) <<
"Starting the remove view operation failed. "
627 "FlutterEngineRemoveView "
628 "returned an unexpected result: "
630 <<
". This indicates a bug in the Windows embedder.";
640 captures.latch.Wait();
642 if (!captures.removed) {
645 FML_LOG(ERROR) <<
"FlutterEngineRemoveView failed to remove view";
653 std::unique_lock write_lock(views_mutex_);
655 FML_DCHECK(views_.find(view_id) != views_.end());
656 views_.erase(view_id);
660 void FlutterWindowsEngine::OnVsync(intptr_t baton) {
661 std::chrono::nanoseconds current_time =
662 std::chrono::nanoseconds(embedder_api_.GetCurrentTime());
663 std::chrono::nanoseconds frame_interval = FrameInterval();
664 auto next = SnapToNextTick(current_time, start_time_, frame_interval);
665 embedder_api_.OnVsync(engine_, baton, next.count(),
666 (next + frame_interval).count());
669 std::chrono::nanoseconds FlutterWindowsEngine::FrameInterval() {
670 if (frame_interval_override_.has_value()) {
671 return frame_interval_override_.value();
673 uint64_t interval = 16600000;
675 DWM_TIMING_INFO timing_info = {};
676 timing_info.cbSize =
sizeof(timing_info);
677 HRESULT result = DwmGetCompositionTimingInfo(NULL, &timing_info);
678 if (result == S_OK && timing_info.rateRefresh.uiDenominator > 0 &&
679 timing_info.rateRefresh.uiNumerator > 0) {
680 interval =
static_cast<double>(timing_info.rateRefresh.uiDenominator *
682 static_cast<double>(timing_info.rateRefresh.uiNumerator);
685 return std::chrono::nanoseconds(interval);
689 std::shared_lock read_lock(views_mutex_);
691 auto iterator = views_.find(view_id);
692 if (iterator == views_.end()) {
696 return iterator->second;
701 return plugin_registrar_.get();
704 void FlutterWindowsEngine::AddPluginRegistrarDestructionCallback(
707 plugin_registrar_destruction_callbacks_[
callback] = registrar;
710 void FlutterWindowsEngine::SendWindowMetricsEvent(
711 const FlutterWindowMetricsEvent& event) {
713 embedder_api_.SendWindowMetricsEvent(engine_, &event);
717 void FlutterWindowsEngine::SendPointerEvent(
const FlutterPointerEvent& event) {
719 embedder_api_.SendPointerEvent(engine_, &event, 1);
723 void FlutterWindowsEngine::SendKeyEvent(
const FlutterKeyEvent& event,
731 void FlutterWindowsEngine::SendViewFocusEvent(
732 const FlutterViewFocusEvent& event) {
734 embedder_api_.SendViewFocusEvent(engine_, &event);
738 bool FlutterWindowsEngine::SendPlatformMessage(
741 const size_t message_size,
744 FlutterPlatformMessageResponseHandle* response_handle =
nullptr;
745 if (reply !=
nullptr &&
user_data !=
nullptr) {
746 FlutterEngineResult result =
747 embedder_api_.PlatformMessageCreateResponseHandle(
748 engine_, reply,
user_data, &response_handle);
749 if (result != kSuccess) {
750 FML_LOG(ERROR) <<
"Failed to create response handle";
755 FlutterPlatformMessage platform_message = {
756 sizeof(FlutterPlatformMessage),
763 FlutterEngineResult message_result =
764 embedder_api_.SendPlatformMessage(engine_, &platform_message);
765 if (response_handle !=
nullptr) {
766 embedder_api_.PlatformMessageReleaseResponseHandle(engine_,
769 return message_result == kSuccess;
772 void FlutterWindowsEngine::SendPlatformMessageResponse(
775 size_t data_length) {
776 embedder_api_.SendPlatformMessageResponse(engine_, handle, data, data_length);
779 void FlutterWindowsEngine::HandlePlatformMessage(
780 const FlutterPlatformMessage* engine_message) {
781 if (engine_message->struct_size !=
sizeof(FlutterPlatformMessage)) {
782 FML_LOG(ERROR) <<
"Invalid message size received. Expected: "
783 <<
sizeof(FlutterPlatformMessage) <<
" but received "
784 << engine_message->struct_size;
788 auto message = ConvertToDesktopMessage(*engine_message);
790 message_dispatcher_->HandleMessage(
message, [
this] {}, [
this] {});
793 void FlutterWindowsEngine::ReloadSystemFonts() {
794 embedder_api_.ReloadSystemFonts(engine_);
797 void FlutterWindowsEngine::ScheduleFrame() {
798 embedder_api_.ScheduleFrame(engine_);
801 void FlutterWindowsEngine::SetNextFrameCallback(fml::closure
callback) {
802 next_frame_callback_ = std::move(
callback);
804 embedder_api_.SetNextFrameCallback(
812 self->task_runner_->PostTask(std::move(self->next_frame_callback_));
817 HCURSOR FlutterWindowsEngine::GetCursorByName(
818 const std::string& cursor_name)
const {
819 static auto* cursors =
new std::map<std::string, const wchar_t*>{
820 {
"allScroll", IDC_SIZEALL},
821 {
"basic", IDC_ARROW},
823 {
"forbidden", IDC_NO},
825 {
"move", IDC_SIZEALL},
828 {
"precise", IDC_CROSS},
829 {
"progress", IDC_APPSTARTING},
831 {
"resizeColumn", IDC_SIZEWE},
832 {
"resizeDown", IDC_SIZENS},
833 {
"resizeDownLeft", IDC_SIZENESW},
834 {
"resizeDownRight", IDC_SIZENWSE},
835 {
"resizeLeft", IDC_SIZEWE},
836 {
"resizeLeftRight", IDC_SIZEWE},
837 {
"resizeRight", IDC_SIZEWE},
838 {
"resizeRow", IDC_SIZENS},
839 {
"resizeUp", IDC_SIZENS},
840 {
"resizeUpDown", IDC_SIZENS},
841 {
"resizeUpLeft", IDC_SIZENWSE},
842 {
"resizeUpRight", IDC_SIZENESW},
843 {
"resizeUpLeftDownRight", IDC_SIZENWSE},
844 {
"resizeUpRightDownLeft", IDC_SIZENESW},
847 const wchar_t* idc_name = IDC_ARROW;
848 auto it = cursors->find(cursor_name);
849 if (it != cursors->end()) {
850 idc_name = it->second;
852 return windows_proc_table_->LoadCursor(
nullptr, idc_name);
857 std::shared_lock read_lock(views_mutex_);
858 auto const iterator =
859 std::find_if(views_.begin(), views_.end(), [hwnd](
auto const& pair) {
860 FlutterWindowsView* const view = pair.second;
861 return GetAncestor(view->GetWindowHandle(), GA_ROOT) == hwnd;
863 if (iterator != views_.end()) {
864 return iterator->second;
869 void FlutterWindowsEngine::SendSystemLocales() {
870 std::vector<LanguageInfo> languages =
872 std::vector<FlutterLocale> flutter_locales;
873 flutter_locales.reserve(languages.size());
874 for (
const auto& info : languages) {
875 flutter_locales.push_back(CovertToFlutterLocale(info));
878 std::vector<const FlutterLocale*> flutter_locale_list;
879 flutter_locale_list.reserve(flutter_locales.size());
880 std::transform(flutter_locales.begin(), flutter_locales.end(),
881 std::back_inserter(flutter_locale_list),
882 [](
const auto& arg) ->
const auto* { return &arg; });
883 embedder_api_.UpdateLocales(engine_, flutter_locale_list.data(),
884 flutter_locale_list.size());
887 void FlutterWindowsEngine::InitializeKeyboard() {
888 auto internal_plugin_messenger = internal_plugin_registrar_->messenger();
889 KeyboardKeyEmbedderHandler::GetKeyStateHandler get_key_state = GetKeyState;
890 KeyboardKeyEmbedderHandler::MapVirtualKeyToScanCode map_vk_to_scan =
891 [](UINT virtual_key,
bool extended) {
892 return MapVirtualKey(virtual_key,
893 extended ? MAPVK_VK_TO_VSC_EX : MAPVK_VK_TO_VSC);
895 keyboard_key_handler_ = std::move(CreateKeyboardKeyHandler(
896 internal_plugin_messenger, get_key_state, map_vk_to_scan));
898 std::move(CreateTextInputPlugin(internal_plugin_messenger));
901 std::unique_ptr<KeyboardHandlerBase>
902 FlutterWindowsEngine::CreateKeyboardKeyHandler(
906 auto keyboard_key_handler = std::make_unique<KeyboardKeyHandler>(messenger);
907 keyboard_key_handler->AddDelegate(
908 std::make_unique<KeyboardKeyEmbedderHandler>(
909 [
this](
const FlutterKeyEvent& event, FlutterKeyEventCallback
callback,
913 get_key_state, map_vk_to_scan));
914 keyboard_key_handler->AddDelegate(
915 std::make_unique<KeyboardKeyChannelHandler>(messenger));
916 keyboard_key_handler->InitKeyboardChannel();
917 return keyboard_key_handler;
920 std::unique_ptr<TextInputPlugin> FlutterWindowsEngine::CreateTextInputPlugin(
922 return std::make_unique<TextInputPlugin>(messenger,
this);
925 bool FlutterWindowsEngine::RegisterExternalTexture(int64_t
texture_id) {
926 return (embedder_api_.RegisterExternalTexture(engine_,
texture_id) ==
930 bool FlutterWindowsEngine::UnregisterExternalTexture(int64_t
texture_id) {
931 return (embedder_api_.UnregisterExternalTexture(engine_,
texture_id) ==
935 bool FlutterWindowsEngine::MarkExternalTextureFrameAvailable(
937 return (embedder_api_.MarkExternalTextureFrameAvailable(
941 bool FlutterWindowsEngine::PostRasterThreadTask(fml::closure
callback)
const {
945 auto captures =
new Captures();
946 captures->callback = std::move(
callback);
947 if (embedder_api_.PostRenderThreadTask(
950 auto captures = reinterpret_cast<Captures*>(opaque);
951 captures->callback();
954 captures) == kSuccess) {
961 bool FlutterWindowsEngine::DispatchSemanticsAction(
964 FlutterSemanticsAction
action,
965 fml::MallocMapping data) {
966 FlutterSendSemanticsActionInfo info{
967 .struct_size =
sizeof(FlutterSendSemanticsActionInfo),
971 .data = data.GetMapping(),
972 .data_length = data.GetSize(),
974 return (embedder_api_.SendSemanticsAction(engine_, &info));
977 void FlutterWindowsEngine::UpdateSemanticsEnabled(
bool enabled) {
978 if (engine_ && semantics_enabled_ != enabled) {
979 std::shared_lock read_lock(views_mutex_);
981 semantics_enabled_ = enabled;
982 embedder_api_.UpdateSemanticsEnabled(engine_, enabled);
983 for (
auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
984 iterator->second->UpdateSemanticsEnabled(enabled);
989 void FlutterWindowsEngine::OnPreEngineRestart() {
991 InitializeKeyboard();
994 std::string FlutterWindowsEngine::GetExecutableName()
const {
995 std::pair<bool, std::string> result = fml::paths::GetExecutablePath();
997 const std::string& executable_path = result.second;
998 size_t last_separator = executable_path.find_last_of(
"/\\");
999 if (last_separator == std::string::npos ||
1000 last_separator == executable_path.size() - 1) {
1001 return executable_path;
1003 return executable_path.substr(last_separator + 1);
1008 void FlutterWindowsEngine::UpdateAccessibilityFeatures() {
1009 UpdateHighContrastMode();
1012 void FlutterWindowsEngine::UpdateHighContrastMode() {
1013 high_contrast_enabled_ = windows_proc_table_->GetHighContrastEnabled();
1015 SendAccessibilityFeatures();
1016 settings_plugin_->UpdateHighContrastMode(high_contrast_enabled_);
1019 void FlutterWindowsEngine::SendAccessibilityFeatures() {
1022 if (high_contrast_enabled_) {
1024 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast;
1027 embedder_api_.UpdateAccessibilityFeatures(
1028 engine_,
static_cast<FlutterAccessibilityFeature
>(flags));
1031 void FlutterWindowsEngine::RequestApplicationQuit(HWND hwnd,
1035 platform_handler_->RequestAppExit(hwnd, wparam, lparam, exit_type, 0);
1038 void FlutterWindowsEngine::OnQuit(std::optional<HWND> hwnd,
1039 std::optional<WPARAM> wparam,
1040 std::optional<LPARAM> lparam,
1042 lifecycle_manager_->Quit(hwnd, wparam, lparam, exit_code);
1045 void FlutterWindowsEngine::OnDwmCompositionChanged() {
1046 std::shared_lock read_lock(views_mutex_);
1048 for (
auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
1049 iterator->second->OnDwmCompositionChanged();
1053 void FlutterWindowsEngine::OnWindowStateEvent(HWND hwnd,
1055 lifecycle_manager_->OnWindowStateEvent(hwnd, event);
1058 std::optional<LRESULT> FlutterWindowsEngine::ProcessExternalWindowMessage(
1063 if (lifecycle_manager_) {
1064 return lifecycle_manager_->ExternalWindowMessage(hwnd,
message, wparam,
1067 return std::nullopt;
1070 void FlutterWindowsEngine::UpdateFlutterCursor(
1071 const std::string& cursor_name)
const {
1072 SetFlutterCursor(GetCursorByName(cursor_name));
1075 void FlutterWindowsEngine::SetFlutterCursor(HCURSOR cursor)
const {
1076 windows_proc_table_->SetCursor(cursor);
1079 void FlutterWindowsEngine::OnChannelUpdate(std::string name,
bool listening) {
1080 if (name ==
"flutter/platform" && listening) {
1081 lifecycle_manager_->BeginProcessingExit();
1082 }
else if (name ==
"flutter/lifecycle" && listening) {
1083 lifecycle_manager_->BeginProcessingLifecycle();
1087 void FlutterWindowsEngine::OnViewFocusChangeRequest(
1088 const FlutterViewFocusChangeRequest* request) {
1089 std::shared_lock read_lock(views_mutex_);
1091 auto iterator = views_.find(request->view_id);
1092 if (iterator == views_.end()) {
1100 bool FlutterWindowsEngine::Present(
const FlutterPresentViewInfo* info) {
1104 std::shared_lock read_lock(views_mutex_);
1106 auto iterator = views_.find(info->view_id);
1107 if (iterator == views_.end()) {
1111 FlutterWindowsView* view = iterator->second;
1113 return compositor_->Present(view, info->layers, info->layers_count);
static void SetUp(BinaryMessenger *binary_messenger, AccessibilityPlugin *plugin)
FlutterWindowsEngine(const FlutterProjectBundle &project, std::shared_ptr< WindowsProcTable > windows_proc_table=nullptr)
FlutterWindowsView * view(FlutterViewId view_id) const
void OnPreEngineRestart()
virtual void OnViewFocusChangeRequest(const FlutterViewFocusChangeRequest *request)
void HandlePlatformMessage(const FlutterPlatformMessage *)
void OnVsync(intptr_t baton)
void SetSwitches(const std::vector< std::string > &switches)
std::weak_ptr< AccessibilityBridgeWindows > accessibility_bridge()
std::function< SHORT(UINT, bool)> MapVirtualKeyToScanCode
std::function< SHORT(int)> GetKeyStateHandler
static std::unique_ptr< Manager > Create(GpuPreference gpu_preference)
static std::shared_ptr< ProcTable > Create()
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
struct _FlutterPlatformMessageResponseHandle FlutterDesktopMessageResponseHandle
void(* FlutterDesktopOnPluginRegistrarDestroyed)(FlutterDesktopPluginRegistrarRef)
static constexpr char kAccessibilityChannelName[]
FlutterDesktopBinaryReply callback
std::vector< LanguageInfo > GetPreferredLanguageInfo(const WindowsProcTable &windows_proc_table)
WindowStateEvent
An event representing a change in window state that may update the.
static void WindowsPlatformThreadPrioritySetter(FlutterThreadPriority priority)
constexpr FlutterViewId kImplicitViewId