#include <flutter_windows_engine.h>

Public Member Functions
	FlutterWindowsEngine (const FlutterProjectBundle &project, std::shared_ptr< WindowsProcTable > windows_proc_table=nullptr)

virtual	~FlutterWindowsEngine ()

bool	Run ()

bool	Run (std::string_view entrypoint)

virtual bool	running () const

virtual bool	Stop ()

std::unique_ptr< FlutterWindowsView >	CreateView (std::unique_ptr< WindowBindingHandler > window, bool is_sized_to_content, const BoxConstraints &box_constraints, FlutterWindowsViewSizingDelegate *sizing_delegate=nullptr)

virtual void	RemoveView (FlutterViewId view_id)

FlutterWindowsView *	view (FlutterViewId view_id) const

FlutterDesktopPluginRegistrarRef	GetRegistrar ()

void	AddPluginRegistrarDestructionCallback (FlutterDesktopOnPluginRegistrarDestroyed callback, FlutterDesktopPluginRegistrarRef registrar)

void	SetSwitches (const std::vector< std::string > &switches)

FlutterDesktopMessengerRef	messenger ()

IncomingMessageDispatcher *	message_dispatcher ()

std::shared_ptr< DisplayManagerWin32 >	display_manager ()

void	UpdateDisplay (const std::vector< FlutterEngineDisplay > &displays)

TaskRunner *	task_runner ()

BinaryMessenger *	messenger_wrapper ()

FlutterWindowsTextureRegistrar *	texture_registrar ()

egl::Manager *	egl_manager () const

WindowProcDelegateManager *	window_proc_delegate_manager ()

void	SendWindowMetricsEvent (const FlutterWindowMetricsEvent &event)

void	SendPointerEvent (const FlutterPointerEvent &event)

void	SendKeyEvent (const FlutterKeyEvent &event, FlutterKeyEventCallback callback, void *user_data)

void	SendViewFocusEvent (const FlutterViewFocusEvent &event)

KeyboardHandlerBase *	keyboard_key_handler ()

TextInputPlugin *	text_input_plugin ()

bool	SendPlatformMessage (const char channel, const uint8_t message, const size_t message_size, const FlutterDesktopBinaryReply reply, void *user_data)

void	SendPlatformMessageResponse (const FlutterDesktopMessageResponseHandle handle, const uint8_t data, size_t data_length)

void	HandlePlatformMessage (const FlutterPlatformMessage *)

void	ReloadSystemFonts ()

void	ScheduleFrame ()

void	SetNextFrameCallback (fml::closure callback)

bool	RegisterExternalTexture (int64_t texture_id)

bool	UnregisterExternalTexture (int64_t texture_id)

bool	MarkExternalTextureFrameAvailable (int64_t texture_id)

virtual bool	PostRasterThreadTask (fml::closure callback) const

void	OnVsync (intptr_t baton)

bool	DispatchSemanticsAction (FlutterViewId view_id, uint64_t node_id, FlutterSemanticsAction action, fml::MallocMapping data)

void	UpdateSemanticsEnabled (bool enabled)

bool	semantics_enabled () const

bool	iaccessibleex_enabled () const

void	UpdateAccessibilityFeatures ()

void	UpdateHighContrastMode ()

bool	high_contrast_enabled () const

void	SetRootIsolateCreateCallback (const fml::closure &callback)

std::string	GetExecutableName () const

void	OnQuit (std::optional< HWND > hwnd, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)

void	RequestApplicationQuit (HWND hwnd, WPARAM wparam, LPARAM lparam, AppExitType exit_type)

void	OnDwmCompositionChanged ()

void	OnWindowStateEvent (HWND hwnd, WindowStateEvent event)

std::optional< LRESULT >	ProcessExternalWindowMessage (HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)

WindowsLifecycleManager *	lifecycle_manager ()

std::shared_ptr< WindowsProcTable >	windows_proc_table ()

void	UpdateFlutterCursor (const std::string &cursor_name) const

void	SetFlutterCursor (HCURSOR cursor) const

WindowManager *	window_manager ()

FlutterWindowsView *	GetViewFromTopLevelWindow (HWND hwnd) const

Static Public Member Functions
static FlutterWindowsEngine *	GetEngineForId (int64_t engine_id)

Protected Member Functions
virtual std::unique_ptr< KeyboardHandlerBase >	CreateKeyboardKeyHandler (BinaryMessenger *messenger, KeyboardKeyEmbedderHandler::GetKeyStateHandler get_key_state, KeyboardKeyEmbedderHandler::MapVirtualKeyToScanCode map_vk_to_scan)

virtual std::unique_ptr< TextInputPlugin >	CreateTextInputPlugin (BinaryMessenger *messenger)

void	OnPreEngineRestart ()

virtual void	OnChannelUpdate (std::string name, bool listening)

virtual void	OnViewFocusChangeRequest (const FlutterViewFocusChangeRequest *request)

Friends
class	EngineModifier

Detailed Description

Definition at line 92 of file flutter_windows_engine.h.

Constructor & Destructor Documentation

◆ FlutterWindowsEngine()

flutter::FlutterWindowsEngine::FlutterWindowsEngine	(	const FlutterProjectBundle &	project,
		std::shared_ptr< WindowsProcTable >	windows_proc_table = `nullptr`
	)

