Flutter - 深入理解Flutter引擎启动

基于Flutter 1.5，从源码视角来深入剖析flutter引擎的启动流程，相关源码目录见文末附录

一、Flutter引擎启动工作

1.1 Flutter启动概览

Flutter作为一款跨平台的框架，可以运行在Android、iOS等平台，Android为例讲解如何从Android应用启动流程中衔接到Flutter框架，如何启动Flutter引擎的启动流程。 熟悉Android的开发者，应该都了解APP启动过程，会执行Application和Activity的初始化，并调用它们的onCreate()方法。那么FlutterApplication和FlutterActivity的onCreate()方法是连接Native和Flutter的枢纽。

• FlutterApplication.java的onCreate过程：初始化配置文件/加载libflutter.so/注册JNI方法；
• FlutterActivity.java的onCreate过程：创建FlutterView、Dart虚拟机、Engine、Isolate、taskRunner等对象，最终执行执行到Dart的main()方法，处理整个Dart业务代码。

1.2 引擎启动工作

1.2.1 FlutterApplication启动

FlutterApplication启动过程

图解：在AndrodManifest.xml定义的FlutterApplication，Android应用在启动时候会执行FlutterApplication.onCreate()，然后再执行FlutterMain.startInitialization()方法，其主要工作：

1. 确保该方法必须运行在主线程，否则抛出异常；
2. 初始化配置参数，vm_snapshot_data、vm_snapshot_instr、isolate_snapshot_data、isolate_snapshot_instr、flutter_assets的值
3. 获取应用根目录下的所有assets资源路径，提取产物资源，加载到内存；
4. 加载libflutter.so库，调用JNI_OnLoad()；
   • Android进程自身会创建JavaVM，此处将当前进程的JavaVM实例保存在静态变量g_jvm，再将当前线程和JavaVM建立关联
   • 注册FlutterMain的JNI方法，nativeInit()和nativeRecordStartTimestamp()
   • 注册PlatformViewAndroid的一系列方法，完成Java和C++的一些方法互调；
   • 注册VSyncWaiter的nativeOnVsync()用于Java调用C++，asyncWaitForVsync()用于C++调用Java；
5. 最终将FlutterApplication的启动耗时记录，通过engine_main_enter_ts变量；

1.2.2 FlutterActivity启动

FlutterActivity启动过程

图解：每一个FlutterActivity都会对应一个FlutterActivityDelegate代理类，FlutterActivity的工作全权委托给FlutterActivityDelegate类，包括onCreate()，onResume()等全部的生命周期回调方法。

1. 确保该方法必须运行在主线程、sSettings完成初始化赋值、资源提前操作完成，否则不再往下执行；
2. 创建FlutterMain(C++)，将拼接所有参数都封装到settings结构体，并记录在FlutterMain的成员变量settings_；
3. 创建FlutterView对象，并在该对象初始过程中创建FlutterNativeView，PlatformChannel，PlatformPlugin等大量对象；
4. FlutterNativeView对象初始化过程中创建FlutterJNI，FlutterPluginRegistry等对象；
5. 在platform_view_android_jni.cc的AttachJNI过程会初始化AndroidShellHolder对象，这边进入引擎层的初始化过程[见小节1.2.3]；

在Flutter引擎启动也初始化完成后，执行FlutterActivityDelegate.runBundle()加载Dart代码，其中entrypoint和libraryPath分别代表主函数入口的函数名”main”和所对应库的路径， 经过层层调用后开始执行dart层的main()方法，执行runApp()的过程，这便开启执行整个Dart业务代码。

1.2.3 Flutter引擎启动

Flutter引擎启动过程

图解：在platform_view_android_jni.cc的AttachJNI过程会初始化AndroidShellHolder对象，该对象初始化过程的主要工作：

1. 创建AndroidShellHolder对象，会初始化ThreadHost，并创建1.ui, 1.gpu, 1.io这3个线程。每个线程Thread初始化过程，都会创建相应的MessageLoop、TaskRunner对象，然后进入pollOnce轮询等待状态；
2. 创建Shell对象，设置默认log只输出ERROR级别，除非在启动的时候带上参数verbose_logging，则会打印出INFO级别的日志；
3. 当进程存在正在运行DartVM，则获取其强引用，复用该DartVM，否则新创建一个Dart虚拟机；
4. 在Shell::CreateShellOnPlatformThread()过程执行如下操作：
   • 主线程中创建PlatformViewAndroid对象，AndroidSurfaceGL、GPUSurfaceGL以及VsyncWaiterAndroid对象；
   • io线程中创建ShellIOManager对象，GrContext、SkiaUnrefQueue对象
   • gpu线程中创建Rasterizer对象，CompositorContext对象
   • ui线程中创建Engine、Animator对象，RuntimeController、Window对象，以及DartIsolate、Isolate对象

可见，每一个FlutterActivity都有相对应的FlutterView、AndroidShellHolder、Shell、Engine、Animator、PlatformViewAndroid、RuntimeController、Window等对象。但每一个进进程DartVM独有一份；

1.3 相关参数

1.3.1 Intent参数

1.4 核心类图

Flutter引擎核心类

每一个FlutterActivity都对应有一个图中所描述的对象；

接下来，从源码角度解读Application.onCreate()和Activity.onCreate()的核心工作。

二、FlutterApplication启动流程

在AndrodManifest.xml定义的FlutterApplication，Android应用在启动时候会执行其onCreate()方法，

2.1 FlutterApplication.onCreate

[-> FlutterApplication.java]

1public class FlutterApplication extends Application {
2    public void onCreate() {
3        super.onCreate();
4        FlutterMain.startInitialization(this); //[见小节2.2]
5    }
6    ...
7} 

2.2 startInitialization

[-> FlutterMain.java]

