Flutter Engine 启动流程：C++ 层的 Embedder API 与 Isolate 初始化

Flutter Engine 启动流程：C++ 层的 Embedder API 与 Isolate 初始化

大家好，今天我们深入探讨 Flutter Engine 的启动流程，重点关注 C++ 层的 Embedder API 如何与 Isolate 初始化协同工作，驱动 Flutter 应用程序的运行。我们将从 Embedder API 的概念入手，逐步分析其在启动流程中的作用，然后深入研究 Isolate 的创建和初始化过程，并结合代码示例，帮助大家理解其中的关键机制。

1. Embedder API：Flutter 与宿主平台的桥梁

Flutter Engine 本身是一个平台无关的渲染引擎，它不了解 iOS、Android 或桌面环境的细节。Embedder API 的作用就是弥合这个 gap，它提供了一组接口，允许宿主平台（例如 Android 中的 Activity，iOS 中的 ViewController）与 Flutter Engine 进行交互，完成窗口管理、事件传递、线程管理等关键任务。

1.1 Embedder API 的主要职责

Embedder API 主要负责以下几个方面：

• 窗口管理： 创建和管理 Flutter 渲染的窗口，包括窗口大小、位置、可见性等。
• 事件循环集成： 将宿主平台的事件循环（例如 Android 的 Looper，iOS 的 RunLoop）与 Flutter Engine 的事件循环集成，确保 Flutter 可以响应用户输入和系统事件。
• 线程管理： 管理 Flutter Engine 使用的线程，例如 UI 线程、GPU 线程、IO 线程等。
• 平台通道 (Platform Channel) 的消息传递： 在 Flutter 代码和宿主平台代码之间传递消息，允许 Flutter 调用原生 API，或者原生代码驱动 Flutter 做出响应。
• 资源加载： 提供资源加载机制，例如加载字体、图片、assets等等。

1.2 Embedder 的接口定义 (以 Android 为例)

虽然 Embedder 的具体实现会根据宿主平台的差异而有所不同，但其核心概念和接口是类似的。在 Android 平台，FlutterView 和 FlutterNativeView 是关键的 Embedder 组件。FlutterView 负责将 Flutter 渲染的内容显示在 Android 窗口上，而 FlutterNativeView 则更底层，直接与 Flutter Engine 交互。

下面是一个简化的 Android Embedder 接口示例，展示了其主要的功能：

// Java 代码 (简化示例)
public interface FlutterEmbedder {

    /**
     * 初始化 Flutter Engine。
     * @param args 初始化参数，例如 Dart entrypoint、 assets 路径等。
     */
    void initialize(String[] args);

    /**
     * 启动 Flutter Engine。
     */
    void run();

    /**
     * 渲染 Flutter 场景。
     * @param frame 渲染数据。
     */
    void render(ByteBuffer frame);

    /**
     * 处理平台消息。
     * @param message 平台消息。
     */
    void handlePlatformMessage(PlatformMessage message);

    /**
     * 处理触摸事件。
     * @param event 触摸事件。
     */
    void handleTouchEvent(MotionEvent event);

    /**
     * 调整窗口大小。
     * @param width 新的宽度。
     * @param height 新的高度。
     */
    void onSurfaceChanged(int width, int height);

    /**
     * 销毁 Flutter Engine。
     */
    void destroy();
}

这个接口定义了 Embedder 需要实现的关键方法，包括初始化、运行、渲染、事件处理和资源管理等。 实际的 Android Embedder 还会包含更多细节，例如 GLSurfaceView 的集成、纹理管理、键盘事件处理等等。

1.3 C++ 层 Embedder 的抽象

在 Flutter Engine 的 C++ 代码中，FlutterEngine 类扮演着核心角色，它通过 Shell 类与 Embedder 进行交互。Shell 类提供了一组抽象接口，让 Flutter Engine 可以与不同的 Embedder 实现进行通信，而无需关心底层平台的具体细节。

下面是 Shell 类中与 Embedder 交互相关的部分接口：

// C++ 代码 (简化示例)
class Shell {
public:
  // ...

  virtual ~Shell() = default;

  // 从平台获取线程任务执行者。
  virtual TaskRunners GetTaskRunners() = 0;

  // 从平台获取引擎创建参数。
  virtual Settings GetSettings() = 0;

  // 通知平台需要重新绘制。
  virtual void ScheduleFrame() = 0;