Definition at line 151 of file flutter_windows_engine.cc.

     : project_(std::make_unique<FlutterProjectBundle>(project)),
       windows_proc_table_(std::move(windows_proc_table)),
       aot_data_(nullptr, nullptr),
       lifecycle_manager_(std::make_unique<WindowsLifecycleManager>(this)) {
   if (windows_proc_table_ == nullptr) {
     windows_proc_table_ = std::make_shared<WindowsProcTable>();
   }
  
   gl_ = egl::ProcTable::Create();
  
   embedder_api_.struct_size = sizeof(FlutterEngineProcTable);
   FlutterEngineGetProcAddresses(&embedder_api_);
  
   task_runner_ =
       std::make_unique<TaskRunner>(
           embedder_api_.GetCurrentTime, [this](const auto* task) {
             if (!engine_) {
               FML_LOG(ERROR)
                   << "Cannot post an engine task when engine is not running.";
               return;
             }
             if (embedder_api_.RunTask(engine_, task) != kSuccess) {
               FML_LOG(ERROR) << "Failed to post an engine task.";
             }
           });
  
   // Set up the legacy structs backing the API handles.
   messenger_ =
       fml::RefPtr<FlutterDesktopMessenger>(new FlutterDesktopMessenger());
   messenger_->SetEngine(this);
   plugin_registrar_ = std::make_unique<FlutterDesktopPluginRegistrar>();
   plugin_registrar_->engine = this;
  
   messenger_wrapper_ =
       std::make_unique<BinaryMessengerImpl>(messenger_->ToRef());
   message_dispatcher_ =
       std::make_unique<IncomingMessageDispatcher>(messenger_->ToRef());
  
   texture_registrar_ =
       std::make_unique<FlutterWindowsTextureRegistrar>(this, gl_);
  
   // Check for impeller support.
   auto& switches = project_->GetSwitches();
   bool enable_impeller = true;
   if (project_->impeller_switch() == FlutterImpellerSwitch::Enabled) {
     enable_impeller = true;
   } else if (project_->impeller_switch() == FlutterImpellerSwitch::Disabled) {
     enable_impeller = false;
   }
   for (const auto& env_switch : switches) {
     if (env_switch == "--enable-impeller" ||
         env_switch == "--enable-impeller=true") {
       enable_impeller = true;
     } else if (env_switch == "--enable-impeller=false") {
       enable_impeller = false;
     }
   }
   enable_impeller_ = enable_impeller;
  
   egl_manager_ = egl::Manager::Create(
       static_cast<egl::GpuPreference>(project_->gpu_preference()));
   window_proc_delegate_manager_ = std::make_unique<WindowProcDelegateManager>();
  
   display_manager_ = std::make_shared<DisplayManagerWin32>(this);
  
   window_proc_delegate_manager_->RegisterTopLevelWindowProcDelegate(
       [](HWND hwnd, UINT msg, WPARAM wpar, LPARAM lpar, void* user_data,
          LRESULT* result) {
         BASE_DCHECK(user_data);
         FlutterWindowsEngine* that =
             static_cast<FlutterWindowsEngine*>(user_data);
  
         BASE_DCHECK(that->display_manager_);
         if (that->display_manager_->HandleWindowMessage(hwnd, msg, wpar, lpar,
                                                         result)) {
           return true;
         }
  
         BASE_DCHECK(that->lifecycle_manager_);
         bool handled =
             that->lifecycle_manager_->WindowProc(hwnd, msg, wpar, lpar, result);
         if (handled) {
           return true;
         }
         auto message_result =
             that->window_manager_->HandleMessage(hwnd, msg, wpar, lpar);
         if (message_result) {
           *result = *message_result;
           return true;
         }
         return false;
       },
       static_cast<void*>(this));
  
   // Set up internal channels.
   // TODO: Replace this with an embedder.h API. See
   // https://github.com/flutter/flutter/issues/71099
   internal_plugin_registrar_ =
       std::make_unique<PluginRegistrar>(plugin_registrar_.get());
  
   accessibility_plugin_ = std::make_unique<AccessibilityPlugin>(this);
   AccessibilityPlugin::SetUp(messenger_wrapper_.get(),
                              accessibility_plugin_.get());
  
   cursor_handler_ =
       std::make_unique<CursorHandler>(messenger_wrapper_.get(), this);
   platform_handler_ =
       std::make_unique<PlatformHandler>(messenger_wrapper_.get(), this);
   window_manager_ = std::make_unique<WindowManager>(this);
   settings_plugin_ = std::make_unique<SettingsPlugin>(messenger_wrapper_.get(),
                                                       task_runner_.get());
 }

References flutter::egl::ProcTable::Create().

◆ ~FlutterWindowsEngine()

flutter::FlutterWindowsEngine::~FlutterWindowsEngine ( )

virtual

Definition at line 267 of file flutter_windows_engine.cc.

                                             {
   messenger_->SetEngine(nullptr);
   Stop();
 }

Member Function Documentation

◆ AddPluginRegistrarDestructionCallback()

void flutter::FlutterWindowsEngine::AddPluginRegistrarDestructionCallback	(	FlutterDesktopOnPluginRegistrarDestroyed	callback,
		FlutterDesktopPluginRegistrarRef	registrar
	)

Definition at line 761 of file flutter_windows_engine.cc.

                                                 {
   plugin_registrar_destruction_callbacks_[callback] = registrar;
 }

References callback.

Referenced by FlutterDesktopPluginRegistrarSetDestructionHandler().

◆ CreateKeyboardKeyHandler()

std::unique_ptr< KeyboardHandlerBase > flutter::FlutterWindowsEngine::CreateKeyboardKeyHandler	(	BinaryMessenger *	messenger,
		KeyboardKeyEmbedderHandler::GetKeyStateHandler	get_key_state,
		KeyboardKeyEmbedderHandler::MapVirtualKeyToScanCode	map_vk_to_scan
	)

protectedvirtual

Definition at line 968 of file flutter_windows_engine.cc.

                                                                       {
   auto keyboard_key_handler = std::make_unique<KeyboardKeyHandler>(messenger);
   keyboard_key_handler->AddDelegate(
       std::make_unique<KeyboardKeyEmbedderHandler>(
           [this](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
                  void* user_data) {
             return SendKeyEvent(event, callback, user_data);
           },
           get_key_state, map_vk_to_scan));
   keyboard_key_handler->AddDelegate(
       std::make_unique<KeyboardKeyChannelHandler>(messenger));
   keyboard_key_handler->InitKeyboardChannel();
   return keyboard_key_handler;
 }

References callback, and user_data.

◆ CreateTextInputPlugin()

std::unique_ptr< TextInputPlugin > flutter::FlutterWindowsEngine::CreateTextInputPlugin ( BinaryMessenger * messenger )

protectedvirtual

Definition at line 986 of file flutter_windows_engine.cc.

                                 {
   return std::make_unique<TextInputPlugin>(messenger, this);
 }

◆ CreateView()

std::unique_ptr< FlutterWindowsView > flutter::FlutterWindowsEngine::CreateView	(	std::unique_ptr< WindowBindingHandler >	window,
		bool	is_sized_to_content,
		const BoxConstraints &	box_constraints,
		FlutterWindowsViewSizingDelegate *	sizing_delegate = `nullptr`
	)

Definition at line 572 of file flutter_windows_engine.cc.

                                                        {
   auto view_id = next_view_id_;
   auto view = std::make_unique<FlutterWindowsView>(
       view_id, this, std::move(window), is_sized_to_content, box_constraints,
       sizing_delegate, windows_proc_table_);
  
   view->CreateRenderSurface();
   view->UpdateSemanticsEnabled(semantics_enabled_);
  
   next_view_id_++;
  
   {
     // Add the view to the embedder. This must happen before the engine
     // is notified the view exists and starts presenting to it.
     std::unique_lock write_lock(views_mutex_);
     FML_DCHECK(views_.find(view_id) == views_.end());
     views_[view_id] = view.get();
   }
  
   if (!view->IsImplicitView()) {
     FML_DCHECK(running());
  
     struct Captures {
       fml::AutoResetWaitableEvent latch;
       bool added;
     };
     Captures captures = {};
  
     FlutterWindowMetricsEvent metrics = view->CreateWindowMetricsEvent();
  
     FlutterAddViewInfo info = {};
     info.struct_size = sizeof(FlutterAddViewInfo);
     info.view_id = view_id;
     info.view_metrics = &metrics;
     info.user_data = &captures;
     info.add_view_callback = [](const FlutterAddViewResult* result) {
       Captures* captures = reinterpret_cast<Captures*>(result->user_data);
       captures->added = result->added;
       captures->latch.Signal();
     };
  
     FlutterEngineResult result = embedder_api_.AddView(engine_, &info);
     if (result != kSuccess) {
       FML_LOG(ERROR)
           << "Starting the add view operation failed. FlutterEngineAddView "
              "returned an unexpected result: "
           << result << ". This indicates a bug in the Windows embedder.";
       FML_DCHECK(false);
       return nullptr;
     }
  
     // Block the platform thread until the engine has added the view.
     // TODO(loicsharma): This blocks the platform thread eagerly and can
     // cause unnecessary delay in input processing. Instead, this should block
     // lazily only when the app does an operation which needs the view.
     // https://github.com/flutter/flutter/issues/146248
     captures.latch.Wait();
  
     if (!captures.added) {
       // Adding the view failed. Update the embedder's state to match the
       // engine's state. This is unexpected and indicates a bug in the Windows
       // embedder.
       FML_LOG(ERROR) << "FlutterEngineAddView failed to add view";
       std::unique_lock write_lock(views_mutex_);
       views_.erase(view_id);
       return nullptr;
     }
   }
  
   return std::move(view);
 }