1public static void startInitialization(Context applicationContext) {
2    startInitialization(applicationContext, new Settings());
3}
4
5public static void startInitialization(Context applicationContext, Settings settings) {
6    //该方法必须运行在主线程，否则抛出异常
7    if (Looper.myLooper() != Looper.getMainLooper()) {
8      throw new IllegalStateException("startInitialization must be called on the main thread");
9    }
10    //保证startInitialization只执行一次
11    if (sSettings != null) {
12      return;
13    }
14    sSettings = settings;
15
16    long initStartTimestampMillis = SystemClock.uptimeMillis();
17    initConfig(applicationContext); //[见小节2.3]
18    initAot(applicationContext); //[见小节2.4]
19    initResources(applicationContext); //[见小节2.5]
20
21    //加载libflutter.so [见小节2.6]
22    if (sResourceUpdater == null) {
23        System.loadLibrary("flutter");
24    } else {
25        sResourceExtractor.waitForCompletion();
26        File lib = new File(PathUtils.getDataDirectory(applicationContext), DEFAULT_LIBRARY);
27        if (lib.exists()) {
28            System.load(lib.getAbsolutePath());
29        } else {
30            System.loadLibrary("flutter");
31        }
32    }
33
34    long initTimeMillis = SystemClock.uptimeMillis() - initStartTimestampMillis;
35    nativeRecordStartTimestamp(initTimeMillis);  //[见小节2.7]
36} 

该方法的主要工作是：

• 初始化配置，获取是否预编译模式，初始化并提取资源文件；
• 加载libflutter.so库；
• 记录启动时间戳；

2.3 initConfig

[-> FlutterMain.java]

1private static void initConfig(Context applicationContext) {
2    try {
3        Bundle metadata = applicationContext.getPackageManager().getApplicationInfo(
4            applicationContext.getPackageName(), PackageManager.GET_META_DATA).metaData;
5        if (metadata != null) {
6            sAotSharedLibraryPath = metadata.getString(PUBLIC_AOT_AOT_SHARED_LIBRARY_PATH, DEFAULT_AOT_SHARED_LIBRARY_PATH);
7            sAotVmSnapshotData = metadata.getString(PUBLIC_AOT_VM_SNAPSHOT_DATA_KEY, DEFAULT_AOT_VM_SNAPSHOT_DATA);
8            sAotVmSnapshotInstr = metadata.getString(PUBLIC_AOT_VM_SNAPSHOT_INSTR_KEY, DEFAULT_AOT_VM_SNAPSHOT_INSTR);
9            sAotIsolateSnapshotData = metadata.getString(PUBLIC_AOT_ISOLATE_SNAPSHOT_DATA_KEY, DEFAULT_AOT_ISOLATE_SNAPSHOT_DATA);
10            sAotIsolateSnapshotInstr = metadata.getString(PUBLIC_AOT_ISOLATE_SNAPSHOT_INSTR_KEY, DEFAULT_AOT_ISOLATE_SNAPSHOT_INSTR);
11            sFlx = metadata.getString(PUBLIC_FLX_KEY, DEFAULT_FLX);
12            sFlutterAssetsDir = metadata.getString(PUBLIC_FLUTTER_ASSETS_DIR_KEY, DEFAULT_FLUTTER_ASSETS_DIR);
13        }
14    } catch (PackageManager.NameNotFoundException e) {
15        throw new RuntimeException(e);
16    }
17} 

初始化FlutterMain的相关配置信息，当metadata数据没有配置初值则采用默认值，每一项配置都是String类型，下面列举了每一项配置参数相对应的默认值，如下所示：

2.4 initAot

[-> FlutterMain.java]

1private static void initAot(Context applicationContext) {
2    //获取应用根目录下的所有assets资源路径
3    Set<String> assets = listAssets(applicationContext, "");
4    sIsPrecompiledAsBlobs = assets.containsAll(Arrays.asList(
5        sAotVmSnapshotData,
6        sAotVmSnapshotInstr,
7        sAotIsolateSnapshotData,
8        sAotIsolateSnapshotInstr
9    ));
10    sIsPrecompiledAsSharedLibrary = assets.contains(sAotSharedLibraryPath);
11    //当assets中存在共享库app.so和Dart虚拟机快照，则是预编译应用抛出异常
12    if (sIsPrecompiledAsBlobs && sIsPrecompiledAsSharedLibrary) {
13      throw new RuntimeException(“...”);
14    }
15} 

2.5 initResources

[-> FlutterMain.java]

1private static void initResources(Context applicationContext) {
2    Context context = applicationContext;
3    //执行异步文件清理
4    new ResourceCleaner(context).start();
5
6    Bundle metaData = null;
7    try {
8        metaData = context.getPackageManager().getApplicationInfo(
9                context.getPackageName(), PackageManager.GET_META_DATA).metaData;
10
11    } catch (PackageManager.NameNotFoundException e) {
12        ...
13    }
14
15    if (metaData != null && metaData.getBoolean("DynamicPatching")) {
16        //资源更新
17        sResourceUpdater = new ResourceUpdater(context);
18        if (sResourceUpdater.getDownloadMode() == ResourceUpdater.DownloadMode.ON_RESTART ||
19            sResourceUpdater.getDownloadMode() == ResourceUpdater.DownloadMode.ON_RESUME) {
20            sResourceUpdater.startUpdateDownloadOnce();
21            if (sResourceUpdater.getInstallMode() == ResourceUpdater.InstallMode.IMMEDIATE) {
22                sResourceUpdater.waitForDownloadCompletion();
23            }
24        }
25    }
26    //资源提取的过程
27    sResourceExtractor = new ResourceExtractor(context);
28
29    sResourceExtractor
30        .addResource(fromFlutterAssets(sFlx))
31        .addResource(fromFlutterAssets(sAotVmSnapshotData))
32        .addResource(fromFlutterAssets(sAotVmSnapshotInstr))
33        .addResource(fromFlutterAssets(sAotIsolateSnapshotData))
34        .addResource(fromFlutterAssets(sAotIsolateSnapshotInstr))
35        .addResource(fromFlutterAssets(DEFAULT_KERNEL_BLOB));
36
37    if (sIsPrecompiledAsSharedLibrary) {
38      sResourceExtractor.addResource(sAotSharedLibraryPath);
39    } else {
40      sResourceExtractor
41        .addResource(sAotVmSnapshotData)
42        .addResource(sAotVmSnapshotInstr)
43        .addResource(sAotIsolateSnapshotData)
44        .addResource(sAotIsolateSnapshotInstr);
45    }
46    if (sResourceUpdater != null) {
47      sResourceExtractor.addResource(DEFAULT_LIBRARY);
48    }
49    sResourceExtractor.start();
50} 

资源初始化主要包括对资源文件的清理、更新以及提前操作，这个过程都是在异步线程执行完成。

2.6 System.loadLibrary

不论是System.loadLibrary()，还是System.load()最终都会调用到该加载库中的JNI_OnLoad()方法，该过程原理见loadLibrary动态库加载过程分析

[-> flutter/shell/platform/android/library_loader.cc]

1JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
2  // 初始化Java虚拟机 [见小节2.6.1]
3  fml::jni::InitJavaVM(vm);
4  JNIEnv* env = fml::jni::AttachCurrentThread();
5  bool result = false;
6
7  // 注册FlutterMain [2.6.2]
8  result = shell::FlutterMain::Register(env);
9
10  // 注册PlatformView [见小节2.6.3]
11  result = shell::PlatformViewAndroid::Register(env);
12
13  // 注册VSyncWaiter [见小节2.6.4]
14  result = shell::VsyncWaiterAndroid::Register(env);
15  return JNI_VERSION_1_4;
16} 

在加载libflutter.so的过程，经过层层调用后会执行JNI_OnLoad()方法，该方法的主要功能：

• 初始化Java虚拟机；
• 注册FlutterMain;
• 注册PlatformView;
• 注册VSyncWaiter;

2.6.1 InitJavaVM

[-> flutter/fml/platform/android/jni_util.cc]

1static JavaVM* g_jvm = nullptr;
2
3void InitJavaVM(JavaVM* vm) {
4  g_jvm = vm;  //保存在静态变量
5}
6
7JNIEnv* AttachCurrentThread() {
8  JNIEnv* env = nullptr;
9  jint ret = g_jvm->AttachCurrentThread(&env, nullptr);
10  return env;
11} 

Android进程在由zygote fork过程中已创建了JavaVM，每一个进程对应一个JavaVM。在这里只是将当前进程的JavaVM实例保存在静态变量，再将当前线程和JavaVM建立关联，获取JNIEnv实例，每个线程对应一个JNIEnv实例。

2.6.2 FlutterMain::Register

[-> flutter/shell/platform/android/flutter_main.cc]

1bool FlutterMain::Register(JNIEnv* env) {
2  static const JNINativeMethod methods[] = {
3      {
4          .name = "nativeInit",
5          .signature = "(Landroid/content/Context;[Ljava/lang/String;Ljava/"
6                       "lang/String;Ljava/lang/String;Ljava/lang/String;)V",
7          .fnPtr = reinterpret_cast<void*>(&Init),
8      },
9      {
10          .name = "nativeRecordStartTimestamp",
11          .signature = "(J)V",
12          .fnPtr = reinterpret_cast<void*>(&RecordStartTimestamp),
13      },
14  };
15
16  jclass clazz = env->FindClass("io/flutter/view/FlutterMain");
17  ...
18  return env->RegisterNatives(clazz, methods, arraysize(methods)) == 0;
19} 

注册了FlutterMain的nativeInit和nativeRecordStartTimestamp的两方法，JNI注册更多详情见Android JNI原理分析。

2.6.3 PlatformViewAndroid::Register

[-> flutter/shell/platform/android/platform_view_android_jni.cc]

1bool PlatformViewAndroid::Register(JNIEnv* env) {
2  g_flutter_callback_info_class = new fml::jni::ScopedJavaGlobalRef<jclass>(
3      env, env->FindClass("io/flutter/view/FlutterCallbackInformation"));
4
5  g_flutter_callback_info_constructor = env->GetMethodID(
6      g_flutter_callback_info_class->obj(), "<init>",
7      "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
8
9  g_flutter_jni_class = new fml::jni::ScopedJavaGlobalRef<jclass>(
10      env, env->FindClass("io/flutter/embedding/engine/FlutterJNI"));
11
12  g_surface_texture_class = new fml::jni::ScopedJavaGlobalRef<jclass>(
13      env, env->FindClass("android/graphics/SurfaceTexture"));
14
15  static const JNINativeMethod callback_info_methods[] = {
16      {
17          .name = "nativeLookupCallbackInformation",
18          .signature = "(J)Lio/flutter/view/FlutterCallbackInformation;",
19          .fnPtr = reinterpret_cast<void*>(&shell::LookupCallbackInformation),
20      },
21  };
22  //注册FlutterCallbackInformation类的Native方法
23  env->RegisterNatives(g_flutter_callback_info_class->obj(),
24                           callback_info_methods,
25                           arraysize(callback_info_methods)) != 0);
26
27  g_is_released_method =
28      env->GetMethodID(g_surface_texture_class->obj(), "isReleased", "()Z");
29
30  g_attach_to_gl_context_method = env->GetMethodID(
31      g_surface_texture_class->obj(), "attachToGLContext", "(I)V");
32
33  g_update_tex_image_method =
34      env->GetMethodID(g_surface_texture_class->obj(), "updateTexImage", "()V");
35
36  g_get_transform_matrix_method = env->GetMethodID(
37      g_surface_texture_class->obj(), "getTransformMatrix", "([F)V");
38
39  g_detach_from_gl_context_method = env->GetMethodID(
40      g_surface_texture_class->obj(), "detachFromGLContext", "()V");
41
42  return RegisterApi(env);  //这里注册了更多Native方法
43}
44
45bool RegisterApi(JNIEnv* env) {
46  static const JNINativeMethod flutter_jni_methods[] = {
47      {
48          .name = "nativeAttach",
49          .signature = "(Lio/flutter/embedding/engine/FlutterJNI;Z)J",
50          .fnPtr = reinterpret_cast<void*>(&AttachJNI),
51      },
52      ...  //省略若干个方法
53      {
54          .name = "nativeSurfaceCreated",
55          .signature = "(JLandroid/view/Surface;)V",
56          .fnPtr = reinterpret_cast<void*>(&SurfaceCreated),
57      },
58  };
59
60  if (env->RegisterNatives(g_flutter_jni_class->obj(), flutter_jni_methods,
61                           arraysize(flutter_jni_methods)) != 0) {
62    return false;
63  }
64
65  g_handle_platform_message_method =
66      env->GetMethodID(g_flutter_jni_class->obj(), "handlePlatformMessage",
67                       "(Ljava/lang/String;[BI)V");
68
69  ...  //省略若干个方法
70  g_update_semantics_method =
71      env->GetMethodID(g_flutter_jni_class->obj(), "updateSemantics",
72                       "(Ljava/nio/ByteBuffer;[Ljava/lang/String;)V");
73  ...
74  return true;
75} 

该方法的主要工作：通过RegisterNatives()注册一些类的Native方法，用于Java调用C++的过程；通过GetMethodID()等方法记录了一些Java方法的jmethodID，用于C++调用Java的过程。将以上方法以及RegisterApi的内容全部展开，完成如下注册：

