Flutter Windows Embedder
flutter_windows.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
7 #include <io.h>
8 
9 #include <algorithm>
10 #include <chrono>
11 #include <cstdlib>
12 #include <filesystem>
13 #include <memory>
14 #include <vector>
15 
16 #include "flutter/fml/macros.h"
20 #include "flutter/shell/platform/embedder/embedder.h"
29 
30 static_assert(FLUTTER_ENGINE_VERSION == 1, "");
31 
32 // Returns the engine corresponding to the given opaque API handle.
35  return reinterpret_cast<flutter::FlutterWindowsEngine*>(ref);
36 }
37 
38 // Returns the opaque API handle for the given engine instance.
41  return reinterpret_cast<FlutterDesktopEngineRef>(engine);
42 }
43 
46  return reinterpret_cast<flutter::FlutterWindowsViewController*>(ref);
47 }
48 
50  flutter::FlutterWindowsViewController* view_controller) {
51  return reinterpret_cast<FlutterDesktopViewControllerRef>(view_controller);
52 }
53 
54 // Returns the view corresponding to the given opaque API handle.
56  return reinterpret_cast<flutter::FlutterWindowsView*>(ref);
57 }
58 
59 // Returns the opaque API handle for the given view instance.
61  return reinterpret_cast<FlutterDesktopViewRef>(view);
62 }
63 
64 // Returns the texture registrar corresponding to the given opaque API handle.
67  return reinterpret_cast<flutter::FlutterWindowsTextureRegistrar*>(ref);
68 }
69 
70 // Returns the opaque API handle for the given texture registrar instance.
73  return reinterpret_cast<FlutterDesktopTextureRegistrarRef>(registrar);
74 }
75 
76 // Creates a view controller that might own the engine.
77 //
78 // If `owns_engine` is true, then the returned `FlutterDesktopViewControllerRef`
79 // owns `engine_ref` and will deallocate `engine_ref` upon its own destruction.
81  FlutterDesktopEngineRef engine_ref,
82  int width,
83  int height,
84  bool owns_engine) {
85  flutter::FlutterWindowsEngine* engine_ptr = EngineFromHandle(engine_ref);
86  std::unique_ptr<flutter::WindowBindingHandler> window_wrapper =
87  std::make_unique<flutter::FlutterWindow>(
88  width, height, engine_ptr->display_manager(),
89  engine_ptr->windows_proc_table());
90 
91  std::unique_ptr<flutter::FlutterWindowsEngine> engine;
92  if (owns_engine) {
93  engine = std::unique_ptr<flutter::FlutterWindowsEngine>(engine_ptr);
94  }
95 
96  std::unique_ptr<flutter::FlutterWindowsView> view = engine_ptr->CreateView(
97  std::move(window_wrapper), false, flutter::BoxConstraints(),
98  /*allow_implicit_view=*/true);
99  if (!view) {
100  return nullptr;
101  }
102 
103  auto controller = std::make_unique<flutter::FlutterWindowsViewController>(
104  std::move(engine), std::move(view));
105 
106  // Launch the engine if it is not running already.
107  if (!controller->engine()->running()) {
108  if (!controller->engine()->Run()) {
109  return nullptr;
110  }
111  }
112 
113  // Must happen after engine is running.
114  controller->view()->SendInitialBounds();
115 
116  // The Windows embedder listens to accessibility updates using the
117  // view's HWND. The embedder's accessibility features may be stale if
118  // the app was in headless mode.
119  controller->engine()->UpdateAccessibilityFeatures();
120 
121  return HandleForViewController(controller.release());
122 }
123 
125  int width,
126  int height,
127  FlutterDesktopEngineRef engine) {
128  return CreateViewController(engine, width, height, /*owns_engine=*/true);
129 }
130 
133  const FlutterDesktopViewControllerProperties* properties) {
134  return CreateViewController(engine, properties->width, properties->height,
135  /*owns_engine=*/false);
136 }
137 
139  auto controller = ViewControllerFromHandle(ref);
140  controller->Destroy();
141  delete controller;
142 }
143 
146  auto controller = ViewControllerFromHandle(ref);
147  return static_cast<FlutterDesktopViewId>(controller->view()->view_id());
148 }
149 
152  auto controller = ViewControllerFromHandle(ref);
153  return HandleForEngine(controller->engine());
154 }
155 
158  auto controller = ViewControllerFromHandle(ref);
159  return HandleForView(controller->view());
160 }
161 
164  auto controller = ViewControllerFromHandle(ref);
165  controller->view()->ForceRedraw();
166 }
167 
170  HWND hwnd,
171  UINT message,
172  WPARAM wparam,
173  LPARAM lparam,
174  LRESULT* result) {
175  auto controller = ViewControllerFromHandle(ref);
176  std::optional<LRESULT> delegate_result =
177  controller->engine()
178  ->window_proc_delegate_manager()
179  ->OnTopLevelWindowProc(hwnd, message, wparam, lparam);
180  if (delegate_result) {
181  *result = *delegate_result;
182  }
183  return delegate_result.has_value();
184 }
185 
187  const FlutterDesktopEngineProperties* engine_properties) {
188  flutter::FlutterProjectBundle project(*engine_properties);
189  auto engine = std::make_unique<flutter::FlutterWindowsEngine>(project);
190  return HandleForEngine(engine.release());
191 }
192 
194  flutter::FlutterWindowsEngine* engine = EngineFromHandle(engine_ref);
195  bool result = true;
196  if (engine->running()) {
197  result = engine->Stop();
198  }
199  delete engine;
200  return result;
201 }
202 
204 FlutterDesktopEngineForId(int64_t engine_id) {
205  return HandleForEngine(
207 }
208 
210  const char* entry_point) {
211  std::string_view entry_point_view{""};
212  if (entry_point != nullptr) {
213  entry_point_view = entry_point;
214  }
215 
216  return EngineFromHandle(engine)->Run(entry_point_view);
217 }
218 
220  return std::chrono::nanoseconds::max().count();
221 }
222 
225 }
226 
229  const char* plugin_name) {
230  // Currently, one registrar acts as the registrar for all plugins, so the
231  // name is ignored. It is part of the API to reduce churn in the future when
232  // aligning more closely with the Flutter registrar system.
233 
234  return EngineFromHandle(engine)->GetRegistrar();
235 }
236 
238  FlutterDesktopEngineRef engine) {
239  return EngineFromHandle(engine)->messenger();
240 }
241 
243  FlutterDesktopEngineRef engine) {
245  EngineFromHandle(engine)->texture_registrar());
246 }
247 
250  void* user_data) {
252  [callback, user_data]() { callback(user_data); });
253 }
254 
257 }
258 
261  VoidCallback on_cancel,
262  void* user_data) {
263  FML_DCHECK(callback) << "Callback must not be null";
264  struct Context {
265  Context(VoidCallback callback, VoidCallback on_cancel, void* user_data)
266  : callback(callback), on_cancel(on_cancel), user_data(user_data) {}
267 
268  ~Context() {
269  if (!invoked && on_cancel) {
270  on_cancel(user_data);
271  }
272  }
273 
275  VoidCallback on_cancel;
276  void* user_data;
277  bool invoked = false;
278 
279  FML_DISALLOW_COPY_AND_ASSIGN(Context);
280  };
281 
282  auto context = std::make_shared<Context>(callback, on_cancel, user_data);
283  EngineFromHandle(engine)->task_runner()->PostTask([context]() {
284  context->invoked = true;
285  context->callback(context->user_data);
286  });
287 }
288 
290  return ViewFromHandle(view)->GetWindowHandle();
291 }
292 
294  auto engine = ViewFromHandle(view)->GetEngine();
295  IDXGIAdapter* adapter;
297  &adapter)) {
298  return nullptr;
299  }
300  return adapter;
301 }
302 
304  IDXGIAdapter** adapter_out) {
305  auto egl_manager = EngineFromHandle(engine)->egl_manager();
306  if (egl_manager) {
307  Microsoft::WRL::ComPtr<ID3D11Device> d3d_device;
308  Microsoft::WRL::ComPtr<IDXGIDevice> dxgi_device;
309  if (egl_manager->GetDevice(d3d_device.GetAddressOf()) &&
310  SUCCEEDED(d3d_device.As(&dxgi_device))) {
311  if (SUCCEEDED(dxgi_device->GetAdapter(adapter_out))) {
312  return true;
313  }
314  }
315  }
316  return false;
317 }
318 
321  HWND hwnd,
322  UINT message,
323  WPARAM wparam,
324  LPARAM lparam,
325  LRESULT* result) {
326  std::optional<LRESULT> lresult =
328  wparam, lparam);
329  if (result && lresult.has_value()) {
330  *result = lresult.value();
331  }
332  return lresult.has_value();
333 }
334 
337  const char* view_type_name,
338  FlutterPlatformViewTypeEntry view_type) {
339  // TODO(schectman): forward to platform view manager.
340  // https://github.com/flutter/flutter/issues/143375
341 }
342 
345  return HandleForView(registrar->engine->view(flutter::kImplicitViewId));
346 }
347 
350  FlutterDesktopViewId view_id) {
351  return HandleForView(registrar->engine->view(view_id));
352 }
353 
357  void* user_data) {
360 }
361 
367 }
368 
371  IDXGIAdapter** adapter_out) {
373  HandleForEngine(registrar->engine), adapter_out);
374 }
375 
377  return flutter::GetDpiForHWND(hwnd);
378 }
379 
380 UINT FlutterDesktopGetDpiForMonitor(HMONITOR monitor) {
381  return flutter::GetDpiForMonitor(monitor);
382 }
383 
385  FILE* unused;
386  if (freopen_s(&unused, "CONOUT$", "w", stdout)) {
387  _dup2(_fileno(stdout), 1);
388  }
389  if (freopen_s(&unused, "CONOUT$", "w", stderr)) {
390  _dup2(_fileno(stdout), 2);
391  }
392  std::ios::sync_with_stdio();
393 }
394 
395 // Implementations of common/ API methods.
396 
399  return registrar->engine->messenger();
400 }
401 
405  registrar->engine->AddPluginRegistrarDestructionCallback(callback, registrar);
406 }
407 
409  const char* channel,
410  const uint8_t* message,
411  const size_t message_size,
412  const FlutterDesktopBinaryReply reply,
413  void* user_data) {
414  FML_DCHECK(FlutterDesktopMessengerIsAvailable(messenger))
415  << "Messenger must reference a running engine to send a message";
416 
418  ->GetEngine()
419  ->SendPlatformMessage(channel, message, message_size, reply, user_data);
420 }
421 
423  const char* channel,
424  const uint8_t* message,
425  const size_t message_size) {
426  return FlutterDesktopMessengerSendWithReply(messenger, channel, message,
427  message_size, nullptr, nullptr);
428 }
429 
431  FlutterDesktopMessengerRef messenger,
433  const uint8_t* data,
434  size_t data_length) {
435  FML_DCHECK(FlutterDesktopMessengerIsAvailable(messenger))
436  << "Messenger must reference a running engine to send a response";
437 
439  ->GetEngine()
440  ->SendPlatformMessageResponse(handle, data, data_length);
441 }
442 
444  const char* channel,
446  void* user_data) {
447  FML_DCHECK(FlutterDesktopMessengerIsAvailable(messenger))
448  << "Messenger must reference a running engine to set a callback";
449 
451  ->GetEngine()
454 }
455 
457  FlutterDesktopMessengerRef messenger) {
459  ->AddRef()
460  ->ToRef();
461 }
462 
465 }
466 
469  nullptr;
470 }
471 
473  FlutterDesktopMessengerRef messenger) {
475  return messenger;
476 }
477 
480 }
481 
484  return HandleForTextureRegistrar(registrar->engine->texture_registrar());
485 }
486 
488  FlutterDesktopTextureRegistrarRef texture_registrar,
489  const FlutterDesktopTextureInfo* texture_info) {
490  return TextureRegistrarFromHandle(texture_registrar)
491  ->RegisterTexture(texture_info);
492 }
493 
495  FlutterDesktopTextureRegistrarRef texture_registrar,
496  int64_t texture_id,
497  void (*callback)(void* user_data),
498  void* user_data) {
499  auto registrar = TextureRegistrarFromHandle(texture_registrar);
500  if (callback) {
501  registrar->UnregisterTexture(
503  return;
504  }
505  registrar->UnregisterTexture(texture_id);
506 }
507 
509  FlutterDesktopTextureRegistrarRef texture_registrar,
510  int64_t texture_id) {
511  return TextureRegistrarFromHandle(texture_registrar)
513 }
flutter::FlutterWindowsEngine * GetEngine() const
Getter for the engine field.
FlutterDesktopMessengerRef ToRef()
Convert to FlutterDesktopMessengerRef.
static FlutterDesktopMessenger * FromRef(FlutterDesktopMessengerRef ref)
Convert from FlutterDesktopMessengerRef.
FlutterWindowsTextureRegistrar * texture_registrar()
std::shared_ptr< WindowsProcTable > windows_proc_table()
FlutterDesktopMessengerRef messenger()
WindowProcDelegateManager * window_proc_delegate_manager()
FlutterWindowsView * view(FlutterViewId view_id) const
std::shared_ptr< DisplayManagerWin32 > display_manager()
bool SendPlatformMessage(const char *channel, const uint8_t *message, const size_t message_size, const FlutterDesktopBinaryReply reply, void *user_data)
std::optional< LRESULT > ProcessExternalWindowMessage(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
void AddPluginRegistrarDestructionCallback(FlutterDesktopOnPluginRegistrarDestroyed callback, FlutterDesktopPluginRegistrarRef registrar)
void SendPlatformMessageResponse(const FlutterDesktopMessageResponseHandle *handle, const uint8_t *data, size_t data_length)
static FlutterWindowsEngine * GetEngineForId(int64_t engine_id)
IncomingMessageDispatcher * message_dispatcher()
std::unique_ptr< FlutterWindowsView > CreateView(std::unique_ptr< WindowBindingHandler > window, bool is_sized_to_content, const BoxConstraints &box_constraints, bool allow_implicit_view, FlutterWindowsViewSizingDelegate *sizing_delegate=nullptr)
void SetNextFrameCallback(fml::closure callback)
FlutterDesktopPluginRegistrarRef GetRegistrar()
int64_t RegisterTexture(const FlutterDesktopTextureInfo *texture_info)
Controls a view that displays Flutter content.
FlutterWindowsEngine * GetEngine() const
virtual HWND GetWindowHandle() const
void SetMessageCallback(const std::string &channel, FlutterDesktopMessageCallback callback, void *user_data)
virtual bool RunsTasksOnCurrentThread() const
Definition: task_runner.cc:117
void PostTask(TaskClosure task)
Definition: task_runner.cc:89
void UnregisterTopLevelWindowProcDelegate(FlutterDesktopWindowProcCallback callback)
void RegisterTopLevelWindowProcDelegate(FlutterDesktopWindowProcCallback callback, void *user_data)
uint32_t texture_id
#define FLUTTER_EXPORT
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
struct FlutterDesktopMessenger * FlutterDesktopMessengerRef
void(* FlutterDesktopMessageCallback)(FlutterDesktopMessengerRef, const FlutterDesktopMessage *, void *)
struct _FlutterPlatformMessageResponseHandle FlutterDesktopMessageResponseHandle
void(* FlutterDesktopOnPluginRegistrarDestroyed)(FlutterDesktopPluginRegistrarRef)
struct FlutterDesktopTextureRegistrar * FlutterDesktopTextureRegistrarRef
static flutter::FlutterWindowsTextureRegistrar * TextureRegistrarFromHandle(FlutterDesktopTextureRegistrarRef ref)
void FlutterDesktopMessengerSetCallback(FlutterDesktopMessengerRef messenger, const char *channel, FlutterDesktopMessageCallback callback, void *user_data)
UINT FlutterDesktopGetDpiForHWND(HWND hwnd)
void FlutterDesktopViewControllerForceRedraw(FlutterDesktopViewControllerRef ref)
static FlutterDesktopTextureRegistrarRef HandleForTextureRegistrar(flutter::FlutterWindowsTextureRegistrar *registrar)
bool FlutterDesktopEngineGetGraphicsAdapter(FlutterDesktopEngineRef engine, IDXGIAdapter **adapter_out)
FlutterDesktopEngineRef FlutterDesktopEngineCreate(const FlutterDesktopEngineProperties *engine_properties)
void FlutterDesktopEngineReloadSystemFonts(FlutterDesktopEngineRef engine)
bool FlutterDesktopEngineProcessExternalWindowMessage(FlutterDesktopEngineRef engine, HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT *result)
bool FlutterDesktopPluginRegistrarGetGraphicsAdapter(FlutterDesktopPluginRegistrarRef registrar, IDXGIAdapter **adapter_out)
static flutter::FlutterWindowsView * ViewFromHandle(FlutterDesktopViewRef ref)
void FlutterDesktopResyncOutputStreams()
void FlutterDesktopEngineRegisterPlatformViewType(FlutterDesktopEngineRef engine, const char *view_type_name, FlutterPlatformViewTypeEntry view_type)
static FlutterDesktopViewRef HandleForView(flutter::FlutterWindowsView *view)
static FlutterDesktopViewControllerRef CreateViewController(FlutterDesktopEngineRef engine_ref, int width, int height, bool owns_engine)
FLUTTER_EXPORT FlutterDesktopEngineRef FlutterDesktopEngineForId(int64_t engine_id)
void FlutterDesktopMessengerSendResponse(FlutterDesktopMessengerRef messenger, const FlutterDesktopMessageResponseHandle *handle, const uint8_t *data, size_t data_length)
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopViewId view_id)
static FlutterDesktopEngineRef HandleForEngine(flutter::FlutterWindowsEngine *engine)
bool FlutterDesktopMessengerSendWithReply(FlutterDesktopMessengerRef messenger, const char *channel, const uint8_t *message, const size_t message_size, const FlutterDesktopBinaryReply reply, void *user_data)
void FlutterDesktopPluginRegistrarSetDestructionHandler(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopOnPluginRegistrarDestroyed callback)
FlutterDesktopPluginRegistrarRef FlutterDesktopEngineGetPluginRegistrar(FlutterDesktopEngineRef engine, const char *plugin_name)
static flutter::FlutterWindowsEngine * EngineFromHandle(FlutterDesktopEngineRef ref)
int64_t FlutterDesktopTextureRegistrarRegisterExternalTexture(FlutterDesktopTextureRegistrarRef texture_registrar, const FlutterDesktopTextureInfo *texture_info)
static FlutterDesktopViewControllerRef HandleForViewController(flutter::FlutterWindowsViewController *view_controller)
bool FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable(FlutterDesktopTextureRegistrarRef texture_registrar, int64_t texture_id)
bool FlutterDesktopEngineIsPlatformThread(FlutterDesktopEngineRef engine)
FlutterDesktopViewControllerRef FlutterDesktopViewControllerCreate(int width, int height, FlutterDesktopEngineRef engine)
FlutterDesktopMessengerRef FlutterDesktopMessengerLock(FlutterDesktopMessengerRef messenger)
void FlutterDesktopTextureRegistrarUnregisterExternalTexture(FlutterDesktopTextureRegistrarRef texture_registrar, int64_t texture_id, void(*callback)(void *user_data), void *user_data)
bool FlutterDesktopEngineDestroy(FlutterDesktopEngineRef engine_ref)
UINT FlutterDesktopGetDpiForMonitor(HMONITOR monitor)
void FlutterDesktopEnginePostPlatformThreadTask(FlutterDesktopEngineRef engine, VoidCallback callback, VoidCallback on_cancel, void *user_data)
bool FlutterDesktopMessengerIsAvailable(FlutterDesktopMessengerRef messenger)
bool FlutterDesktopMessengerSend(FlutterDesktopMessengerRef messenger, const char *channel, const uint8_t *message, const size_t message_size)
FlutterDesktopTextureRegistrarRef FlutterDesktopEngineGetTextureRegistrar(FlutterDesktopEngineRef engine)
void FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopWindowProcCallback delegate)
IDXGIAdapter * FlutterDesktopViewGetGraphicsAdapter(FlutterDesktopViewRef view)
bool FlutterDesktopViewControllerHandleTopLevelWindowProc(FlutterDesktopViewControllerRef ref, HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT *result)
uint64_t FlutterDesktopEngineProcessMessages(FlutterDesktopEngineRef engine)
void FlutterDesktopMessengerUnlock(FlutterDesktopMessengerRef messenger)
void FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopWindowProcCallback delegate, void *user_data)
FlutterDesktopMessengerRef FlutterDesktopEngineGetMessenger(FlutterDesktopEngineRef engine)
FlutterDesktopViewId FlutterDesktopViewControllerGetViewId(FlutterDesktopViewControllerRef ref)
FlutterDesktopEngineRef FlutterDesktopViewControllerGetEngine(FlutterDesktopViewControllerRef ref)
FlutterDesktopTextureRegistrarRef FlutterDesktopRegistrarGetTextureRegistrar(FlutterDesktopPluginRegistrarRef registrar)
FlutterDesktopMessengerRef FlutterDesktopPluginRegistrarGetMessenger(FlutterDesktopPluginRegistrarRef registrar)
void FlutterDesktopEngineSetNextFrameCallback(FlutterDesktopEngineRef engine, VoidCallback callback, void *user_data)
HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view)
void FlutterDesktopMessengerRelease(FlutterDesktopMessengerRef messenger)
FlutterDesktopViewRef FlutterDesktopViewControllerGetView(FlutterDesktopViewControllerRef ref)
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(FlutterDesktopPluginRegistrarRef registrar)
FlutterDesktopMessengerRef FlutterDesktopMessengerAddRef(FlutterDesktopMessengerRef messenger)
FlutterDesktopViewControllerRef FlutterDesktopEngineCreateViewController(FlutterDesktopEngineRef engine, const FlutterDesktopViewControllerProperties *properties)
void FlutterDesktopViewControllerDestroy(FlutterDesktopViewControllerRef ref)
static flutter::FlutterWindowsViewController * ViewControllerFromHandle(FlutterDesktopViewControllerRef ref)
bool FlutterDesktopEngineRun(FlutterDesktopEngineRef engine, const char *entry_point)
struct FlutterDesktopViewController * FlutterDesktopViewControllerRef
bool(* FlutterDesktopWindowProcCallback)(HWND, UINT, WPARAM, LPARAM, void *, LRESULT *result)
struct FlutterDesktopEngine * FlutterDesktopEngineRef
int64_t FlutterDesktopViewId
struct FlutterDesktopView * FlutterDesktopViewRef
void(* VoidCallback)(void *)
FlutterDesktopBinaryReply callback
Win32Message message
UINT GetDpiForHWND(HWND hwnd)
Definition: dpi_utils.cc:128
UINT GetDpiForMonitor(HMONITOR monitor)
Definition: dpi_utils.cc:132
constexpr FlutterViewId kImplicitViewId
flutter::FlutterWindowsEngine * engine
Definition: window_state.h:25