Referenced by CreateViewController(), flutter::HostWindow::InitializeFlutterView(), and flutter::testing::TEST_F().

◆ DispatchSemanticsAction()

bool flutter::FlutterWindowsEngine::DispatchSemanticsAction	(	FlutterViewId	view_id,
		uint64_t	node_id,
		FlutterSemanticsAction	action,
		fml::MallocMapping	data
	)

Definition at line 1027 of file flutter_windows_engine.cc.

                            {
   FlutterSendSemanticsActionInfo info{
       .struct_size = sizeof(FlutterSendSemanticsActionInfo),
       .view_id = view_id,
       .node_id = target,
       .action = action,
       .data = data.GetMapping(),
       .data_length = data.GetSize(),
   };
   return (embedder_api_.SendSemanticsAction(engine_, &info));
 }

References action.

Referenced by flutter::AccessibilityBridgeWindows::DispatchAccessibilityAction().

◆ display_manager()

std::shared_ptr<DisplayManagerWin32> flutter::FlutterWindowsEngine::display_manager ( )

inline

Definition at line 166 of file flutter_windows_engine.h.

                                                        {
     return display_manager_;
   }

Referenced by CreateViewController(), and flutter::HostWindow::InitializeFlutterView().

◆ egl_manager()

egl::Manager* flutter::FlutterWindowsEngine::egl_manager ( ) const

inline

Definition at line 183 of file flutter_windows_engine.h.

183 { return egl_manager_.get(); }

Referenced by flutter::FlutterWindowsView::CreateRenderSurface(), FlutterDesktopEngineGetGraphicsAdapter(), flutter::FlutterWindowsView::OnWindowSizeChanged(), and flutter::FlutterWindowsTextureRegistrar::RegisterTexture().

◆ GetEngineForId()

FlutterWindowsEngine * flutter::FlutterWindowsEngine::GetEngineForId ( int64_t engine_id )

static

Definition at line 272 of file flutter_windows_engine.cc.

                                                                             {
   return reinterpret_cast<FlutterWindowsEngine*>(engine_id);
 }

Referenced by FlutterDesktopEngineForId(), InternalFlutterWindows_WindowManager_CreateDialogWindow(), InternalFlutterWindows_WindowManager_CreatePopupWindow(), InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), and InternalFlutterWindows_WindowManager_Initialize().

◆ GetExecutableName()

std::string flutter::FlutterWindowsEngine::GetExecutableName ( ) const

Definition at line 1060 of file flutter_windows_engine.cc.

                                                         {
   std::pair<bool, std::string> result = fml::paths::GetExecutablePath();
   if (result.first) {
     const std::string& executable_path = result.second;
     size_t last_separator = executable_path.find_last_of("/\\");
     if (last_separator == std::string::npos ||
         last_separator == executable_path.size() - 1) {
       return executable_path;
     }
     return executable_path.substr(last_separator + 1);
   }
   return "Flutter";
 }

◆ GetRegistrar()

FlutterDesktopPluginRegistrarRef flutter::FlutterWindowsEngine::GetRegistrar ( )

Definition at line 757 of file flutter_windows_engine.cc.

                                                                     {
   return plugin_registrar_.get();
 }

Referenced by FlutterDesktopEngineGetPluginRegistrar().

◆ GetViewFromTopLevelWindow()

FlutterWindowsView * flutter::FlutterWindowsEngine::GetViewFromTopLevelWindow ( HWND hwnd ) const

Definition at line 921 of file flutter_windows_engine.cc.

                      {
   std::shared_lock read_lock(views_mutex_);
   auto const iterator =
       std::find_if(views_.begin(), views_.end(), [hwnd](auto const& pair) {
         FlutterWindowsView* const view = pair.second;
         return GetAncestor(view->GetWindowHandle(), GA_ROOT) == hwnd;
       });
   if (iterator != views_.end()) {
     return iterator->second;
   }
   return nullptr;
 }

◆ HandlePlatformMessage()

void flutter::FlutterWindowsEngine::HandlePlatformMessage ( const FlutterPlatformMessage * engine_message )

Definition at line 845 of file flutter_windows_engine.cc.

                                                   {
   if (engine_message->struct_size != sizeof(FlutterPlatformMessage)) {
     FML_LOG(ERROR) << "Invalid message size received. Expected: "
                    << sizeof(FlutterPlatformMessage) << " but received "
                    << engine_message->struct_size;
     return;
   }
  
   auto message = ConvertToDesktopMessage(*engine_message);
  
   message_dispatcher_->HandleMessage(message, [this] {}, [this] {});
 }

References message.

Referenced by Run().

◆ high_contrast_enabled()

bool flutter::FlutterWindowsEngine::high_contrast_enabled ( ) const

inline

Definition at line 275 of file flutter_windows_engine.h.

275 { return high_contrast_enabled_; }

◆ iaccessibleex_enabled()

bool flutter::FlutterWindowsEngine::iaccessibleex_enabled ( ) const

inline

Definition at line 263 of file flutter_windows_engine.h.

                                      {
     return project_->accessibility_mode() ==
            FlutterAccessibilityMode::IAccessibleEx;
   }

References flutter::IAccessibleEx.

Referenced by flutter::FlutterPlatformNodeDelegateWindows::IsIAccessibleExEnabled().

◆ keyboard_key_handler()

KeyboardHandlerBase* flutter::FlutterWindowsEngine::keyboard_key_handler ( )

inline

Definition at line 203 of file flutter_windows_engine.h.

                                               {
     return keyboard_key_handler_.get();
   }

Referenced by flutter::FlutterWindowsView::OnPointerMove().

◆ lifecycle_manager()

WindowsLifecycleManager* flutter::FlutterWindowsEngine::lifecycle_manager ( )

inline

Definition at line 320 of file flutter_windows_engine.h.

                                                {
     return lifecycle_manager_.get();
   }

◆ MarkExternalTextureFrameAvailable()

bool flutter::FlutterWindowsEngine::MarkExternalTextureFrameAvailable ( int64_t texture_id )

Definition at line 1001 of file flutter_windows_engine.cc.

                         {
   return (embedder_api_.MarkExternalTextureFrameAvailable(
               engine_, texture_id) == kSuccess);
 }

◆ message_dispatcher()