• 完成注册以下类中的所有Native方法，用于Java调用C++：
  • FlutterCallbackInformation （1个native方法）
  • FlutterJNI （nativeSurfaceCreated等21个native方法）
• 完成记录以下类中的相关Java方法，用于于C++调用Java：
  • FlutterCallbackInformation （1个方法）
  • SurfaceTexture （5个方法）
  • FlutterJNI （handlePlatformMessage等6个方法）

2.6.4 VsyncWaiterAndroid::Register

[-> flutter/shell/platform/android/vsync_waiter_android.cc]

1bool VsyncWaiterAndroid::Register(JNIEnv* env) {
2  static const JNINativeMethod methods[] = ;
3
4  jclass clazz = env->FindClass("io/flutter/view/VsyncWaiter");
5
6  g_vsync_waiter_class = new fml::jni::ScopedJavaGlobalRef<jclass>(env, clazz);
7
8  g_async_wait_for_vsync_method_ = env->GetStaticMethodID(
9      g_vsync_waiter_class->obj(), "asyncWaitForVsync", "(J)V");
10
11  return env->RegisterNatives(clazz, methods, arraysize(methods)) == 0;
12} 

该注册过程主要工作：

• 将Java层的VsyncWaiter类的nativeOnVsync()方法，映射到C++层的OnNativeVsync()方法，用于该方法的Java调用C++的过程；
• 将Java层的VsyncWaiter类的asyncWaitForVsync()方法，保存到C++层的g_async_wait_for_vsync_method_变量，用于该方法C++调用Java的过程。

2.7 nativeRecordStartTimestamp

[-> flutter/shell/platform/android/flutter_main.cc]

1static void RecordStartTimestamp(JNIEnv* env,
2                                 jclass jcaller,
3                                 jlong initTimeMillis) {
4  int64_t initTimeMicros =
5      static_cast<int64_t>(initTimeMillis) * static_cast<int64_t>(1000);
6  flutter::engine_main_enter_ts = Dart_TimelineGetMicros() - initTimeMicros;
7} 

nativeRecordStartTimestamp这是一个native方法，经过JNI调用会执行nativeRecordStartTimestamp()方法，记录引擎启动耗时时长。

三、FlutterActivity启动流程

3.1 FlutterActivity.onCreate

[-> platform/android/io/flutter/app/FlutterActivity.java]

1public class FlutterActivity extends Activity implements FlutterView.Provider, PluginRegistry, ViewFactory {    
2    private final FlutterActivityDelegate delegate = new FlutterActivityDelegate(this, this);
3    private final FlutterActivityEvents eventDelegate = delegate;
4    private final FlutterView.Provider viewProvider = delegate;
5    private final PluginRegistry pluginRegistry = delegate;
6
7    @Override
8    protected void onCreate(Bundle savedInstanceState) {
9        super.onCreate(savedInstanceState);
10        eventDelegate.onCreate(savedInstanceState); //[见小节3.2]
11    }
12} 

FlutterActivity的工作基本全权委托给FlutterActivityDelegate类，包括onCreate()，onResume()等全部的生命周期回调方法。

3.2 FlutterActivityDelegate.onCreate

[-> FlutterActivityDelegate.java]

1public void onCreate(Bundle savedInstanceState) {
2    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
3        Window window = activity.getWindow();
4        window.addFlags(LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
5        window.setStatusBarColor(0x40000000);
6        window.getDecorView().setSystemUiVisibility(PlatformPlugin.DEFAULT_SYSTEM_UI);
7    }
8    //从Intent中提取参数
9    String[] args = getArgsFromIntent(activity.getIntent());
10    // [见小节3.3]
11    FlutterMain.ensureInitializationComplete(activity.getApplicationContext(), args);
12    //此处viewFactory便是FlutterActivity，该方法目前返回值为null
13    flutterView = viewFactory.createFlutterView(activity);
14    if (flutterView == null) {
15        //nativeView同样是null
16        FlutterNativeView nativeView = viewFactory.createFlutterNativeView();
17        //[见小节3.4]
18        flutterView = new FlutterView(activity, null, nativeView);
19        flutterView.setLayoutParams(matchParent);
20        activity.setContentView(flutterView);
21        launchView = createLaunchView();
22        if (launchView != null) {
23            addLaunchView();
24        }
25    }
26
27    if (loadIntent(activity.getIntent())) {
28        return;
29    }
30
31    String appBundlePath = FlutterMain.findAppBundlePath(activity.getApplicationContext());
32    if (appBundlePath != null) {
33        //[见小节5.1]
34        runBundle(appBundlePath);
35    }
36} 

getArgsFromIntent()方法会从Intent中提取的参数，参数含义见[小节1.3.1]；

3.3 ensureInitializationComplete

[-> FlutterMain.java]

1public static void ensureInitializationComplete(Context applicationContext, String[] args) {
2    if (Looper.myLooper() != Looper.getMainLooper()) {
3      throw new IllegalStateException("ensureInitializationComplete must be called on the main thread");
4    }
5    if (sSettings == null) {
6      throw new IllegalStateException("ensureInitializationComplete must be called after startInitialization");
7    }
8    if (sInitialized) {
9        return;
10    }
11    try {
12        sResourceExtractor.waitForCompletion();
13
14        List<String> shellArgs = new ArrayList<>();
15
16        shellArgs.add("--icu-symbol-prefix=_binary_icudtl_dat");
17        ApplicationInfo applicationInfo = applicationContext.getPackageManager().getApplicationInfo(
18            applicationContext.getPackageName(), PackageManager.GET_META_DATA);
19        shellArgs.add("--icu-native-lib-path=" + applicationInfo.nativeLibraryDir + File.separator + DEFAULT_LIBRARY);
20        //args赋值过程为getArgsFromIntent()
21        if (args != null) {
22            Collections.addAll(shellArgs, args);
23        }
24        if (sIsPrecompiledAsSharedLibrary) {
25            shellArgs.add("--" + AOT_SHARED_LIBRARY_PATH + "=" +
26                new File(PathUtils.getDataDirectory(applicationContext), sAotSharedLibraryPath));
27        } else {
28            if (sIsPrecompiledAsBlobs) {
29                shellArgs.add("--" + AOT_SNAPSHOT_PATH_KEY + "=" +
30                    PathUtils.getDataDirectory(applicationContext));
31            } else {
32                shellArgs.add("--cache-dir-path=" +
33                    PathUtils.getCacheDirectory(applicationContext));
34
35                shellArgs.add("--" + AOT_SNAPSHOT_PATH_KEY + "=" +
36                    PathUtils.getDataDirectory(applicationContext) + "/" + sFlutterAssetsDir);
37            }
38            shellArgs.add("--" + AOT_VM_SNAPSHOT_DATA_KEY + "=" + sAotVmSnapshotData);
39            shellArgs.add("--" + AOT_VM_SNAPSHOT_INSTR_KEY + "=" + sAotVmSnapshotInstr);
40            shellArgs.add("--" + AOT_ISOLATE_SNAPSHOT_DATA_KEY + "=" + sAotIsolateSnapshotData);
41            shellArgs.add("--" + AOT_ISOLATE_SNAPSHOT_INSTR_KEY + "=" + sAotIsolateSnapshotInstr);
42        }
43
44        if (sSettings.getLogTag() != null) {
45            shellArgs.add("--log-tag=" + sSettings.getLogTag());
46        }
47
48        String appBundlePath = findAppBundlePath(applicationContext);
49        String appStoragePath = PathUtils.getFilesDir(applicationContext);
50        String engineCachesPath = PathUtils.getCacheDirectory(applicationContext);
51        //[见小节3.3.1]
52        nativeInit(applicationContext, shellArgs.toArray(new String[0]),
53            appBundlePath, appStoragePath, engineCachesPath);
54        sInitialized = true;
55    } catch (Exception e) {
56        throw new RuntimeException(e);
57    }
58} 

