flutter::FlutterWindowsEngine Class Reference

#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)
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 ()
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 (uint64_t id, FlutterSemanticsAction action, fml::MallocMapping data)
void	UpdateSemanticsEnabled (bool enabled)
bool	semantics_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 ()

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 90 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 149 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();
  enable_impeller_ = std::find(switches.begin(), switches.end(),
                               "--enable-impeller=true") != switches.end();
 
  egl_manager_ = egl::Manager::Create(
      static_cast<egl::GpuPreference>(project_->gpu_preference()));
  window_proc_delegate_manager_ = std::make_unique<WindowProcDelegateManager>();
  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->lifecycle_manager_);
        return that->lifecycle_manager_->WindowProc(hwnd, msg, wpar, lpar,
                                                    result);
      },
      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);
  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 231 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 692 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 844 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 862 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

)

Definition at line 515 of file flutter_windows_engine.cc.

                                                {
  auto view_id = next_view_id_;
  auto view = std::make_unique<FlutterWindowsView>(
      view_id, this, std::move(window), windows_proc_table_);
 
  view->CreateRenderSurface();
 
  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().

DispatchSemanticsAction()

bool flutter::FlutterWindowsEngine::DispatchSemanticsAction	(	uint64_t	id,
		FlutterSemanticsAction	action,
		fml::MallocMapping	data
	)

Definition at line 903 of file flutter_windows_engine.cc.

                           {
  return (embedder_api_.DispatchSemanticsAction(engine_, target, action,
                                                data.GetMapping(),
                                                data.GetSize()) == kSuccess);
}

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

egl_manager()

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

inline

Definition at line 171 of file flutter_windows_engine.h.

{ return egl_manager_.get(); }

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

GetEngineForId()

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

static

Definition at line 236 of file flutter_windows_engine.cc.

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

Referenced by FlutterDesktopEngineForId().

GetExecutableName()

std::string flutter::FlutterWindowsEngine::GetExecutableName

(

)

const

Definition at line 929 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 688 of file flutter_windows_engine.cc.

                                                                    {
  return plugin_registrar_.get();
}

Referenced by FlutterDesktopEngineGetPluginRegistrar().

HandlePlatformMessage()

void flutter::FlutterWindowsEngine::HandlePlatformMessage

(

const FlutterPlatformMessage *

engine_message

)

Definition at line 767 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 257 of file flutter_windows_engine.h.

{ return high_contrast_enabled_; }

keyboard_key_handler()

KeyboardHandlerBase* flutter::FlutterWindowsEngine::keyboard_key_handler ( )

inline

Definition at line 191 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 302 of file flutter_windows_engine.h.

                                               {
    return lifecycle_manager_.get();
  }

MarkExternalTextureFrameAvailable()

bool flutter::FlutterWindowsEngine::MarkExternalTextureFrameAvailable

(

int64_t

texture_id

)

Definition at line 877 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 157 of file flutter_windows_engine.h.

                                                  {
    return message_dispatcher_.get();
  }

Referenced by FlutterDesktopMessengerSetCallback().

messenger()

FlutterDesktopMessengerRef flutter::FlutterWindowsEngine::messenger ( )

inline

Definition at line 155 of file flutter_windows_engine.h.

{ return messenger_->ToRef(); }

Referenced by FlutterDesktopEngineGetMessenger(), and FlutterDesktopPluginRegistrarGetMessenger().

messenger_wrapper()

BinaryMessenger* flutter::FlutterWindowsEngine::messenger_wrapper ( )

inline

Definition at line 163 of file flutter_windows_engine.h.

{ return messenger_wrapper_.get(); }

OnChannelUpdate()

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

protectedvirtual

Definition at line 1005 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 980 of file flutter_windows_engine.cc.

                                                   {
  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 924 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 973 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 1013 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 648 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 988 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 883 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 993 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 867 of file flutter_windows_engine.cc.

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

ReloadSystemFonts()

void flutter::FlutterWindowsEngine::ReloadSystemFonts

(

)

Definition at line 781 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 586 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());
    views_.erase(view_id);
  }
}

References flutter::kImplicitViewId.

RequestApplicationQuit()

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