IncomingMessageDispatcher* flutter::FlutterWindowsEngine::message_dispatcher ( )

inline

Definition at line 162 of file flutter_windows_engine.h.

                                                   {
     return message_dispatcher_.get();
   }

Referenced by FlutterDesktopMessengerSetCallback().

◆ messenger()

FlutterDesktopMessengerRef flutter::FlutterWindowsEngine::messenger ( )

inline

Definition at line 160 of file flutter_windows_engine.h.

160 { return messenger_->ToRef(); }

Referenced by FlutterDesktopEngineGetMessenger(), and FlutterDesktopPluginRegistrarGetMessenger().

◆ messenger_wrapper()

BinaryMessenger* flutter::FlutterWindowsEngine::messenger_wrapper ( )

inline

Definition at line 175 of file flutter_windows_engine.h.

175 { return messenger_wrapper_.get(); }

◆ OnChannelUpdate()

void flutter::FlutterWindowsEngine::OnChannelUpdate	(	std::string	name,
		bool	listening
	)

protectedvirtual

Definition at line 1148 of file flutter_windows_engine.cc.

                                                                          {
   if (name == "flutter/platform" && listening) {
     lifecycle_manager_->BeginProcessingExit();
   } else if (name == "flutter/lifecycle" && listening) {
     lifecycle_manager_->BeginProcessingLifecycle();
   }
 }

◆ OnDwmCompositionChanged()

void flutter::FlutterWindowsEngine::OnDwmCompositionChanged ( )

Definition at line 1111 of file flutter_windows_engine.cc.

                                                    {
   if (display_manager_) {
     display_manager_->UpdateDisplays();
   }
  
   std::shared_lock read_lock(views_mutex_);
   for (auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
     iterator->second->OnDwmCompositionChanged();
   }
 }

Referenced by flutter::WindowsLifecycleManager::WindowProc().

◆ OnPreEngineRestart()

void flutter::FlutterWindowsEngine::OnPreEngineRestart ( )

protected

Definition at line 1055 of file flutter_windows_engine.cc.

                                               {
   // Reset the keyboard's state on hot restart.
   InitializeKeyboard();
 }

Referenced by Run().

◆ OnQuit()

void flutter::FlutterWindowsEngine::OnQuit	(	std::optional< HWND >	hwnd,
		std::optional< WPARAM >	wparam,
		std::optional< LPARAM >	lparam,
		UINT	exit_code
	)

Definition at line 1104 of file flutter_windows_engine.cc.

                                                   {
   lifecycle_manager_->Quit(hwnd, wparam, lparam, exit_code);
 }

Referenced by flutter::PlatformHandler::QuitApplication().

◆ OnViewFocusChangeRequest()

void flutter::FlutterWindowsEngine::OnViewFocusChangeRequest ( const FlutterViewFocusChangeRequest * request )

protectedvirtual

Definition at line 1156 of file flutter_windows_engine.cc.

                                                   {
   std::shared_lock read_lock(views_mutex_);
  
   auto iterator = views_.find(request->view_id);
   if (iterator == views_.end()) {
     return;
   }
  
   FlutterWindowsView* view = iterator->second;
   view->Focus();
 }

References flutter::FlutterWindowsView::Focus().

Referenced by Run().

◆ OnVsync()

void flutter::FlutterWindowsEngine::OnVsync ( intptr_t baton )

Definition at line 717 of file flutter_windows_engine.cc.

                                                  {
   std::chrono::nanoseconds current_time =
       std::chrono::nanoseconds(embedder_api_.GetCurrentTime());
   std::chrono::nanoseconds frame_interval = FrameInterval();
   auto next = SnapToNextTick(current_time, start_time_, frame_interval);
   embedder_api_.OnVsync(engine_, baton, next.count(),
                         (next + frame_interval).count());
 }

Referenced by Run().

◆ OnWindowStateEvent()

void flutter::FlutterWindowsEngine::OnWindowStateEvent	(	HWND	hwnd,
		WindowStateEvent	event
	)

Definition at line 1122 of file flutter_windows_engine.cc.

                                                                       {
   lifecycle_manager_->OnWindowStateEvent(hwnd, event);
 }

Referenced by flutter::FlutterWindowsView::OnWindowStateEvent(), and flutter::FlutterWindowsView::~FlutterWindowsView().

◆ PostRasterThreadTask()

bool flutter::FlutterWindowsEngine::PostRasterThreadTask ( fml::closure callback ) const

virtual

Definition at line 1007 of file flutter_windows_engine.cc.

                                                                          {
   struct Captures {
     fml::closure callback;
   };
   auto captures = new Captures();
   captures->callback = std::move(callback);
   if (embedder_api_.PostRenderThreadTask(
           engine_,
           [](void* opaque) {
             auto captures = reinterpret_cast<Captures*>(opaque);
             captures->callback();
             delete captures;
           },
           captures) == kSuccess) {
     return true;
   }
   delete captures;
   return false;
 }

References callback.

Referenced by flutter::FlutterWindowsTextureRegistrar::UnregisterTexture().

◆ ProcessExternalWindowMessage()

std::optional< LRESULT > flutter::FlutterWindowsEngine::ProcessExternalWindowMessage	(	HWND	hwnd,
		UINT	message,
		WPARAM	wparam,
		LPARAM	lparam
	)

Definition at line 1127 of file flutter_windows_engine.cc.

                    {
   if (lifecycle_manager_) {
     return lifecycle_manager_->ExternalWindowMessage(hwnd, message, wparam,
                                                      lparam);
   }
   return std::nullopt;
 }

References message.

Referenced by FlutterDesktopEngineProcessExternalWindowMessage().

◆ RegisterExternalTexture()

bool flutter::FlutterWindowsEngine::RegisterExternalTexture ( int64_t texture_id )

Definition at line 991 of file flutter_windows_engine.cc.

                                                                      {
   return (embedder_api_.RegisterExternalTexture(engine_, texture_id) ==
           kSuccess);
 }

◆ ReloadSystemFonts()

void flutter::FlutterWindowsEngine::ReloadSystemFonts ( )

Definition at line 859 of file flutter_windows_engine.cc.

                                              {
   embedder_api_.ReloadSystemFonts(engine_);
 }

Referenced by FlutterDesktopEngineReloadSystemFonts().

◆ RemoveView()

void flutter::FlutterWindowsEngine::RemoveView ( FlutterViewId view_id )

virtual