  // 触发 platform channel 的消息。
  virtual void DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message) = 0;

  // 发送平台相关的事件，比如键盘，触摸等。
  virtual void SendPlatformMessage(std::unique_ptr<PlatformMessage> message) = 0;

  // 窗口大小改变事件。
  virtual void OnEnginePlatformViewMutation(
      const EnginePlatformViewMutationResult& result) = 0;

  // 获取平台提供的外部视图的持有者。
  virtual std::unique_ptr<ExternalViewEmbedder> CreateExternalViewEmbedder() = 0;

  // ...
};

FlutterEngine 通过调用 Shell 提供的接口，例如 ScheduleFrame、DispatchPlatformMessage 和 SendPlatformMessage，与 Embedder 进行通信，实现窗口渲染、事件传递和平台消息处理等功能。

2. Isolate：Flutter 并发模型的基础

Isolate 是 Flutter 并发模型的核心概念。每个 Flutter 应用程序至少运行在一个 Isolate 中，而复杂的应用程序可能会使用多个 Isolate 来实现并行计算和异步任务处理。

2.1 Isolate 的概念和特点

Isolate 可以被理解为独立的 Dart 虚拟机实例，拥有自己的堆内存和执行上下文。Isolate 之间不共享内存，只能通过消息传递进行通信，这保证了 Isolate 之间的隔离性，避免了多线程并发访问共享内存可能导致的数据竞争和死锁问题。

Isolate 的主要特点包括：

• 内存隔离： 每个 Isolate 拥有独立的堆内存，防止数据竞争。
• 消息传递： Isolate 之间通过消息传递进行通信，实现异步任务处理。
• 并发执行： 多个 Isolate 可以并发执行，提高应用程序的性能。
• 事件循环： 每个 Isolate 都有自己的事件循环，负责处理消息和事件。

2.2 Isolate 的创建和初始化

Isolate 的创建和初始化过程涉及多个步骤，包括创建 Dart 虚拟机实例、加载 Dart 代码、设置 Isolate 的上下文环境等。在 Flutter Engine 中，Isolate 的创建和管理主要由 Isolate 类负责。

下面是 Isolate 创建和初始化过程的简化流程：

1. 创建 Dart 虚拟机实例： 使用 Dart VM 的 API 创建一个新的 Dart 虚拟机实例。
2. 加载 Dart 代码： 将 Dart 代码加载到虚拟机实例中。这通常涉及到从 Dart 文件的二进制快照 (snapshot) 中读取代码，或者 JIT 编译 Dart 代码。
3. 设置 Isolate 上下文： 设置 Isolate 的上下文环境，包括设置根 Isolate、错误处理函数、消息处理函数等。
4. 启动 Isolate 的事件循环： 启动 Isolate 的事件循环，开始处理消息和事件。

2.3 Flutter Engine 中 Isolate 的初始化

在 Flutter Engine 启动过程中，通常会创建一个或多个 Isolate。其中，uiIsolate 负责处理 UI 渲染和用户交互，而 serviceIsolate 负责提供调试和诊断服务。

下面是 Flutter Engine 中 uiIsolate 初始化相关的代码片段（简化示例）：

// C++ 代码 (简化示例)
std::unique_ptr<Isolate> CreateUIIsolate(
    Shell& shell,
    const Settings& settings,
    const TaskRunners& task_runners) {
  // 1. 创建 Dart 虚拟机实例。
  DartVMRef vm = DartVM::ForProcess(settings.dart_library_group_config);

  // 2. 创建 Isolate 对象。
  auto isolate = std::make_unique<Isolate>(
      shell, vm, task_runners, Isolate::IsolateType::kUI, /*is_root_isolate=*/true);

  // 3. 初始化 Isolate。
  if (!isolate->Initialize(settings)) {
    return nullptr;
  }

  // 4. 返回 Isolate 对象。
  return isolate;
}

bool Isolate::Initialize(const Settings& settings) {
  // ...

  // 加载 Dart 代码。
  if (!LoadDartCode(settings)) {
    return false;
  }

  // 设置 Isolate 上下文。
  if (!SetupIsolateContext()) {
    return false;
  }

  // 启动 Isolate 的事件循环。
  Run();

  // ...

  return true;
}

这段代码展示了 uiIsolate 的创建和初始化过程。首先，创建一个 Dart 虚拟机实例，然后创建一个 Isolate 对象，并调用 Initialize 方法进行初始化。Initialize 方法会加载 Dart 代码、设置 Isolate 上下文，并启动 Isolate 的事件循环。