Definition at line 966 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 245 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 249 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 = project_->assets_path().u8string();
  std::string icu_path_string = project_->icu_path().u8string();
  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();
  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::RunOnPlatformThread) {
    FML_LOG(WARNING)
        << "Running with merged platform and UI thread. Experimental.";
    custom_task_runners.ui_task_runner = &platform_task_runner;
  }
 
  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);
 
    // TODO(loicsharma): Remove implicit view assumption.
    // https://github.com/flutter/flutter/issues/142845
    auto view = host->view(kImplicitViewId);
    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;
  }
 
  // Configure device frame rate displayed via devtools.
  FlutterEngineDisplay display = {};
  display.struct_size = sizeof(FlutterEngineDisplay);
  display.display_id = 0;
  display.single_display = true;
  display.refresh_rate =
      1.0 / (static_cast<double>(FrameInterval().count()) / 1000000000.0);
 
  std::vector<FlutterEngineDisplay> displays = {display};
  embedder_api_.NotifyDisplayUpdate(engine_,
                                    kFlutterEngineDisplaysUpdateTypeStartup,
                                    displays.data(), displays.size());
 
  SendSystemLocales();
  SetLifecycleState(flutter::AppLifecycleState::kResumed);
 
  settings_plugin_->StartWatching();
  settings_plugin_->SendSettings();
 
  InitializeKeyboard();
 
  return true;
}

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

running()

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

inlinevirtual

Definition at line 123 of file flutter_windows_engine.h.

{ return engine_ != nullptr; }

Referenced by FlutterDesktopEngineDestroy().

ScheduleFrame()

void flutter::FlutterWindowsEngine::ScheduleFrame

(

)

Definition at line 785 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 248 of file flutter_windows_engine.h.

{ return semantics_enabled_; }

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

SendKeyEvent()

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

Definition at line 711 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 726 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 760 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 705 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 719 of file flutter_windows_engine.cc.

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

SendWindowMetricsEvent()

void flutter::FlutterWindowsEngine::SendWindowMetricsEvent

(

const FlutterWindowMetricsEvent &

event

)

Definition at line 698 of file flutter_windows_engine.cc.

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

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

SetNextFrameCallback()

void flutter::FlutterWindowsEngine::SetNextFrameCallback

(

fml::closure

callback

)

Definition at line 789 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 268 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 240 of file flutter_windows_engine.cc.

                                          {
  project_->SetSwitches(switches);
}

References SetSwitches().

Referenced by SetSwitches().

Stop()

bool flutter::FlutterWindowsEngine::Stop ( )

virtual

Definition at line 502 of file flutter_windows_engine.cc.

                                {
  if (engine_) {
    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 161 of file flutter_windows_engine.h.

{ return task_runner_.get(); }

Referenced by 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 194 of file flutter_windows_engine.h.

{ return text_input_plugin_.get(); }

texture_registrar()

FlutterWindowsTextureRegistrar* flutter::FlutterWindowsEngine::texture_registrar ( )

inline

Definition at line 165 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 872 of file flutter_windows_engine.cc.

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

UpdateAccessibilityFeatures()

void flutter::FlutterWindowsEngine::UpdateAccessibilityFeatures

(

)

Definition at line 943 of file flutter_windows_engine.cc.

                                                       {
  UpdateHighContrastMode();
}

Referenced by flutter::testing::TEST_F().

UpdateHighContrastMode()

void flutter::FlutterWindowsEngine::UpdateHighContrastMode

(

)

Definition at line 947 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 912 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 676 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(), flutter::PlatformHandler::GetHasStrings(), flutter::PlatformHandler::GetPlainText(), Run(), and flutter::PlatformHandler::SetPlainText().

window_proc_delegate_manager()

WindowProcDelegateManager* flutter::FlutterWindowsEngine::window_proc_delegate_manager ( )

inline

Definition at line 173 of file flutter_windows_engine.h.

                                                            {
    return window_proc_delegate_manager_.get();
  }

Referenced by FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate(), and FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate().

windows_proc_table()

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

inline

Definition at line 306 of file flutter_windows_engine.h.

                                                       {
    return windows_proc_table_;
  }

Referenced by CreateViewController().

Friends And Related Function Documentation

EngineModifier

friend class EngineModifier

friend

Definition at line 342 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