Definition at line 648 of file flutter_windows_engine.cc.

                                                            {
   FML_DCHECK(running());
  
   // Notify the engine to stop rendering to the view if it isn't the implicit
   // view. The engine and framework assume the implicit view always exists and
   // can continue presenting.
   if (view_id != kImplicitViewId) {
     struct Captures {
       fml::AutoResetWaitableEvent latch;
       bool removed;
     };
     Captures captures = {};
  
     FlutterRemoveViewInfo info = {};
     info.struct_size = sizeof(FlutterRemoveViewInfo);
     info.view_id = view_id;
     info.user_data = &captures;
     info.remove_view_callback = [](const FlutterRemoveViewResult* result) {
       // This is invoked on an engine thread. If
       // |FlutterRemoveViewResult.removed| is `true`, the engine guarantees the
       // view won't be presented.
       Captures* captures = reinterpret_cast<Captures*>(result->user_data);
       captures->removed = result->removed;
       captures->latch.Signal();
     };
  
     FlutterEngineResult result = embedder_api_.RemoveView(engine_, &info);
     if (result != kSuccess) {
       FML_LOG(ERROR) << "Starting the remove view operation failed. "
                         "FlutterEngineRemoveView "
                         "returned an unexpected result: "
                      << result
                      << ". This indicates a bug in the Windows embedder.";
       FML_DCHECK(false);
       return;
     }
  
     // Block the platform thread until the engine has removed the view.
     // TODO(loicsharma): This blocks the platform thread eagerly and can
     // cause unnecessary delay in input processing. Instead, this should block
     // lazily only when an operation needs the view.
     // https://github.com/flutter/flutter/issues/146248
     captures.latch.Wait();
  
     if (!captures.removed) {
       // Removing the view failed. This is unexpected and indicates a bug in the
       // Windows embedder.
       FML_LOG(ERROR) << "FlutterEngineRemoveView failed to remove view";
       return;
     }
   }
  
   {
     // The engine no longer presents to the view. Remove the view from the
     // embedder.
     std::unique_lock write_lock(views_mutex_);
  
     FML_DCHECK(views_.find(view_id) != views_.end());
  
     // Reset text input state if the removed view is the active text input
     // view, to prevent stale view references.
     if (text_input_plugin_) {
       text_input_plugin_->OnViewRemoved(view_id);
     }
  
     views_.erase(view_id);
   }
 }

References flutter::kImplicitViewId.

◆ RequestApplicationQuit()

void flutter::FlutterWindowsEngine::RequestApplicationQuit	(	HWND	hwnd,
		WPARAM	wparam,
		LPARAM	lparam,
		AppExitType	exit_type
	)

Definition at line 1097 of file flutter_windows_engine.cc.

                                                                          {
   platform_handler_->RequestAppExit(hwnd, wparam, lparam, exit_type, 0);
 }

◆ Run() [1/2]

bool flutter::FlutterWindowsEngine::Run ( )

Definition at line 281 of file flutter_windows_engine.cc.

                                {
   return Run("");
 }

Referenced by FlutterDesktopEngineRun().

◆ Run() [2/2]

bool flutter::FlutterWindowsEngine::Run ( std::string_view entrypoint )