2.4 Isolate 之间的通信

由于 Isolate 之间不共享内存，它们只能通过消息传递进行通信。在 Flutter 中，可以使用 SendPort 和 ReceivePort 来实现 Isolate 之间的消息传递。

• SendPort 用于发送消息到目标 Isolate。
• ReceivePort 用于接收来自其他 Isolate 的消息。

下面是一个简单的 Isolate 之间消息传递的示例：

// Dart 代码 (简化示例)
import 'dart:isolate';

void main() async {
  // 创建一个 ReceivePort 用于接收消息。
  ReceivePort receivePort = ReceivePort();

  // 启动一个新的 Isolate。
  Isolate isolate = await Isolate.spawn(workerFunction, receivePort.sendPort);

  // 监听 ReceivePort 接收的消息。
  receivePort.listen((message) {
    print('Received message: $message');
    receivePort.close();
    isolate.kill();
  });

  // 发送消息到新的 Isolate。
  print('Sending message to worker isolate');
}

void workerFunction(SendPort sendPort) {
  // 发送消息到主 Isolate。
  sendPort.send('Hello from worker isolate!');
}

在这个例子中，主 Isolate 创建了一个新的 Isolate，并向其发送了一个 SendPort。新的 Isolate 通过 SendPort 向主 Isolate 发送消息。主 Isolate 监听 ReceivePort 接收的消息，并在收到消息后关闭 ReceivePort 并杀死新的 Isolate。

3. Embedder API 与 Isolate 初始化的协同

Embedder API 和 Isolate 初始化是 Flutter Engine 启动流程中的两个关键环节。Embedder API 负责与宿主平台进行交互，提供窗口管理、事件传递和线程管理等功能，而 Isolate 初始化负责创建和管理 Dart 虚拟机实例，加载 Dart 代码，并启动 Isolate 的事件循环。

这两个环节之间的协同体现在以下几个方面：

• 线程管理： Embedder API 负责管理 Flutter Engine 使用的线程，包括 UI 线程、GPU 线程和 IO 线程。Isolate 的事件循环通常运行在 UI 线程上，由 Embedder API 提供的线程管理机制来保证其正常运行。
• 事件传递： Embedder API 负责将宿主平台的事件（例如触摸事件、键盘事件）传递给 Flutter Engine。Flutter Engine 将这些事件传递给 uiIsolate，由 uiIsolate 处理这些事件，并更新 UI。
• 平台通道消息传递： Embedder API 负责在 Flutter 代码和宿主平台代码之间传递消息。uiIsolate 可以通过平台通道调用原生 API，或者原生代码可以通过平台通道驱动 Flutter 做出响应。

总而言之，Embedder API 为 Isolate 的运行提供了必要的平台支持，而 Isolate 则利用 Embedder API 提供的功能，实现 UI 渲染、事件处理和平台交互。

4. 代码示例：Android 平台 Flutter Engine 初始化流程

为了更好地理解 Embedder API 和 Isolate 初始化之间的协同，我们来看一个 Android 平台 Flutter Engine 初始化流程的简化代码示例：

// Java 代码 (简化示例)
public class MainActivity extends Activity {

    private FlutterView flutterView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 1. 创建 FlutterView。
        flutterView = new FlutterView(this);

        // 2. 设置 FlutterView 的布局参数。
        setContentView(flutterView);

        // 3. 初始化 Flutter Engine。
        FlutterMain.startInitialization(this);
        FlutterNativeView nativeView = new FlutterNativeView(this);

        // 4. 获取 Flutter Engine 的运行参数。
        String[] args = getArgs();

        // 5. 运行 Flutter Engine。
        nativeView.runFromBundle(FlutterMain.findAppBundlePath(), null, args);

        // 6. 连接 FlutterView 和 FlutterNativeView。
        flutterView.attachToFlutterEngine(nativeView.getFlutterEngine());
    }

    private String[] getArgs() {
        // ...
        return new String[]{
                "--icu-data-file-path=" + FlutterMain.getIcuDataPath(),
                "--local-package-asset-path=" + FlutterMain.getLookupKeyForAsset("flutter_assets"),
                "--aot-shared-library-name=" + "flutter.so",
                "--cache-path=" + getCacheDir().getAbsolutePath(),
                "--domain-name=com.example.app"
        };
    }
}

