mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
498dbc6dc1
The Windows embedding was based on the GLFW embedding, which grew organically from a singe-file implementation that used structs to manage all of the important state. It is in the process of being converted to a cleaner object-based architecture, but currently it is a hybrid of objects and structs that have redundant data, making it very prone to errors of forgetting to update pointers in multiple locations. This reduces the remaining structs to only a single pointer to the larger object that manages the responsibilities that handle is associated with, so that there is no need to wire things together in multiple places. For now they continue to exist as projections of the larger objects, but that will be eliminated over time by having an object structure that better reflects the API structure. Fixes https://github.com/flutter/flutter/issues/64250
127 lines
4.3 KiB
C++
127 lines
4.3 KiB
C++
// Copyright 2013 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_FLUTTER_WINDOWS_ENGINE_H_
|
|
#define FLUTTER_SHELL_PLATFORM_WINDOWS_FLUTTER_WINDOWS_ENGINE_H_
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <vector>
|
|
|
|
#include "flutter/shell/platform/common/cpp/incoming_message_dispatcher.h"
|
|
#include "flutter/shell/platform/windows/flutter_project_bundle.h"
|
|
#include "flutter/shell/platform/windows/public/flutter_windows.h"
|
|
#include "flutter/shell/platform/windows/win32_task_runner.h"
|
|
#include "flutter/shell/platform/windows/win32_window_proc_delegate_manager.h"
|
|
#include "flutter/shell/platform/windows/window_state.h"
|
|
|
|
namespace flutter {
|
|
|
|
class FlutterWindowsView;
|
|
|
|
// Manages state associated with the underlying FlutterEngine that isn't
|
|
// related to its display.
|
|
//
|
|
// In most cases this will be associated with a FlutterView, but if not will
|
|
// run in headless mode.
|
|
class FlutterWindowsEngine {
|
|
public:
|
|
// Creates a new Flutter engine object configured to run |project|.
|
|
explicit FlutterWindowsEngine(const FlutterProjectBundle& project);
|
|
|
|
virtual ~FlutterWindowsEngine();
|
|
|
|
// Prevent copying.
|
|
FlutterWindowsEngine(FlutterWindowsEngine const&) = delete;
|
|
FlutterWindowsEngine& operator=(FlutterWindowsEngine const&) = delete;
|
|
|
|
// Starts running the engine with the given entrypoint. If null, defaults to
|
|
// main().
|
|
//
|
|
// Returns false if the engine couldn't be started.
|
|
bool RunWithEntrypoint(const char* entrypoint);
|
|
|
|
// Returns true if the engine is currently running.
|
|
bool running() { return engine_ != nullptr; }
|
|
|
|
// Stops the engine. This invalidates the pointer returned by engine().
|
|
//
|
|
// Returns false if stopping the engine fails, or if it was not running.
|
|
bool Stop();
|
|
|
|
// Sets the view that is displaying this engine's content.
|
|
void SetView(FlutterWindowsView* view);
|
|
|
|
// The view displaying this engine's content, if any. This will be null for
|
|
// headless engines.
|
|
FlutterWindowsView* view() { return view_; }
|
|
|
|
// Returns the currently configured Plugin Registrar.
|
|
FlutterDesktopPluginRegistrarRef GetRegistrar();
|
|
|
|
// Sets |callback| to be called when the plugin registrar is destroyed.
|
|
void SetPluginRegistrarDestructionCallback(
|
|
FlutterDesktopOnRegistrarDestroyed callback);
|
|
|
|
FLUTTER_API_SYMBOL(FlutterEngine) engine() { return engine_; }
|
|
|
|
FlutterDesktopMessengerRef messenger() { return messenger_.get(); }
|
|
|
|
IncomingMessageDispatcher* message_dispatcher() {
|
|
return message_dispatcher_.get();
|
|
}
|
|
|
|
Win32TaskRunner* task_runner() { return task_runner_.get(); }
|
|
|
|
Win32WindowProcDelegateManager* window_proc_delegate_manager() {
|
|
return window_proc_delegate_manager_.get();
|
|
}
|
|
|
|
// Callback passed to Flutter engine for notifying window of platform
|
|
// messages.
|
|
void HandlePlatformMessage(const FlutterPlatformMessage*);
|
|
|
|
private:
|
|
// Sends system settings (e.g., locale) to the engine.
|
|
//
|
|
// Should be called just after the engine is run, and after any relevant
|
|
// system changes.
|
|
void SendSystemSettings();
|
|
|
|
// The handle to the embedder.h engine instance.
|
|
FLUTTER_API_SYMBOL(FlutterEngine) engine_ = nullptr;
|
|
|
|
std::unique_ptr<FlutterProjectBundle> project_;
|
|
|
|
// AOT data, if any.
|
|
UniqueAotDataPtr aot_data_;
|
|
|
|
// The view displaying the content running in this engine, if any.
|
|
FlutterWindowsView* view_ = nullptr;
|
|
|
|
// Task runner for tasks posted from the engine.
|
|
std::unique_ptr<Win32TaskRunner> task_runner_;
|
|
|
|
// The plugin messenger handle given to API clients.
|
|
std::unique_ptr<FlutterDesktopMessenger> messenger_;
|
|
|
|
// Message dispatch manager for messages from engine_.
|
|
std::unique_ptr<IncomingMessageDispatcher> message_dispatcher_;
|
|
|
|
// The plugin registrar handle given to API clients.
|
|
std::unique_ptr<FlutterDesktopPluginRegistrar> plugin_registrar_;
|
|
|
|
// A callback to be called when the engine (and thus the plugin registrar)
|
|
// is being destroyed.
|
|
FlutterDesktopOnRegistrarDestroyed plugin_registrar_destruction_callback_;
|
|
|
|
// The manager for WindowProc delegate registration and callbacks.
|
|
std::unique_ptr<Win32WindowProcDelegateManager> window_proc_delegate_manager_;
|
|
};
|
|
|
|
} // namespace flutter
|
|
|
|
#endif // FLUTTER_SHELL_PLATFORM_WINDOWS_FLUTTER_WINDOWS_ENGINE_H_
|