Definition at line 285 of file flutter_windows_engine.cc.

                                                         {
   if (!project_->HasValidPaths()) {
     FML_LOG(ERROR) << "Missing or unresolvable paths to assets.";
     return false;
   }
   std::string assets_path_string = fml::PathToUtf8(project_->assets_path());
   std::string icu_path_string = fml::PathToUtf8(project_->icu_path());
   if (embedder_api_.RunsAOTCompiledDartCode()) {
     aot_data_ = project_->LoadAotData(embedder_api_);
     if (!aot_data_) {
       FML_LOG(ERROR) << "Unable to start engine without AOT data.";
       return false;
     }
   }
  
   // FlutterProjectArgs is expecting a full argv, so when processing it for
   // flags the first item is treated as the executable and ignored. Add a dummy
   // value so that all provided arguments are used.
   std::string executable_name = GetExecutableName();
   std::vector<const char*> argv = {executable_name.c_str()};
   std::vector<std::string> switches = project_->GetSwitches();
   if (enable_impeller_) {
     if (std::find(switches.begin(), switches.end(),
                   "--impeller-use-sdfs=true") == switches.end() &&
         std::find(switches.begin(), switches.end(),
                   "--impeller-use-sdfs=false") == switches.end()) {
       switches.push_back("--impeller-use-sdfs=true");
     }
     if (std::find(switches.begin(), switches.end(), "--enable-impeller") ==
             switches.end() &&
         std::find(switches.begin(), switches.end(), "--enable-impeller=true") ==
             switches.end()) {
       // Impeller was enabled programmatically, so forward the switch to the
       // engine.
       switches.push_back("--enable-impeller");
     }
   } else if (project_->impeller_switch() == FlutterImpellerSwitch::Disabled) {
     if (std::find(switches.begin(), switches.end(),
                   "--enable-impeller=false") == switches.end()) {
       // Impeller was disabled programmatically, so forward the switch to the
       // engine.
       switches.push_back("--enable-impeller=false");
     }
   }
   if (project_->enable_flutter_gpu()) {
     if (std::find(switches.begin(), switches.end(), "--enable-flutter-gpu") ==
             switches.end() &&
         std::find(switches.begin(), switches.end(),
                   "--enable-flutter-gpu=true") == switches.end()) {
       // Flutter GPU was enabled programmatically, so forward the switch to
       // the engine.
       switches.push_back("--enable-flutter-gpu");
     }
   }
   std::transform(
       switches.begin(), switches.end(), std::back_inserter(argv),
       [](const std::string& arg) -> const char* { return arg.c_str(); });
  
   const std::vector<std::string>& entrypoint_args =
       project_->dart_entrypoint_arguments();
   std::vector<const char*> entrypoint_argv;
   std::transform(
       entrypoint_args.begin(), entrypoint_args.end(),
       std::back_inserter(entrypoint_argv),
       [](const std::string& arg) -> const char* { return arg.c_str(); });
  
   // Configure task runners.
   FlutterTaskRunnerDescription platform_task_runner = {};
   platform_task_runner.struct_size = sizeof(FlutterTaskRunnerDescription);
   platform_task_runner.user_data = task_runner_.get();
   platform_task_runner.runs_task_on_current_thread_callback =
       [](void* user_data) -> bool {
     return static_cast<TaskRunner*>(user_data)->RunsTasksOnCurrentThread();
   };
   platform_task_runner.post_task_callback = [](FlutterTask task,
                                                uint64_t target_time_nanos,
                                                void* user_data) -> void {
     static_cast<TaskRunner*>(user_data)->PostFlutterTask(task,
                                                          target_time_nanos);
   };
   FlutterCustomTaskRunners custom_task_runners = {};
   custom_task_runners.struct_size = sizeof(FlutterCustomTaskRunners);
   custom_task_runners.platform_task_runner = &platform_task_runner;
   custom_task_runners.thread_priority_setter =
       &WindowsPlatformThreadPrioritySetter;
  
   if (project_->ui_thread_policy() !=
       FlutterUIThreadPolicy::RunOnSeparateThread) {
     custom_task_runners.ui_task_runner = &platform_task_runner;
   } else {
     FML_LOG(WARNING) << "Running with unmerged platform and UI threads. This "
                         "will be removed in future.";
   }
  
   FlutterProjectArgs args = {};
   args.struct_size = sizeof(FlutterProjectArgs);
   args.shutdown_dart_vm_when_done = true;
   args.assets_path = assets_path_string.c_str();
   args.icu_data_path = icu_path_string.c_str();
   args.command_line_argc = static_cast<int>(argv.size());
   args.command_line_argv = argv.empty() ? nullptr : argv.data();
   args.engine_id = reinterpret_cast<int64_t>(this);
  
   // Fail if conflicting non-default entrypoints are specified in the method
   // argument and the project.
   //
   // TODO(cbracken): https://github.com/flutter/flutter/issues/109285
   // The entrypoint method parameter should eventually be removed from this
   // method and only the entrypoint specified in project_ should be used.
   if (!project_->dart_entrypoint().empty() && !entrypoint.empty() &&
       project_->dart_entrypoint() != entrypoint) {
     FML_LOG(ERROR) << "Conflicting entrypoints were specified in "
                       "FlutterDesktopEngineProperties.dart_entrypoint and "
                       "FlutterDesktopEngineRun(engine, entry_point). ";
     return false;
   }
   if (!entrypoint.empty()) {
     args.custom_dart_entrypoint = entrypoint.data();
   } else if (!project_->dart_entrypoint().empty()) {
     args.custom_dart_entrypoint = project_->dart_entrypoint().c_str();
   }
   args.dart_entrypoint_argc = static_cast<int>(entrypoint_argv.size());
   args.dart_entrypoint_argv =
       entrypoint_argv.empty() ? nullptr : entrypoint_argv.data();
   args.platform_message_callback =
       [](const FlutterPlatformMessage* engine_message,
          void* user_data) -> void {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
     return host->HandlePlatformMessage(engine_message);
   };
   args.vsync_callback = [](void* user_data, intptr_t baton) -> void {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
     host->OnVsync(baton);
   };
   args.on_pre_engine_restart_callback = [](void* user_data) {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
     host->OnPreEngineRestart();
   };
   args.update_semantics_callback2 = [](const FlutterSemanticsUpdate2* update,
                                        void* user_data) {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
  
     auto view = host->view(update->view_id);
     if (!view) {
       return;
     }
  
     auto accessibility_bridge = view->accessibility_bridge().lock();
     if (!accessibility_bridge) {
       return;
     }
  
     for (size_t i = 0; i < update->node_count; i++) {
       const FlutterSemanticsNode2* node = update->nodes[i];
       accessibility_bridge->AddFlutterSemanticsNodeUpdate(*node);
     }
  
     for (size_t i = 0; i < update->custom_action_count; i++) {
       const FlutterSemanticsCustomAction2* action = update->custom_actions[i];
       accessibility_bridge->AddFlutterSemanticsCustomActionUpdate(*action);
     }
  
     accessibility_bridge->CommitUpdates();
   };
   args.root_isolate_create_callback = [](void* user_data) {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
     if (host->root_isolate_create_callback_) {
       host->root_isolate_create_callback_();
     }
   };
   args.channel_update_callback = [](const FlutterChannelUpdate* update,
                                     void* user_data) {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
     if (SAFE_ACCESS(update, channel, nullptr) != nullptr) {
       std::string channel_name(update->channel);
       host->OnChannelUpdate(std::move(channel_name),
                             SAFE_ACCESS(update, listening, false));
     }
   };
   args.view_focus_change_request_callback =
       [](const FlutterViewFocusChangeRequest* request, void* user_data) {
         auto host = static_cast<FlutterWindowsEngine*>(user_data);
         host->OnViewFocusChangeRequest(request);
       };
  
   args.custom_task_runners = &custom_task_runners;
  
   if (!platform_view_plugin_) {
     platform_view_plugin_ = std::make_unique<PlatformViewPlugin>(
         messenger_wrapper_.get(), task_runner_.get());
   }
   if (egl_manager_) {
     auto resolver = [](const char* name) -> void* {
       return reinterpret_cast<void*>(::eglGetProcAddress(name));
     };
  
     // TODO(schectman) Pass the platform view manager to the compositor
     // constructors: https://github.com/flutter/flutter/issues/143375
     compositor_ =
         std::make_unique<CompositorOpenGL>(this, resolver, enable_impeller_);
   } else {
     compositor_ = std::make_unique<CompositorSoftware>();
   }
  
   FlutterCompositor compositor = {};
   compositor.struct_size = sizeof(FlutterCompositor);
   compositor.user_data = this;
   compositor.create_backing_store_callback =
       [](const FlutterBackingStoreConfig* config,
          FlutterBackingStore* backing_store_out, void* user_data) -> bool {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
  
     return host->compositor_->CreateBackingStore(*config, backing_store_out);
   };
  
   compositor.collect_backing_store_callback =
       [](const FlutterBackingStore* backing_store, void* user_data) -> bool {
     auto host = static_cast<FlutterWindowsEngine*>(user_data);
  
     return host->compositor_->CollectBackingStore(backing_store);
   };
  
   compositor.present_view_callback =
       [](const FlutterPresentViewInfo* info) -> bool {
     auto host = static_cast<FlutterWindowsEngine*>(info->user_data);
  
     return host->Present(info);
   };
   args.compositor = &compositor;
  
   if (aot_data_) {
     args.aot_data = aot_data_.get();
   }
  
   // The platform thread creates OpenGL contexts. These
   // must be released to be used by the engine's threads.
   FML_DCHECK(!egl_manager_ || !egl_manager_->HasContextCurrent());
  
   FlutterRendererConfig renderer_config;
  
   if (enable_impeller_) {
     // Impeller does not support a Software backend. Avoid falling back and
     // confusing the engine on which renderer is selected.
     if (!egl_manager_) {
       FML_LOG(ERROR) << "Could not create surface manager. Impeller backend "
                         "does not support software rendering.";
       return false;
     }
     renderer_config = GetOpenGLRendererConfig();
   } else {
     renderer_config =
         egl_manager_ ? GetOpenGLRendererConfig() : GetSoftwareRendererConfig();
   }
  
   auto result = embedder_api_.Run(FLUTTER_ENGINE_VERSION, &renderer_config,
                                   &args, this, &engine_);
   if (result != kSuccess || engine_ == nullptr) {
     FML_LOG(ERROR) << "Failed to start Flutter engine: error " << result;
     return false;
   }
  
   display_manager_->UpdateDisplays();
  
   SendSystemLocales();
  
   settings_plugin_->StartWatching();
   settings_plugin_->SendSettings();
  
   InitializeKeyboard();
  
   return true;
 }

References flutter::FlutterWindowsView::accessibility_bridge(), action, HandlePlatformMessage(), OnPreEngineRestart(), OnViewFocusChangeRequest(), OnVsync(), RunOnSeparateThread, user_data, view(), and flutter::WindowsPlatformThreadPrioritySetter().

◆ running()

virtual bool flutter::FlutterWindowsEngine::running ( ) const

inlinevirtual

Definition at line 125 of file flutter_windows_engine.h.

125 { return engine_ != nullptr; }

Referenced by FlutterDesktopEngineDestroy(), and flutter::HostWindow::InitializeFlutterView().

◆ ScheduleFrame()

void flutter::FlutterWindowsEngine::ScheduleFrame ( )

Definition at line 863 of file flutter_windows_engine.cc.

                                          {
   embedder_api_.ScheduleFrame(engine_);
 }

Referenced by flutter::FlutterWindowsView::ForceRedraw().

