Flutter 安卓平台源码剖析（一）

Love The Way You Lie 2024-04-18 09:32 223阅读 0赞

### 文章目录 ###

*   *  前言
     *  启动流程
     *   *  入口Activity
         *   *  环境初始化
             *  创建 splash view
         *  Application启动
         *  Java层与Flutter引擎关联
         *  运行Dart代码
         *  总结
     *  视频课程
     *  欢迎关注公众号：编程之路从0到1

博主相关文章列表  
[**Flutter 框架实现原理**][Flutter]  
[**Flutter 框架层启动源码剖析**][Flutter 1]  
[**Flutter 页面更新流程剖析**][Flutter 2]  
[**Flutter 事件处理源码剖析**][Flutter 3]  
[**Flutter 路由源码剖析**][Flutter 4]  
[**Flutter 安卓平台源码剖析（一）**][Flutter 5]  
[**Flutter 自定义控件之RenderObject**][Flutter _RenderObject]

## 前言 ##

做技术，只有弄懂了原理，才能遇事不慌，手中无码，心中有码。这篇文章主要研究Flutter 在安卓平台上的启动流程源码。

## 启动流程 ##

### 入口Activity ###

当我们创建一个Flutter app工程时，打开android目录下的源码，会发现有一个`MainActivity`继承自`FlutterActivity`，整个`MainActivity`非常简单，只在`onCreate`下加了一行代码`GeneratedPluginRegistrant.registerWith(this)`，那么`FlutterActivity`又是何方神圣呢？`FlutterActivity`的源码在Flutter SDK的jar包中，想要研究Flutter源码，第一件事就是需要下载一套SDK源码，我们可以在GitHub上下载 [engine源码][engine]

public class MainActivity extends FlutterActivity { 
      @Override
      protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState);
        GeneratedPluginRegistrant.registerWith(this);
      }
    }

`engine\src\flutter\shell\platform\android\io\flutter\app\FlutterActivity.java`  
省略部分源码，删除注释后代码如下

public class FlutterActivity extends Activity implements 
    FlutterView.Provider, PluginRegistry, ViewFactory { 
        private static final String TAG = "FlutterActivity";
        
        private final FlutterActivityDelegate delegate = new FlutterActivityDelegate(this, this);
    
        private final FlutterActivityEvents eventDelegate = delegate;
        private final FlutterView.Provider viewProvider = delegate;
        private final PluginRegistry pluginRegistry = delegate;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            eventDelegate.onCreate(savedInstanceState);
        }
    
        @Override
        protected void onStart() { 
            super.onStart();
            eventDelegate.onStart();
        }
    
        @Override
        protected void onResume() { 
            super.onResume();
            eventDelegate.onResume();
        }
    
        @Override
        protected void onDestroy() { 
            eventDelegate.onDestroy();
            super.onDestroy();
        }
    
       // ...省略部分源码...
    }

可以看到`FlutterActivity`继承自`Activity`，并实现了三个接口，`FlutterActivity`的生命周期方法，均由一个代理类`FlutterActivityDelegate`处理。

`engine\src\flutter\shell\platform\android\io\flutter\app\FlutterActivityDelegate.java`