该方法重要工作：

• 保证该操作运行在主线程；
• 保证sSettings完成初始化赋值；
• 保证sResourceExtractor完成资源文件的提取工作；
• 拼接所有相关的shellArgs，包括intent中的参数；
• 执行nativeInit来初始化native相关信息；

3.3.1 FlutterMain::Init

[-> flutter/shell/platform/android/flutter_main.cc]

1void FlutterMain::Init(JNIEnv* env,
2                       jclass clazz,
3                       jobject context,
4                       jobjectArray jargs,
5                       jstring bundlePath,
6                       jstring appStoragePath,
7                       jstring engineCachesPath) {
8  std::vector<std::string> args;
9  args.push_back("flutter");
10  for (auto& arg : fml::jni::StringArrayToVector(env, jargs)) {
11    args.push_back(std::move(arg));
12  }
13  auto command_line = fml::CommandLineFromIterators(args.begin(), args.end());
14  //根据args生成Settings结构体，记录所有相关参数
15  auto settings = SettingsFromCommandLine(command_line);
16
17  settings.assets_path = fml::jni::JavaStringToString(env, bundlePath);
18
19  flutter::DartCallbackCache::SetCachePath(
20      fml::jni::JavaStringToString(env, appStoragePath));
21
22  fml::paths::InitializeAndroidCachesPath(
23      fml::jni::JavaStringToString(env, engineCachesPath));
24  //从磁盘中加载缓存
25  flutter::DartCallbackCache::LoadCacheFromDisk();
26
27  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
28    auto application_kernel_path =
29        fml::paths::JoinPaths({settings.assets_path, "kernel_blob.bin"});
30    if (fml::IsFile(application_kernel_path)) {
31      settings.application_kernel_asset = application_kernel_path;
32    }
33  }
34  //初始化observer的增加和删除方法
35  settings.task_observer_add = [](intptr_t key, fml::closure callback) {
36    fml::MessageLoop::GetCurrent().AddTaskObserver(key, std::move(callback));
37  };
38
39  settings.task_observer_remove = [](intptr_t key) {
40    fml::MessageLoop::GetCurrent().RemoveTaskObserver(key);
41  };
42  //[见小节3.3.2]
43  g_flutter_main.reset(new FlutterMain(std::move(settings)));
44} 

小节2.6.2注册了nativeInit所对应的方法FlutterMain::Init()，该方法主要功能args以及各种资源文件路径细信息都保存在Settings结构体，记录在FlutterMain中，最后记录在g_flutter_main静态变量。

3.3.2 FlutterMain初始化

[-> flutter/shell/platform/android/flutter_main.cc]

1FlutterMain::FlutterMain(flutter::Settings settings)
2    : settings_(std::move(settings)) {} 

3.4 FlutterView初始化

[-> platform/android/io/flutter/view/FlutterView.java]

1public class FlutterView extends SurfaceView implements BinaryMessenger, TextureRegistry {
2
3  public FlutterView(Context context, AttributeSet attrs, FlutterNativeView nativeView) {
4      super(context, attrs);
5
6      Activity activity = getActivity(getContext());
7
8      if (nativeView == null) {
9          //初始化FlutterNativeView [见小节3.4.1]
10          mNativeView = new FlutterNativeView(activity.getApplicationContext());
11      } else {
12          mNativeView = nativeView;
13      }
14
15      dartExecutor = mNativeView.getDartExecutor();
16      flutterRenderer = new FlutterRenderer(mNativeView.getFlutterJNI());
17      mIsSoftwareRenderingEnabled = FlutterJNI.nativeGetIsSoftwareRenderingEnabled();
18      mMetrics = new ViewportMetrics();
19      mMetrics.devicePixelRatio = context.getResources().getDisplayMetrics().density;
20      setFocusable(true);
21      setFocusableInTouchMode(true);
22
23      mNativeView.attachViewAndActivity(this, activity);
24
25      mSurfaceCallback = new SurfaceHolder.Callback() {
26          @Override
27          public void surfaceCreated(SurfaceHolder holder) {
28              assertAttached();
29              mNativeView.getFlutterJNI().onSurfaceCreated(holder.getSurface());
30          }
31
32          @Override
33          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
34              assertAttached();
35              mNativeView.getFlutterJNI().onSurfaceChanged(width, height);
36          }
37
38          @Override
39          public void surfaceDestroyed(SurfaceHolder holder) {
40              assertAttached();
41              mNativeView.getFlutterJNI().onSurfaceDestroyed();
42          }
43      };
44      getHolder().addCallback(mSurfaceCallback);
45
46      mActivityLifecycleListeners = new ArrayList<>();
47      mFirstFrameListeners = new ArrayList<>();
48
49      //创建所有的平台通道channels
50      navigationChannel = new NavigationChannel(dartExecutor);
51      keyEventChannel = new KeyEventChannel(dartExecutor);
52      lifecycleChannel = new LifecycleChannel(dartExecutor);
53      localizationChannel = new LocalizationChannel(dartExecutor);
54      platformChannel = new PlatformChannel(dartExecutor);
55      systemChannel = new SystemChannel(dartExecutor);
56      settingsChannel = new SettingsChannel(dartExecutor);
57
58      //创建并设置插件
59      PlatformPlugin platformPlugin = new PlatformPlugin(activity, platformChannel);
60      addActivityLifecycleListener(platformPlugin);
61      mImm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
62      mTextInputPlugin = new TextInputPlugin(this, dartExecutor);
63      androidKeyProcessor = new AndroidKeyProcessor(keyEventChannel, mTextInputPlugin);
64      androidTouchProcessor = new AndroidTouchProcessor(flutterRenderer);
65
66      //发送初始化平台台的消息发送给Dart
67      sendLocalesToDart(getResources().getConfiguration());
68      sendUserPlatformSettingsToDart();
69  }
70  ...
71} 