◆ semantics_enabled()

bool flutter::FlutterWindowsEngine::semantics_enabled ( ) const

inline

Definition at line 261 of file flutter_windows_engine.h.

261 { return semantics_enabled_; }

Referenced by flutter::AccessibilityPlugin::Announce().

◆ SendKeyEvent()

void flutter::FlutterWindowsEngine::SendKeyEvent	(	const FlutterKeyEvent &	event,
		FlutterKeyEventCallback	callback,
		void *	user_data
	)

Definition at line 789 of file flutter_windows_engine.cc.

                                                          {
   if (engine_) {
     embedder_api_.SendKeyEvent(engine_, &event, callback, user_data);
   }
 }

◆ SendPlatformMessage()

bool flutter::FlutterWindowsEngine::SendPlatformMessage	(	const char *	channel,
		const uint8_t *	message,
		const size_t	message_size,
		const FlutterDesktopBinaryReply	reply,
		void *	user_data
	)

Definition at line 804 of file flutter_windows_engine.cc.

                      {
   FlutterPlatformMessageResponseHandle* response_handle = nullptr;
   if (reply != nullptr && user_data != nullptr) {
     FlutterEngineResult result =
         embedder_api_.PlatformMessageCreateResponseHandle(
             engine_, reply, user_data, &response_handle);
     if (result != kSuccess) {
       FML_LOG(ERROR) << "Failed to create response handle";
       return false;
     }
   }
  
   FlutterPlatformMessage platform_message = {
       sizeof(FlutterPlatformMessage),
       channel,
       message,
       message_size,
       response_handle,
   };
  
   FlutterEngineResult message_result =
       embedder_api_.SendPlatformMessage(engine_, &platform_message);
   if (response_handle != nullptr) {
     embedder_api_.PlatformMessageReleaseResponseHandle(engine_,
                                                        response_handle);
   }
   return message_result == kSuccess;
 }

References user_data.

Referenced by FlutterDesktopMessengerSendWithReply().

◆ SendPlatformMessageResponse()

void flutter::FlutterWindowsEngine::SendPlatformMessageResponse	(	const FlutterDesktopMessageResponseHandle *	handle,
		const uint8_t *	data,
		size_t	data_length
	)

Definition at line 838 of file flutter_windows_engine.cc.

                         {
   embedder_api_.SendPlatformMessageResponse(engine_, handle, data, data_length);
 }

Referenced by FlutterDesktopMessengerSendResponse().

◆ SendPointerEvent()

void flutter::FlutterWindowsEngine::SendPointerEvent ( const FlutterPointerEvent & event )

Definition at line 783 of file flutter_windows_engine.cc.

                                                                             {
   if (engine_) {
     embedder_api_.SendPointerEvent(engine_, &event, 1);
   }
 }

◆ SendViewFocusEvent()

void flutter::FlutterWindowsEngine::SendViewFocusEvent ( const FlutterViewFocusEvent & event )

Definition at line 797 of file flutter_windows_engine.cc.

                                         {
   if (engine_) {
     embedder_api_.SendViewFocusEvent(engine_, &event);
   }
 }

◆ SendWindowMetricsEvent()

void flutter::FlutterWindowsEngine::SendWindowMetricsEvent ( const FlutterWindowMetricsEvent & event )

Definition at line 776 of file flutter_windows_engine.cc.

                                             {
   if (engine_) {
     embedder_api_.SendWindowMetricsEvent(engine_, &event);
   }
 }

Referenced by flutter::FlutterWindowsView::SendInitialBounds(), and flutter::FlutterWindowsView::SetSizedToContent().

◆ SetFlutterCursor()

void flutter::FlutterWindowsEngine::SetFlutterCursor ( HCURSOR cursor ) const

Definition at line 1144 of file flutter_windows_engine.cc.

                                                                 {
   windows_proc_table_->SetCursor(cursor);
 }

◆ SetNextFrameCallback()

void flutter::FlutterWindowsEngine::SetNextFrameCallback ( fml::closure callback )

Definition at line 867 of file flutter_windows_engine.cc.

                                                                    {
   next_frame_callback_ = std::move(callback);
  
   embedder_api_.SetNextFrameCallback(
       engine_,
       [](void* user_data) {
         // Embedder callback runs on raster thread. Switch back to platform
         // thread.
         FlutterWindowsEngine* self =
             static_cast<FlutterWindowsEngine*>(user_data);
  
         self->task_runner_->PostTask(std::move(self->next_frame_callback_));
       },
       this);
 }

Referenced by FlutterDesktopEngineSetNextFrameCallback().

◆ SetRootIsolateCreateCallback()

void flutter::FlutterWindowsEngine::SetRootIsolateCreateCallback ( const fml::closure & callback )

inline

Definition at line 286 of file flutter_windows_engine.h.

                                                                 {
     root_isolate_create_callback_ = callback;
   }

References callback.

◆ SetSwitches()

void flutter::FlutterWindowsEngine::SetSwitches ( const std::vector< std::string > & switches )

Definition at line 276 of file flutter_windows_engine.cc.

                                           {
   project_->SetSwitches(switches);
 }

References SetSwitches().

Referenced by SetSwitches().

◆ Stop()

bool flutter::FlutterWindowsEngine::Stop ( )

virtual

Definition at line 558 of file flutter_windows_engine.cc.

                                 {
   if (engine_) {
     window_manager_->OnEngineShutdown();
     for (const auto& [callback, registrar] :
          plugin_registrar_destruction_callbacks_) {
       callback(registrar);
     }
     FlutterEngineResult result = embedder_api_.Shutdown(engine_);
     engine_ = nullptr;
     return (result == kSuccess);
   }
   return false;
 }

Referenced by FlutterDesktopEngineDestroy().

◆ task_runner()

TaskRunner* flutter::FlutterWindowsEngine::task_runner ( )

inline

Definition at line 173 of file flutter_windows_engine.h.

173 { return task_runner_.get(); }

Referenced by FlutterDesktopEngineIsPlatformThread(), FlutterDesktopEnginePostPlatformThreadTask(), flutter::FlutterWindowsTextureRegistrar::MarkTextureFrameAvailable(), flutter::FlutterWindowsView::OnFramePresented(), flutter::FlutterWindowsView::OnWindowSizeChanged(), and flutter::FlutterWindowsTextureRegistrar::UnregisterTexture().

◆ text_input_plugin()

TextInputPlugin* flutter::FlutterWindowsEngine::text_input_plugin ( )

inline

Definition at line 206 of file flutter_windows_engine.h.

206 { return text_input_plugin_.get(); }

◆ texture_registrar()

FlutterWindowsTextureRegistrar* flutter::FlutterWindowsEngine::texture_registrar ( )

inline

Definition at line 177 of file flutter_windows_engine.h.

                                                       {
     return texture_registrar_.get();
   }

Referenced by FlutterDesktopRegistrarGetTextureRegistrar().

◆ UnregisterExternalTexture()

bool flutter::FlutterWindowsEngine::UnregisterExternalTexture ( int64_t texture_id )