@Override
        public void onCreate(Bundle savedInstanceState) { 
            // 根据当前系统版本设置沉浸式状态栏
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { 
                Window window = activity.getWindow();
                window.addFlags(LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
                window.setStatusBarColor(0x40000000);
                window.getDecorView().setSystemUiVisibility(PlatformPlugin.DEFAULT_SYSTEM_UI);
            }
            // 获取intent传入的参数信息
            String[] args = getArgsFromIntent(activity.getIntent());
            // 初始化一些参数配置信息，包括打包的flutter代码路径、应用存储目录、引擎缓存目录等
            FlutterMain.ensureInitializationComplete(activity.getApplicationContext(), args);
            
            flutterView = viewFactory.createFlutterView(activity);
            // 真正创建contentView的地方
            if (flutterView == null) { 
                FlutterNativeView nativeView = viewFactory.createFlutterNativeView();
                flutterView = new FlutterView(activity, null, nativeView);
                flutterView.setLayoutParams(matchParent);
                activity.setContentView(flutterView);
                launchView = createLaunchView();
                if (launchView != null) { 
                    addLaunchView();
                }
            }
    
            if (loadIntent(activity.getIntent())) { 
                return;
            }
    
            String appBundlePath = FlutterMain.findAppBundlePath(activity.getApplicationContext());
            if (appBundlePath != null) { 
                runBundle(appBundlePath);
            }
        }

我们自然是要找到`onCreate`方法，以上代码我增加了一点注释，我们要快速定位到关键代码，什么是关键代码，看到了`activity.setContentView(flutterView);`，这里就是关键代码，终于见到了我们熟悉的`setContentView`了。这里我们不禁要问，这个`flutterView`到底是个什么View?

一开始我们就知道`ViewFactory`是`FlutterActivity`实现的，这里`createFlutterView`方法实现也在`FlutterActivity`里，但这个方法始终返回空，再看`createFlutterNativeView`方法，仍然是返回空

@Override
        public FlutterNativeView createFlutterNativeView() { 
            return null;
        }
        
        @Override
        public FlutterNativeView createFlutterNativeView() { 
            return null;
        }

这里真正的`flutterView`实际上是通过`flutterView = new FlutterView(activity, null, nativeView)`这行代码`new`出来的，然后传递给`setContentView`

接下来直接看到`FlutterView`源码（省略部分代码）

public class FlutterView extends SurfaceView implements BinaryMessenger, TextureRegistry { 
        private static final String TAG = "FlutterView";
    
        public FlutterView(Context context, AttributeSet attrs, FlutterNativeView nativeView) { 
            super(context, attrs);
    
            Activity activity = getActivity(getContext());
            if (activity == null) { 
                throw new IllegalArgumentException("Bad context");
            }
    
            if (nativeView == null) { 
                mNativeView = new FlutterNativeView(activity.getApplicationContext());
            } else { 
                mNativeView = nativeView;
            }
    
            dartExecutor = mNativeView.getDartExecutor();
            flutterRenderer = new FlutterRenderer(mNativeView.getFlutterJNI());
            mIsSoftwareRenderingEnabled = FlutterJNI.nativeGetIsSoftwareRenderingEnabled();
            mMetrics = new ViewportMetrics();
            mMetrics.devicePixelRatio = context.getResources().getDisplayMetrics().density;
            setFocusable(true);
            setFocusableInTouchMode(true);
    
            mNativeView.attachViewAndActivity(this, activity);
    
            mSurfaceCallback = new SurfaceHolder.Callback() { 
                @Override
                public void surfaceCreated(SurfaceHolder holder) { 
                    assertAttached();
                    mNativeView.getFlutterJNI().onSurfaceCreated(holder.getSurface());
                }
    
                @Override
                public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { 
                    assertAttached();
                    mNativeView.getFlutterJNI().onSurfaceChanged(width, height);
                }
    
                @Override
                public void surfaceDestroyed(SurfaceHolder holder) { 
                    assertAttached();
                    mNativeView.getFlutterJNI().onSurfaceDestroyed();
                }
            };
            getHolder().addCallback(mSurfaceCallback);
    
            mActivityLifecycleListeners = new ArrayList<>();
            mFirstFrameListeners = new ArrayList<>();
    
            // Create all platform channels
            navigationChannel = new NavigationChannel(dartExecutor);
            keyEventChannel = new KeyEventChannel(dartExecutor);
            lifecycleChannel = new LifecycleChannel(dartExecutor);
            localizationChannel = new LocalizationChannel(dartExecutor);
            platformChannel = new PlatformChannel(dartExecutor);
            systemChannel = new SystemChannel(dartExecutor);
            settingsChannel = new SettingsChannel(dartExecutor);
    
            // Create and setup plugins
            PlatformPlugin platformPlugin = new PlatformPlugin(activity, platformChannel);
            addActivityLifecycleListener(platformPlugin);
            mImm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            mTextInputPlugin = new TextInputPlugin(this, dartExecutor);
            androidKeyProcessor = new AndroidKeyProcessor(keyEventChannel, mTextInputPlugin);
            androidTouchProcessor = new AndroidTouchProcessor(flutterRenderer);
    
            // Send initial platform information to Dart
            sendLocalesToDart(getResources().getConfiguration());
            sendUserPlatformSettingsToDart();
        }

到这里就明白了，`FlutterView`实际上就是安卓中的`SurfaceView`，因为`SurfaceView`是双缓冲的，可以在子线程更新UI，性能高效，因此通常是用来做游戏开发、视频直播。经过简单的源码分析，我们大致能明白Flutter在安卓上的实现方式，整个Flutter开发的app都是在一个`Activity`中进行渲染的，这就有点像现在前端流行的所谓单页应用。

还个方法中还创建了各种平台插件和`platform channel`，用于Flutter层和原生代码之间的数据传递。

#### 环境初始化 ####

现在我们再回过头来看一下刚刚漏过的一些代码，看看它们做了些什么事  
`onCreate`函数中有调用`FlutterMain.ensureInitializationComplete(activity.getApplicationContext(), args)`

/** * Blocks until initialization of the native system has completed. */
        public static void ensureInitializationComplete(@NonNull Context applicationContext, @Nullable String[] args) { 
            if (Looper.myLooper() != Looper.getMainLooper()) { 
              throw new IllegalStateException("ensureInitializationComplete must be called on the main thread");
            }
            if (sSettings == null) { 
              throw new IllegalStateException("ensureInitializationComplete must be called after startInitialization");
            }
            if (sInitialized) { 
                return;
            }
            try { 
                sResourceExtractor.waitForCompletion();
    
                List<String> shellArgs = new ArrayList<>();
                shellArgs.add("--icu-symbol-prefix=_binary_icudtl_dat");
    
                ApplicationInfo applicationInfo = getApplicationInfo(applicationContext);
                shellArgs.add("--icu-native-lib-path=" + applicationInfo.nativeLibraryDir + File.separator + DEFAULT_LIBRARY);
    
               // ...省略...
    
                if (sSettings.getLogTag() != null) { 
                    shellArgs.add("--log-tag=" + sSettings.getLogTag());
                }
    
                String appBundlePath = findAppBundlePath(applicationContext);
                String appStoragePath = PathUtils.getFilesDir(applicationContext);
                String engineCachesPath = PathUtils.getCacheDirectory(applicationContext);
                nativeInit(applicationContext, shellArgs.toArray(new String[0]),
                    appBundlePath, appStoragePath, engineCachesPath);
    
                sInitialized = true;
            } catch (Exception e) { 
                Log.e(TAG, "Flutter initialization failed.", e);
                throw new RuntimeException(e);
            }
        }

该方法注释已经明确告诉我们，这是一个阻塞的方法，直到底层初始化完成。这意味着该方法执行会影响app的启动速度。总的来说，该方法做了几件事，它保证初始化操作在主线程运行，调用`sResourceExtractor.waitForCompletion()`完成资源文件的提取工作，拼接所有相关的`shellArgs`参数，包括`intent`中的参数，配置`dart`代码编译产物appBundle路径，应用存储、引擎缓存目录等信息，  
最后通过执行`nativeInit`函数在c++层初始化这些信息

#### 创建 splash view ####

接下来，还有一个地方值得一说，在创建`FlutterView`之后，调用了一个`createLaunchView`方法

private View createLaunchView() { 
            if (!showSplashScreenUntilFirstFrame()) { 
                return null;
            }
            final Drawable launchScreenDrawable = getLaunchScreenDrawableFromActivityTheme();
            if (launchScreenDrawable == null) { 
                return null;
            }
            final View view = new View(activity);
            view.setLayoutParams(matchParent);
            view.setBackground(launchScreenDrawable);
            return view;
        }

这个方法，其实就是在Flutter启动后添加一个`splash view`。大家知道，在Flutter应用启动之后，会有一小段白屏的时间，之所以会白屏，就是这个方法导致的。目前的解决办法，就是手动添加一个设计好的闪屏页，平滑的过度一下。那么如何修改默认的白屏页，设置我们自己的`splash view`呢？

private Drawable getLaunchScreenDrawableFromActivityTheme() { 
            TypedValue typedValue = new TypedValue();
            if (!activity.getTheme().resolveAttribute(
                android.R.attr.windowBackground,
                typedValue,
                true)) { 
                return null;
            }
            if (typedValue.resourceId == 0) { 
                return null;
            }
            try { 
                return activity.getResources().getDrawable(typedValue.resourceId);
            } catch (NotFoundException e) { 
                Log.e(TAG, "Referenced launch screen windowBackground resource does not exist");
                return null;
            }
        }

可以看到，这个`Drawable`其实是从主题的`windowBackground`中取的，我们打开app工程中的`styles.xml`

看到，`windowBackground`其实是指定为`launch_background`，在`drawable`文件夹下找到它

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
        <item android:drawable="@android:color/white" />
    
        
        
    </layer-list>

这里默认背景确实被设置成了白色，并且还友好的给出了一个设置图片的示例，将注释的代码打开，就可以设置自己的`splash view`

### Application启动 ###

我们知道安卓app启动时，首先调用的是`Application`的`onCreate`，现在来看一看Flutter应用的Application做了些什么  
`flutter\shell\platform\android\io\flutter\app\FlutterApplication.java`

public class FlutterApplication extends Application { 
        @Override
        @CallSuper
        public void onCreate() { 
            super.onCreate();
            FlutterMain.startInitialization(this);
        }
    
        private Activity mCurrentActivity = null;
        public Activity getCurrentActivity() { 
            return mCurrentActivity;
        }
        public void setCurrentActivity(Activity mCurrentActivity) { 
            this.mCurrentActivity = mCurrentActivity;
        }
    }

整个`FlutterApplication`比较简单，主要调用了`FlutterMain.startInitialization(this)`开启初始化

public static void startInitialization(@NonNull Context applicationContext, @NonNull Settings settings) { 
            if (Looper.myLooper() != Looper.getMainLooper()) { 
              throw new IllegalStateException("startInitialization must be called on the main thread");
            }
            // Do not run startInitialization more than once.
            if (sSettings != null) { 
              return;
            }
    
            sSettings = settings;
    
            long initStartTimestampMillis = SystemClock.uptimeMillis();
            initConfig(applicationContext);
            initAot(applicationContext);
            initResources(applicationContext);
    
            System.loadLibrary("flutter");
            long initTimeMillis = SystemClock.uptimeMillis() - initStartTimestampMillis;
            nativeRecordStartTimestamp(initTimeMillis);
        }

该方法注释表明，它是用来初始化底层的Flutter 引擎的，主要做了几件事，

*  初始化配置
 *  获取是否预编译模式
 *  初始化并提取资源文件
 *  加载libflutter.so

### Java层与Flutter引擎关联 ###

在`FlutterApplication`中加载了引擎的so，我们不禁要问，那Flutter引擎又是在哪创建的，怎么与原生Java代码关联起来的呢？

在`FlutterView`构造方法中创建了`FlutterNativeView`，看到`FlutterNativeView`的构造方法

public FlutterNativeView(@NonNull Context context, boolean isBackgroundView) { 
            mContext = context;
            mPluginRegistry = new FlutterPluginRegistry(this, context);
            mFlutterJNI = new FlutterJNI();
            mFlutterJNI.setRenderSurface(new RenderSurfaceImpl());
            this.dartExecutor = new DartExecutor(mFlutterJNI);
            mFlutterJNI.addEngineLifecycleListener(new EngineLifecycleListenerImpl());
            attach(this, isBackgroundView);
            assertAttached();
        }

在这里主要创建了`FlutterJNI`对象，并调用了一个关键方法`attach`，一路跟踪该方法调用

private void attach(FlutterNativeView view, boolean isBackgroundView) { 
            mFlutterJNI.attachToNative(isBackgroundView);
            dartExecutor.onAttachedToJNI();
        }

`flutter\shell\platform\android\io\flutter\embedding\engine\FlutterJNI.java`

public void attachToNative(boolean isBackgroundView) { 
        ensureRunningOnMainThread();
        ensureNotAttachedToNative();
        nativePlatformViewId = nativeAttach(this, isBackgroundView);
      }
      
      private native long nativeAttach(FlutterJNI flutterJNI, boolean isBackgroundView);

最后发现调用了一个`native`方法，并将`FlutterJNI`实例对象自身传入了`C++`层。这里，我们怎么才能找到`native`方法所对应的C++源码呢？

我这里就介绍一种最简单的傻瓜式方法，不需要太多技巧，大家可以下载一个FileLocatorPro工具，它是Windows平台上的文本搜索神器，建议最好安装一个。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
为了搜索更快，我们不仅仅将下载的Flutter engine源码根路径设置进去，还要缩写一点范围，我这里将源码根目录下的`flutter\shell\platform\android`设置为搜索路径，另外还可以在文件名称一栏填入`*.cc`，表示仅搜索以`.cc`作为后缀的文件，这里`.cc`是C++源文件后缀名。最后我们秒搜到了匹配的内容

`flutter\shell\platform\android\platform_view_android_jni.cc`

static const JNINativeMethod flutter_jni_methods[] = { 
          // Start of methods from FlutterNativeView
          { 
              .name = "nativeAttach",
              .signature = "(Lio/flutter/embedding/engine/FlutterJNI;Z)J",
              .fnPtr = reinterpret_cast<void*>(&AttachJNI),
          }

这是一个结构体数组，可以看到`nativeAttach`对应的函数指针是`AttachJNI`，我们继续在当前文件中找到`AttachJNI`函数，它就是Java层`nativeAttach`方法的具体实现

// Called By Java
    static jlong AttachJNI(JNIEnv* env,
                           jclass clazz,
                           jobject flutterJNI,
                           jboolean is_background_view) { 
      fml::jni::JavaObjectWeakGlobalRef java_object(env, flutterJNI);
      auto shell_holder = std::make_unique<AndroidShellHolder>(
          FlutterMain::Get().GetSettings(), java_object, is_background_view);
      if (shell_holder->IsValid()) { 
        return reinterpret_cast<jlong>(shell_holder.release());
      } else { 
        return 0;
      }
    }

这里的C++代码主要干了一件事，就是通过`make_unique`来创建了一个`AndroidShellHolder`对象，因此我们需要找到`AndroidShellHolder`类的构造方法

`flutter/shell/platform/android/android_shell_holder.cc`

AndroidShellHolder::AndroidShellHolder(
        flutter::Settings settings,
        fml::jni::JavaObjectWeakGlobalRef java_object,
        bool is_background_view)
        : settings_(std::move(settings)), java_object_(java_object) { 
      static size_t shell_count = 1;
      auto thread_label = std::to_string(shell_count++);
    
      FML_CHECK(pthread_key_create(&thread_destruct_key_, ThreadDestructCallback) ==
                0);
    
      if (is_background_view) { 
        thread_host_ = { thread_label, ThreadHost::Type::UI};
      } else { 
        thread_host_ = { thread_label, ThreadHost::Type::UI | ThreadHost::Type::GPU |
                                          ThreadHost::Type::IO};
      }
    
      // ...省略...
    
      // The current thread will be used as the platform thread. Ensure that the
      // message loop is initialized.
      fml::MessageLoop::EnsureInitializedForCurrentThread();
      fml::RefPtr<fml::TaskRunner> gpu_runner;
      fml::RefPtr<fml::TaskRunner> ui_runner;
      fml::RefPtr<fml::TaskRunner> io_runner;
      fml::RefPtr<fml::TaskRunner> platform_runner =
          fml::MessageLoop::GetCurrent().GetTaskRunner();
      if (is_background_view) { 
        auto single_task_runner = thread_host_.ui_thread->GetTaskRunner();
        gpu_runner = single_task_runner;
        ui_runner = single_task_runner;
        io_runner = single_task_runner;
      } else { 
        gpu_runner = thread_host_.gpu_thread->GetTaskRunner();
        ui_runner = thread_host_.ui_thread->GetTaskRunner();
        io_runner = thread_host_.io_thread->GetTaskRunner();
      }
      flutter::TaskRunners task_runners(thread_label,     // label
                                        platform_runner,  // platform
                                        gpu_runner,       // gpu
                                        ui_runner,        // ui
                                        io_runner         // io
      );
    
      shell_ =
          Shell::Create(task_runners,             // task runners
                        settings_,                // settings
                        on_create_platform_view,  // platform view create callback
                        on_create_rasterizer      // rasterizer create callback
          );
    
      platform_view_ = weak_platform_view;
      FML_DCHECK(platform_view_);
    
      is_valid_ = shell_ != nullptr;
    
      // ...省略...
    }

这个方法里面代码比较多，省略部分代码，我们看到最重要的几个地方，首先这里有四个线程，除了当前线程作为`platform`线程，还创建了三个新的线程

*  `gpu`线程
 *  `ui`线程
 *  `io`线程

此处当配图，来自[闲鱼技术博客][Link 1]  
![在这里插入图片描述][format_png]

四个线程分别持有一个`TaskRunner`对象，后续会通过这些`TaskRunner`来将一些操作放到对应的线程中去执行。

*  `Platform Task Runner`的线程可以理解为是主线程，它不仅仅处理与Engine交互，它还处理来自平台的消息。
 *  `UI Task Runner`被用于执行Dart root isolate代码，简单说也就是Dart语言的主线程。我们所编写的Dart代码基本就是在这个线程运行。因此该线程繁忙会导致UI卡顿，如果有繁重的计算任务，如加密、解压缩等，应当在Dart中另起一个`isolate`来执行代码。需要注意，另启的`isolate`是不能与Flutter引擎交互的，表现在开发中，也就是不能在新创建的`isolate`中调用插件，例如在新的`isolate`操作SQlite数据库，如有这种需求，可以使用[FlutterIsolate 库][FlutterIsolate]
 *  `GPU Task Runner` 用于执行设备GPU的相关调用。主要是配置管理每一帧绘制所需要的GPU资源。如果该线程卡顿，直接导致程序卡顿。通常来说用平台代码和Dart代码都无法直接操作到该线程
 *  `IO Runner`的主要是从图片存储（如磁盘）中读取压缩的图片格式，将图片数据进行处理，为GPU Runner的渲染做好准备。也就是处理与磁盘IO相关的事务

最后，看到以下函数的调用，此处即是创建引擎的地方

shell_ =
          Shell::Create(task_runners,             // task runners
                        settings_,                // settings
                        on_create_platform_view,  // platform view create callback
                        on_create_rasterizer      // rasterizer create callback
          );

大家有兴趣可以找相关源码，继续跟踪一下源码，看看引擎是如何创建的

\flutter\shell\common\shell.cc

### 运行Dart代码 ###

通过反编译Flutter生成的apk，我们很清楚的知道，Dart代码编译后的产物，包括相关的资源文件，实际上都是打包到安卓的`assets`目录下的，那么Dart代码是在哪加载执行的呢？

在`FlutterActivityDelegate`的`onCreate`方法的最后有如下代码

String appBundlePath = FlutterMain.findAppBundlePath(activity.getApplicationContext());
     if (appBundlePath != null) { 
         runBundle(appBundlePath);
     }

这里首先获取资源文件提取后在应用所属目录下的路径，然后调用`runBundle`进行加载执行。`runBundle`方法最终调用`FlutterJNI`中的一个native方法

private native void nativeRunBundleAndSnapshotFromLibrary(
          long nativePlatformViewId,
          @NonNull String[] prioritizedBundlePaths,
          @Nullable String entrypointFunctionName,
          @Nullable String pathToEntrypointFunction,
          @NonNull AssetManager manager
      );

调用过程如下，[点击大图][Link 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]

### 总结 ###

*  `FlutterActivityDelegate`中`onCreate`流程图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
    对象调用关系图，[点击大图][Link 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]

`FlutterMain.ensureInitializationComplete`方法调用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]

*  `FlutterApplication`中`onCreate`调用  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]
 *  `FlutterView`创建  
    [点击大图][Link 4]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]
 *  `FlutterNativeView`创建  
    [点击大图][Link 5]