3.4.1 FlutterNativeView初始化

[-> FlutterNativeView.java]

1public class FlutterNativeView implements BinaryMessenger {
2  public FlutterNativeView(@NonNull Context context) {
3      this(context, false);
4  }
5
6  public FlutterNativeView(@NonNull Context context, boolean isBackgroundView) {
7      mContext = context;
8      mPluginRegistry = new FlutterPluginRegistry(this, context);
9      mFlutterJNI = new FlutterJNI();
10      mFlutterJNI.setRenderSurface(new RenderSurfaceImpl());
11      this.dartExecutor = new DartExecutor(mFlutterJNI);
12      mFlutterJNI.addEngineLifecycleListener(new EngineLifecycleListenerImpl());
13      attach(this, isBackgroundView); //[见小节3.4.2]
14  }
15} 

该方法主功能：

• 初始化对象FlutterPluginRegistry；
• 初始化对象FlutterJNI；
• 初始化对象RenderSurfaceImpl，并赋值给mFlutterJNI的成员变量renderSurface；
• 初始化对象DartExecutor；
• 设置引擎生命周期回调监听器；
• 并执行attach方法

3.4.2 FlutterNativeView.attach

[-> FlutterNativeView.java]

1private void attach(FlutterNativeView view, boolean isBackgroundView) {
2    mFlutterJNI.attachToNative(isBackgroundView); //[见小节3.4.3]
3    //将dartExecutor.messenger赋值给mFlutterJNI.platformMessageHandler
4    dartExecutor.onAttachedToJNI();
5} 

[小节2.6.3]的过程已经注册了FlutterJNI的attachToNative()方法，相对应的Native方法为AttachJNI()

3.4.3 FlutterJNI.attachToNative

[-> FlutterJNI.java]

1public void attachToNative(boolean isBackgroundView) {
2  nativePlatformViewId = nativeAttach(this, isBackgroundView);  //[见小节3.4.4]
3} 

3.4.4 AttachJNI

[-> flutter/shell/platform/android/platform_view_android_jni.cc]

1static jlong AttachJNI(JNIEnv* env,
2                       jclass clazz,
3                       jobject flutterJNI,
4                       jboolean is_background_view) {
5  fml::jni::JavaObjectWeakGlobalRef java_object(env, flutterJNI);
6   //[见小节4.1]
7  auto shell_holder = std::make_unique<AndroidShellHolder>(
8      FlutterMain::Get().GetSettings(), java_object, is_background_view);
9  if (shell_holder->IsValid()) {
10    return reinterpret_cast<jlong>(shell_holder.release());
11  } else {
12    return 0;
13  }
14} 

该方法主要是为了在引擎层初始化AndroidShellHolder对象，详见[小节4.1]。

四、Flutter引擎启动

4.1 AndroidShellHolder初始化

[-> flutter/shell/platform/android/android_shell_holder.cc]

1AndroidShellHolder::AndroidShellHolder(
2    flutter::Settings settings,
3    fml::jni::JavaObjectWeakGlobalRef java_object,
4    bool is_background_view)
5    : settings_(std::move(settings)), java_object_(java_object) {
6  static size_t shell_count = 1;
7  auto thread_label = std::to_string(shell_count++);
8  //创建线程私有的key
9  FML_CHECK(pthread_key_create(&thread_destruct_key_, ThreadDestructCallback) ==
10            0);
11
12  if (is_background_view) {
13    thread_host_ = {thread_label, ThreadHost::Type::UI};
14  } else {
15    //创建目标线程[见小节4.2]
16    thread_host_ = {thread_label, ThreadHost::Type::UI | ThreadHost::Type::GPU |
17                                      ThreadHost::Type::IO};
18  }
19
20  //当UI和GPU线程退出时从JNI分离。
21  auto jni_exit_task([key = thread_destruct_key_]() {
22    FML_CHECK(pthread_setspecific(key, reinterpret_cast<void*>(1)) == 0);
23  });
24  thread_host_.ui_thread->GetTaskRunner()->PostTask(jni_exit_task);
25  if (!is_background_view) {
26    thread_host_.gpu_thread->GetTaskRunner()->PostTask(jni_exit_task);
27  }
28
29  fml::WeakPtr<PlatformViewAndroid> weak_platform_view;
30  Shell::CreateCallback<PlatformView> on_create_platform_view =
31      [is_background_view, java_object, &weak_platform_view](Shell& shell) {
32        std::unique_ptr<PlatformViewAndroid> platform_view_android;
33        if (is_background_view) {
34          ...
35        } else {
36          platform_view_android = std::make_unique<PlatformViewAndroid>(
37              shell,                  
38              shell.GetTaskRunners(),  
39              java_object,           
40              shell.GetSettings().enable_software_rendering
41          );
42        }
43        weak_platform_view = platform_view_android->GetWeakPtr();
44        return platform_view_android;
45      };
46
47  Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {
48    return std::make_unique<Rasterizer>(shell.GetTaskRunners());
49  };
50
51  // 当前主线程初始化MesageLoop [见小节4.2.2]
52  fml::MessageLoop::EnsureInitializedForCurrentThread();
53  fml::RefPtr<fml::TaskRunner> gpu_runner;
54  fml::RefPtr<fml::TaskRunner> ui_runner;
55  fml::RefPtr<fml::TaskRunner> io_runner;
56  fml::RefPtr<fml::TaskRunner> platform_runner =
57      fml::MessageLoop::GetCurrent().GetTaskRunner();
58  if (is_background_view) {
59    ...
60  } else {
61    gpu_runner = thread_host_.gpu_thread->GetTaskRunner();
62    ui_runner = thread_host_.ui_thread->GetTaskRunner();
63    io_runner = thread_host_.io_thread->GetTaskRunner();
64  }
65  //创建task_runners对象
66  flutter::TaskRunners task_runners(thread_label,    
67                                    platform_runner, gpu_runner,    
68                                    ui_runner,  io_runner );
69  // 创建Shell对象 [见小节4.3]
70  shell_ =  Shell::Create(task_runners, settings_,              
71                    on_create_platform_view,  on_create_rasterizer);
72
73  platform_view_ = weak_platform_view;
74  is_valid_ = shell_ != nullptr;
75  if (is_valid_) {
76    //提升ui线程和gpu线程的优先级
77    task_runners.GetGPUTaskRunner()->PostTask([]() {
78      if (::setpriority(PRIO_PROCESS, gettid(), -5) != 0) {
79        if (::setpriority(PRIO_PROCESS, gettid(), -2) != 0) {
80          FML_LOG(ERROR) << "Failed to set GPU task runner priority";
81        }
82      }
83    });
84    task_runners.GetUITaskRunner()->PostTask([]() {
85      if (::setpriority(PRIO_PROCESS, gettid(), -1) != 0) {
86        FML_LOG(ERROR) << "Failed to set UI task runner priority";
87      }
88    });
89  }
90} 