在这个例子中，MainActivity 是 Android 应用程序的入口点。在 onCreate 方法中，我们首先创建一个 FlutterView，并设置其布局参数。然后，我们初始化 Flutter Engine，获取 Flutter Engine 的运行参数，并运行 Flutter Engine。最后，我们将 FlutterView 连接到 FlutterNativeView，从而将 Flutter 渲染的内容显示在 Android 窗口上。

在这个过程中，FlutterView 和 FlutterNativeView 扮演着 Embedder 的角色，负责与 Flutter Engine 进行交互。FlutterNativeView 负责创建和管理 Flutter Engine 的实例，并将平台事件传递给 Flutter Engine。Flutter Engine 则负责创建和管理 Isolate，加载 Dart 代码，并启动 UI 渲染。

5. 深入理解 Flutter Engine 的启动过程

Flutter Engine 的启动过程是一个复杂的过程，涉及多个组件和模块之间的协同工作。为了更好地理解这个过程，我们可以将其分解为以下几个阶段：

阶段	描述	涉及的组件
1	Embedder 初始化： 宿主平台创建 Embedder 实例，并设置窗口、事件循环等平台相关配置。	FlutterView (Android), FlutterViewController (iOS), Shell (C++)
2	Flutter Engine 初始化： Embedder 创建 Flutter Engine 实例，并初始化 Engine 的各个模块，例如渲染器、输入管理器、平台通道等。	FlutterEngine (C++), Shell (C++), Renderer (C++), TextInputPlugin (C++), PlatformChannel (C++)
3	Isolate 初始化： Flutter Engine 创建和初始化 uiIsolate 和 serviceIsolate，加载 Dart 代码，并启动 Isolate 的事件循环。	Isolate (C++), DartVM (C++)
4	Dart 代码执行： uiIsolate 执行 Dart 代码，构建 UI 树，并开始渲染。	Flutter Framework (Dart)
5	事件循环运行： Flutter Engine 的事件循环开始运行，处理用户输入、平台事件和异步任务，驱动应用程序的运行。	Shell (C++), uiIsolate (C++), Dart Event Loop (C++)

理解这些阶段可以帮助我们更好地理解 Flutter Engine 的启动过程，并诊断启动过程中可能出现的问题。

6. 常见问题和调试技巧

在 Flutter Engine 启动过程中，可能会遇到各种问题，例如初始化失败、渲染异常、事件处理错误等。下面是一些常见问题和调试技巧：

• 初始化失败： 检查 Embedder 的配置是否正确，例如窗口大小、事件循环集成、线程管理等。
• 渲染异常： 检查 GPU 驱动程序是否正常工作，以及 Flutter Engine 的渲染设置是否正确。
• 事件处理错误： 检查 Embedder 是否正确地将平台事件传递给 Flutter Engine，以及 Flutter Framework 是否正确地处理这些事件。
• Isolate 创建失败： 检查 Dart VM 的配置是否正确，以及 Dart 代码是否存在语法错误或运行时错误。

在调试 Flutter Engine 启动过程时，可以使用以下工具和技巧：

• 日志输出： 在 Embedder 和 Flutter Engine 的代码中添加日志输出，可以帮助我们了解启动过程中的各个环节是否正常工作。
• 断点调试： 使用调试器可以单步执行代码，并查看变量的值，从而帮助我们找到问题的根源。
• 性能分析： 使用性能分析工具可以分析启动过程中的性能瓶颈，并优化代码。
• Flutter Doctor： 使用 flutter doctor 命令可以检查 Flutter 开发环境是否配置正确。

Embedder 和 Isolate：启动流程的关键

Embedder API 是 Flutter 与宿主平台交互的桥梁，负责窗口管理、事件传递和线程管理；而 Isolate 则是 Flutter 并发模型的基础，负责 Dart 代码的执行和 UI 渲染。

协同工作：平台支持和核心驱动

Embedder API 为 Isolate 的运行提供平台支持，包括线程管理和事件传递；Isolate 则利用 Embedder API 提供的功能，实现 UI 渲染、事件处理和平台交互，二者协同驱动 Flutter 应用的运行。

深入理解：分阶段剖析启动流程

理解 Flutter Engine 启动流程的各个阶段，例如 Embedder 初始化、Flutter Engine 初始化、Isolate 初始化、Dart 代码执行和事件循环运行，可以帮助我们更好地理解启动过程，并诊断启动过程中可能出现的问题。