Definition at line 996 of file flutter_windows_engine.cc.

                                                                        {
   return (embedder_api_.UnregisterExternalTexture(engine_, texture_id) ==
           kSuccess);
 }

◆ UpdateAccessibilityFeatures()

void flutter::FlutterWindowsEngine::UpdateAccessibilityFeatures ( )

Definition at line 1074 of file flutter_windows_engine.cc.

                                                        {
   UpdateHighContrastMode();
 }

Referenced by flutter::HostWindow::InitializeFlutterView(), and flutter::testing::TEST_F().

◆ UpdateDisplay()

void flutter::FlutterWindowsEngine::UpdateDisplay ( const std::vector< FlutterEngineDisplay > & displays )

Definition at line 767 of file flutter_windows_engine.cc.

                                                      {
   if (engine_) {
     embedder_api_.NotifyDisplayUpdate(engine_,
                                       kFlutterEngineDisplaysUpdateTypeStartup,
                                       displays.data(), displays.size());
   }
 }

Referenced by flutter::DisplayManagerWin32::UpdateDisplays().

◆ UpdateFlutterCursor()

void flutter::FlutterWindowsEngine::UpdateFlutterCursor ( const std::string & cursor_name ) const

Definition at line 1139 of file flutter_windows_engine.cc.

                                         {
   SetFlutterCursor(GetCursorByName(cursor_name));
 }

◆ UpdateHighContrastMode()

void flutter::FlutterWindowsEngine::UpdateHighContrastMode ( )

Definition at line 1078 of file flutter_windows_engine.cc.

                                                   {
   high_contrast_enabled_ = windows_proc_table_->GetHighContrastEnabled();
  
   SendAccessibilityFeatures();
   settings_plugin_->UpdateHighContrastMode(high_contrast_enabled_);
 }

Referenced by flutter::FlutterWindowsView::OnHighContrastChanged().

◆ UpdateSemanticsEnabled()

void flutter::FlutterWindowsEngine::UpdateSemanticsEnabled ( bool enabled )

Definition at line 1043 of file flutter_windows_engine.cc.

                                                               {
   if (engine_ && semantics_enabled_ != enabled) {
     std::shared_lock read_lock(views_mutex_);
  
     semantics_enabled_ = enabled;
     embedder_api_.UpdateSemanticsEnabled(engine_, enabled);
     for (auto iterator = views_.begin(); iterator != views_.end(); iterator++) {
       iterator->second->UpdateSemanticsEnabled(enabled);
     }
   }
 }

Referenced by flutter::FlutterWindowsView::OnUpdateSemanticsEnabled(), and flutter::testing::TEST_F().

◆ view()

FlutterWindowsView * flutter::FlutterWindowsEngine::view ( FlutterViewId view_id ) const

Definition at line 745 of file flutter_windows_engine.cc.

                                                                           {
   std::shared_lock read_lock(views_mutex_);
  
   auto iterator = views_.find(view_id);
   if (iterator == views_.end()) {
     return nullptr;
   }
  
   return iterator->second;
 }

Referenced by flutter::AccessibilityPlugin::Announce(), FlutterDesktopPluginRegistrarGetView(), FlutterDesktopPluginRegistrarGetViewById(), InternalFlutterWindows_WindowManager_GetTopLevelWindowHandle(), and Run().

◆ window_manager()

WindowManager* flutter::FlutterWindowsEngine::window_manager ( )

inline

Definition at line 335 of file flutter_windows_engine.h.

335 { return window_manager_.get(); }

Referenced by InternalFlutterWindows_WindowManager_CreateDialogWindow(), InternalFlutterWindows_WindowManager_CreatePopupWindow(), InternalFlutterWindows_WindowManager_CreateRegularWindow(), InternalFlutterWindows_WindowManager_CreateTooltipWindow(), and InternalFlutterWindows_WindowManager_Initialize().

◆ window_proc_delegate_manager()

WindowProcDelegateManager* flutter::FlutterWindowsEngine::window_proc_delegate_manager ( )

inline

Definition at line 185 of file flutter_windows_engine.h.

                                                             {
     return window_proc_delegate_manager_.get();
   }

Referenced by FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate(), FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate(), and flutter::HostWindowDialog::HandleMessage().

◆ windows_proc_table()

std::shared_ptr<WindowsProcTable> flutter::FlutterWindowsEngine::windows_proc_table ( )

inline

Definition at line 324 of file flutter_windows_engine.h.

                                                        {
     return windows_proc_table_;
   }

Referenced by flutter::HostWindowSized::ApplyContentSize(), CreateViewController(), and flutter::HostWindow::InitializeFlutterView().

Friends And Related Function Documentation

◆ EngineModifier

friend class EngineModifier

friend

Definition at line 373 of file flutter_windows_engine.h.

The documentation for this class was generated from the following files:

shell/platform/windows/flutter_windows_engine.h
shell/platform/windows/flutter_windows_engine.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ FlutterWindowsEngine()

◆ ~FlutterWindowsEngine()

Member Function Documentation

◆ AddPluginRegistrarDestructionCallback()

◆ CreateKeyboardKeyHandler()

◆ CreateTextInputPlugin()

◆ CreateView()

◆ DispatchSemanticsAction()

◆ display_manager()

◆ egl_manager()

◆ GetEngineForId()

◆ GetExecutableName()

◆ GetRegistrar()

◆ GetViewFromTopLevelWindow()

◆ HandlePlatformMessage()

◆ high_contrast_enabled()

◆ iaccessibleex_enabled()

◆ keyboard_key_handler()

◆ lifecycle_manager()

◆ MarkExternalTextureFrameAvailable()

◆ message_dispatcher()

◆ messenger()

◆ messenger_wrapper()

◆ OnChannelUpdate()

◆ OnDwmCompositionChanged()

◆ OnPreEngineRestart()

◆ OnQuit()

◆ OnViewFocusChangeRequest()

◆ OnVsync()

◆ OnWindowStateEvent()

◆ PostRasterThreadTask()

◆ ProcessExternalWindowMessage()

◆ RegisterExternalTexture()

◆ ReloadSystemFonts()

◆ RemoveView()

◆ RequestApplicationQuit()

◆ Run() [1/2]

◆ Run() [2/2]

◆ running()

◆ ScheduleFrame()

◆ semantics_enabled()

◆ SendKeyEvent()

◆ SendPlatformMessage()

◆ SendPlatformMessageResponse()

◆ SendPointerEvent()

◆ SendViewFocusEvent()

◆ SendWindowMetricsEvent()

◆ SetFlutterCursor()

◆ SetNextFrameCallback()

◆ SetRootIsolateCreateCallback()

◆ SetSwitches()

◆ Stop()

◆ task_runner()

◆ text_input_plugin()

◆ texture_registrar()

◆ UnregisterExternalTexture()

◆ UpdateAccessibilityFeatures()

◆ UpdateDisplay()

◆ UpdateFlutterCursor()

◆ UpdateHighContrastMode()

◆ UpdateSemanticsEnabled()

◆ view()

◆ window_manager()

◆ window_proc_delegate_manager()

◆ windows_proc_table()

Friends And Related Function Documentation

◆ EngineModifier