该方法的主要功能：

• 创建ui，gpu，io这3个线程，并分别初始化MessageLoop
• on_create_platform_view
• on_create_rasterizer
• 创建Shell对象，TaskRunners对象

另外，关于pthread_key_create(pthread_key_t *key, void (destructor)(void))，用于创建线程内私有的全局变量，其中第一个参数为key，第二参数为析构函数，等线程退出时会执行。

4.2 ThreadHost初始化

[-> flutter/shell/common/thread_host.cc]

1ThreadHost::ThreadHost(std::string name_prefix, uint64_t mask) {
2  if (mask & ThreadHost::Type::Platform) {
3    platform_thread = std::make_unique<fml::Thread>(name_prefix + ".platform");
4  }
5
6  if (mask & ThreadHost::Type::UI) {
7    //创建线程 [见小节4.2.1]
8    ui_thread = std::make_unique<fml::Thread>(name_prefix + ".ui");
9  }
10
11  if (mask & ThreadHost::Type::GPU) {
12    gpu_thread = std::make_unique<fml::Thread>(name_prefix + ".gpu");
13  }
14
15  if (mask & ThreadHost::Type::IO) {
16    io_thread = std::make_unique<fml::Thread>(name_prefix + ".io");
17  }
18} 

根据传递的参数，可知首次创建AndroidShellHolder实例的过程，会创建1.ui, 1.gpu, 1.io这3个线程。每个线程Thread初始化过程，都会创建相应的MessageLoop、TaskRunner对象，然后进入pollOnce轮询等待状态，更多详见深入理解Flutter消息机制的MessageLoop启动部分。

4.3 Shell::Create

[-> flutter/shell/common/shell.cc]

1std::unique_ptr<Shell> Shell::Create(
2    TaskRunners task_runners,
3    Settings settings,
4    Shell::CreateCallback<PlatformView> on_create_platform_view,
5    Shell::CreateCallback<Rasterizer> on_create_rasterizer) {
6  PerformInitializationTasks(settings); //[见小节4.3.1]
7
8  TRACE_EVENT0("flutter", "Shell::Create");
9
10  auto vm = DartVMRef::Create(settings); //[见小节4.4]
11  auto vm_data = vm->GetVMData();
12  //[见小节4.5]
13  return Shell::Create(std::move(task_runners),             
14                       std::move(settings),                 
15                       vm_data->GetIsolateSnapshot(),       // isolate snapshot
16                       DartSnapshot::Empty(),               // shared snapshot
17                       std::move(on_create_platform_view),  
18                       std::move(on_create_rasterizer),     
19                       std::move(vm)                        
20  );
21} 

4.3.1 PerformInitializationTasks

[-> flutter/shell/common/shell.cc]

1static void PerformInitializationTasks(const Settings& settings) {
2  {
3    fml::LogSettings log_settings;
4    //设置log输出的最小级别
5    log_settings.min_log_level =
6        settings.verbose_logging ? fml::LOG_INFO : fml::LOG_ERROR;
7    fml::SetLogSettings(log_settings);
8  }
9
10  static std::once_flag gShellSettingsInitialization = {};
11  std::call_once(gShellSettingsInitialization, [&settings] {
12    RecordStartupTimestamp(); //记录启动时间
13
14    tonic::SetLogHandler([](const char* message) { FML_LOG(ERROR) << message; });
15
16    if (settings.trace_skia) {
17      InitSkiaEventTracer(settings.trace_skia);
18    }
19
20    if (!settings.skia_deterministic_rendering_on_cpu) {
21      SkGraphics::Init();
22    } else {
23      FML_DLOG(INFO) << "Skia deterministic rendering is enabled.";
24    }
25
26    if (settings.icu_initialization_required) {
27      if (settings.icu_data_path.size() != 0) {
28        fml::icu::InitializeICU(settings.icu_data_path);
29      } else if (settings.icu_mapper) {
30        fml::icu::InitializeICUFromMapping(settings.icu_mapper());
31      } else {
32        FML_DLOG(WARNING) << "Skipping ICU initialization in the shell.";
33      }
34    }
35  });
36} 

默认情况只有ERROR级别的日志才会输出，除非在启动的时候带上参数verbose_logging，则会打印出INFO级别的日志。

4.4 DartVMRef::Create

[-> flutter/runtime/dart_vm_lifecycle.cc]

1static std::weak_ptr<DartVM> gVM;
2
3DartVMRef DartVMRef::Create(Settings settings,
4                            fml::RefPtr<DartSnapshot> vm_snapshot,
5                            fml::RefPtr<DartSnapshot> isolate_snapshot,
6                            fml::RefPtr<DartSnapshot> shared_snapshot) {
7  std::lock_guard<std::mutex> lifecycle_lock(gVMMutex);
8
9  //当该进程存在一个正在运行虚拟机，则获取其强引用，复用该虚拟机
10  if (auto vm = gVM.lock()) {
11    return DartVMRef{std::move(vm)};
12  }
13  ...
14
15  auto isolate_name_server = std::make_shared<IsolateNameServer>();
16  //创建虚拟机
17  auto vm = DartVM::Create(std::move(settings),          
18                           std::move(vm_snapshot),       
19                           std::move(isolate_snapshot),  
20                           std::move(shared_snapshot),   
21                           isolate_name_server           
22  );
23  ...
24  gVMData = vm->GetVMData();
25  gVMServiceProtocol = vm->GetServiceProtocol();
26  gVMIsolateNameServer = isolate_name_server;
27  gVM = vm;
28
29  if (settings.leak_vm) {
30    gVMLeak = new std::shared_ptr<DartVM>(vm);
31  }
32  return DartVMRef{std::move(vm)};
33} 