![FlutterNativeView][]

## 视频课程 ##

如需要获取完整的**Flutter全栈式开发课程**，请 [**点击跳转**][Link 6]  
![qr\_adv][qr_adv]

## 欢迎关注公众号：编程之路从0到1 ##

![编程之路从0到1][0_1]

[Flutter]: https://blog.csdn.net/yingshukun/article/details/107813592
[Flutter 1]: https://blog.csdn.net/yingshukun/article/details/107813908
[Flutter 2]: https://blog.csdn.net/yingshukun/article/details/107814286
[Flutter 3]: https://blog.csdn.net/yingshukun/article/details/107814213
[Flutter 4]: https://blog.csdn.net/yingshukun/article/details/107814385
[Flutter 5]: https://arcticfox.blog.csdn.net/article/details/100543916
[Flutter _RenderObject]: https://blog.csdn.net/yingshukun/article/details/107814111
[engine]: https://github.com/flutter/engine
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6445db79469a41fc9d9c8899bd75e9d4.jpg
[Link 1]: https://blog.csdn.net/weixin_38912070/article/details/93857033
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9EVXdpYXlKME1qMUVHbGVBb0xSQjBBRG1DMW1RcmtrUWQ1WHBmZEwxNmp0Y2lhRFRabkI3SnN5a0lkREgxSFUxMXAwTzRzdk5ONmd6cWwyV1VCVmRwZ1ZRLzY0MA?x-oss-process=image/format,png
[FlutterIsolate]: https://github.com/rmawatson/flutter_isolate
[Link 2]: https://s2.ax1x.com/2019/09/07/nlAWon.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/710b380d533441e4a16742dcbb0deda4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/cf25fad0ae9f4417a4a3f5f90995d7fd.png
[Link 3]: https://s2.ax1x.com/2019/09/07/nlVd8P.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a061b947ea714040923577b16f20f90b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/4ff15fea523a4d889ffe9e1362c53507.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5cad6b6c880044d2ab95c4f38a3bfd3d.png
[Link 4]: https://s2.ax1x.com/2019/09/07/nlmhxP.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9hcmN0aWNmb3guYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/44759295dc1f4c6994e86346a31bbbe1.png
[Link 5]: https://s2.ax1x.com/2019/09/07/nlnSqU.png
[FlutterNativeView]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2ff188695fe5436cb76ef01912c56ba9.png
[Link 6]: http://m.study.163.com/provider/480000001855430/index.htm?share=2&shareId=480000001855430
[qr_adv]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c22d9a81d7384ee1acaa28112bb8b4e9.png
[0_1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/89274e6beb9d4cd7a41db389f6437130.jpg