更多关于虚拟机创建过程，详见深入理解Dart虚拟机启动的[小节2.1]部分。

4.5 Shell::Create

[-> flutter/shell/common/shell.cc]

1std::unique_ptr<Shell> Shell::Create(
2    TaskRunners task_runners,
3    Settings settings,
4    fml::RefPtr<const DartSnapshot> isolate_snapshot,
5    fml::RefPtr<const DartSnapshot> shared_snapshot,
6    Shell::CreateCallback<PlatformView> on_create_platform_view,
7    Shell::CreateCallback<Rasterizer> on_create_rasterizer,
8    DartVMRef vm) {
9  ...
10
11  fml::AutoResetWaitableEvent latch;
12  std::unique_ptr<Shell> shell;
13  fml::TaskRunner::RunNowOrPostTask(
14      task_runners.GetPlatformTaskRunner(),
15      fml::MakeCopyable([&latch,                                          //
16                         vm = std::move(vm),                              //
17                         &shell,                                          //
18                         task_runners = std::move(task_runners),          //
19                         settings,                                        //
20                         isolate_snapshot = std::move(isolate_snapshot),  //
21                         shared_snapshot = std::move(shared_snapshot),    //
22                         on_create_platform_view,                         //
23                         on_create_rasterizer                             //
24  ]() mutable {
25        //[见小节4.5.1]
26        shell = CreateShellOnPlatformThread(std::move(vm),
27                                            std::move(task_runners),      //
28                                            settings,                     //
29                                            std::move(isolate_snapshot),  //
30                                            std::move(shared_snapshot),   //
31                                            on_create_platform_view,      //
32                                            on_create_rasterizer          //
33        );
34        latch.Signal();
35      }));
36  latch.Wait();  //等待完成
37  return shell;
38} 

4.5.1 Shell::CreateShellOnPlatformThread

[-> flutter/shell/common/shell.cc]

1std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
2    blink::TaskRunners task_runners,
3    blink::Settings settings,
4    Shell::CreateCallback<PlatformView> on_create_platform_view,
5    Shell::CreateCallback<Rasterizer> on_create_rasterizer) {
6
7    //创建Shell对象[见小节4.6]
8    auto shell = std::unique_ptr<Shell>(new Shell(task_runners, settings));
9
10    //在主线程创建platform view [见小节4.7]
11    auto platform_view = on_create_platform_view(*shell.get());
12
13    //由platform view创建vsync waiter [见小节4.8]
14    auto vsync_waiter = platform_view->CreateVSyncWaiter();
15
16    fml::AutoResetWaitableEvent io_latch;
17    std::unique_ptr<ShellIOManager> io_manager;
18    auto io_task_runner = shell->GetTaskRunners().GetIOTaskRunner();
19    fml::TaskRunner::RunNowOrPostTask(
20        io_task_runner,
21        [&io_latch, &io_manager, &platform_view, io_task_runner ]() {
22          TRACE_EVENT0("flutter", "ShellSetupIOSubsystem");
23          // 在io线程中创建ShellIOManager对象 [见小节4.9]
24          io_manager = std::make_unique<ShellIOManager>(
25              platform_view->CreateResourceContext(), io_task_runner);
26          io_latch.Signal();
27        });
28    io_latch.Wait();
29
30    fml::AutoResetWaitableEvent gpu_latch;
31    std::unique_ptr<Rasterizer> rasterizer;
32    fml::WeakPtr<SnapshotDelegate> snapshot_delegate;
33    fml::TaskRunner::RunNowOrPostTask(
34        task_runners.GetGPUTaskRunner(),
35        [&gpu_latch, &rasterizer, on_create_rasterizer, shell = shell.get(), &snapshot_delegate]() {
36          TRACE_EVENT0("flutter", "ShellSetupGPUSubsystem");
37          // 在gpu线程中创建Rasterizer对象 [见小节4.10]
38          if (auto new_rasterizer = on_create_rasterizer(*shell)) {
39            rasterizer = std::move(new_rasterizer);
40            snapshot_delegate = rasterizer->GetSnapshotDelegate();
41          }
42          gpu_latch.Signal();
43        });
44    gpu_latch.Wait();
45
46    fml::AutoResetWaitableEvent ui_latch;
47    std::unique_ptr<Engine> engine;
48    fml::TaskRunner::RunNowOrPostTask(
49        shell->GetTaskRunners().GetUITaskRunner(),
50        fml::MakeCopyable([&ui_latch,                                         //
51                           &engine,                                           //
52                           shell = shell.get(),                               //
53                           isolate_snapshot = std::move(isolate_snapshot),    //
54                           shared_snapshot = std::move(shared_snapshot),      //
55                           vsync_waiter = std::move(vsync_waiter),            //
56                           snapshot_delegate = std::move(snapshot_delegate),  //
57                           io_manager = io_manager->GetWeakPtr()              //
58    ]() mutable {
59          TRACE_EVENT0("flutter", "ShellSetupUISubsystem");
60          const auto& task_runners = shell->GetTaskRunners();
61          // 创建Animator对象 [见小节4.11]
62          auto animator = std::make_unique<Animator>(*shell, task_runners,
63                                                     std::move(vsync_waiter));
64          // 在ui线程中创建Engine对象 [见小节4.12]
65          engine = std::make_unique<Engine>(*shell,                        //
66                                            *shell->GetDartVM(),           //
67                                            std::move(isolate_snapshot),   //
68                                            std::move(shared_snapshot),    //
69                                            task_runners,                  //
70                                            shell->GetSettings(),          //
71                                            std::move(animator),           //
72                                            std::move(snapshot_delegate),  //
73                                            std::move(io_manager)          //
74          );
75          ui_latch.Signal();
76        }));
77
78    ui_latch.Wait();
79
80    // [见小节4.13]
81    if (!shell->Setup(std::move(platform_view), std::move(engine),      
82                      std::move(rasterizer), std::move(io_manager))  
83    ) {
84      return nullptr;
85    }
86    return shell;
87}