peformance improvement : reduce engine init time 50%off at least

- supprot android && ios
- use new api like asyncrun() to reduce mainthead block time
- add code comment
- add testcase for async init method
- clang-format

Author: peihan.cph

shell/common/shell.cc

@@ -39,7 +39,24 @@ constexpr char kSystemChannel[] = "flutter/system";
 constexpr char kTypeKey[] = "type";
 constexpr char kFontChange[] = "fontsChange";
 
+void Shell::OnEngineInit(std::unique_ptr<Engine> engine) {
+  Setup(std::move(platform_view_),  //
+        std::move(engine),          //
+        std::move(rasterizer_),     //
+        std::move(io_manager_));    //
+}
+
+void Shell::BindParams(std::unique_ptr<PlatformView> platform_view,
+                       std::unique_ptr<Rasterizer> rasterizer,
+                       std::unique_ptr<ShellIOManager> io_manager) {
+  platform_view_ = std::move(platform_view);
+  // engine_ = std::move(engine);
+  rasterizer_ = std::move(rasterizer);
+  io_manager_ = std::move(io_manager);
+}
+
 std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
+    fml::closure& async_init_callback,
     DartVMRef vm,
     TaskRunners task_runners,
     const WindowData window_data,
@@ -126,13 +143,21 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
   auto dispatcher_maker = platform_view->GetDispatcherMaker();
 
   // Create the engine on the UI thread.
+  bool do_async_init = false;
+  if (async_init_callback) {
+    do_async_init = true;
+  }
   std::promise<std::unique_ptr<Engine>> engine_promise;
   auto engine_future = engine_promise.get_future();
+  std::promise<void> async_init_promise;
+  std::future<void> async_init_future = async_init_promise.get_future();
   fml::TaskRunner::RunNowOrPostTask(
       shell->GetTaskRunners().GetUITaskRunner(),
       fml::MakeCopyable([&engine_promise,                                 //
                          shell = shell.get(),                             //
-                         &dispatcher_maker,                               //
+                         &async_init_promise,                             //
+                         callback_in = std::move(async_init_callback),    //
+                         dispatcher_in = std::move(dispatcher_maker),     //
                          &window_data,                                    //
                          isolate_snapshot = std::move(isolate_snapshot),  //
                          vsync_waiter = std::move(vsync_waiter),          //
@@ -148,21 +173,47 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
         auto animator = std::make_unique<Animator>(*shell, task_runners,
                                                    std::move(vsync_waiter));
 
-        engine_promise.set_value(std::make_unique<Engine>(
-            *shell,                         //
-            dispatcher_maker,               //
-            *shell->GetDartVM(),            //
-            std::move(isolate_snapshot),    //
-            task_runners,                   //
-            window_data,                    //
-            shell->GetSettings(),           //
-            std::move(animator),            //
-            weak_io_manager_future.get(),   //
-            unref_queue_future.get(),       //
-            snapshot_delegate_future.get()  //
-            ));
+        // wait params
+        auto snapshot_delegate = snapshot_delegate_future.get();
+        auto unref_queue = unref_queue_future.get();
+        auto io_manager = weak_io_manager_future.get();
+        if (callback_in) {
+          async_init_promise.set_value();
+        }
+        auto engine_ref =
+            std::make_unique<Engine>(*shell,                       //
+                                     dispatcher_in,                //
+                                     *shell->GetDartVM(),          //
+                                     std::move(isolate_snapshot),  //
+                                     task_runners,                 //
+                                     window_data,                  //
+                                     shell->GetSettings(),         //
+                                     std::move(animator),          //
+                                     std::move(io_manager),        //
+                                     std::move(unref_queue),       //
+                                     std::move(snapshot_delegate)  //
+            );
+
+        if (callback_in) {
+          fml::TaskRunner::RunNowOrPostTask(
+              shell->GetTaskRunners().GetPlatformTaskRunner(),
+              fml::MakeCopyable(
+                  [async_init_callback_func = std::move(callback_in),
+                   shell_inner = shell,
+                   engine_inner = std::move(engine_ref)]() mutable {
+                    shell_inner->OnEngineInit(std::move(engine_inner));
+                    async_init_callback_func();
+                  }));
+        } else {
+          engine_promise.set_value(std::move(engine_ref));
+        }
       }));
-
+  if (do_async_init) {
+    async_init_future.get();
+    shell->BindParams(std::move(platform_view), rasterizer_future.get(),
+                      io_manager_future.get());
+    return shell;
+  }
   if (!shell->Setup(std::move(platform_view),  //
                     engine_future.get(),       //
                     rasterizer_future.get(),   //
@@ -240,11 +291,13 @@ static void PerformInitializationTasks(const Settings& settings) {
 }
 
 std::unique_ptr<Shell> Shell::Create(
+    fml::closure& async_init_callback,
     TaskRunners task_runners,
     Settings settings,
     const Shell::CreateCallback<PlatformView>& on_create_platform_view,
     const Shell::CreateCallback<Rasterizer>& on_create_rasterizer) {
-  return Shell::Create(std::move(task_runners),                //
+  return Shell::Create(async_init_callback,                    //
+                       std::move(task_runners),                //
                        WindowData{/* default window data */},  //
                        std::move(settings),                    //
                        std::move(on_create_platform_view),     //
@@ -253,6 +306,7 @@ std::unique_ptr<Shell> Shell::Create(
 }
 
 std::unique_ptr<Shell> Shell::Create(
+    fml::closure& async_init_callback,
     TaskRunners task_runners,
     const WindowData window_data,
     Settings settings,
@@ -268,7 +322,8 @@ std::unique_ptr<Shell> Shell::Create(
 
   auto vm_data = vm->GetVMData();
 
-  return Shell::Create(std::move(task_runners),        //
+  return Shell::Create(async_init_callback,
+                       std::move(task_runners),        //
                        std::move(window_data),         //
                        std::move(settings),            //
                        vm_data->GetIsolateSnapshot(),  // isolate snapshot
@@ -279,6 +334,7 @@ std::unique_ptr<Shell> Shell::Create(
 }
 
 std::unique_ptr<Shell> Shell::Create(
+    fml::closure& async_init_callback,
     TaskRunners task_runners,
     const WindowData window_data,
     Settings settings,
@@ -303,14 +359,16 @@ std::unique_ptr<Shell> Shell::Create(
       fml::MakeCopyable([&latch,                                          //
                          vm = std::move(vm),                              //
                          &shell,                                          //
+                         &async_init_callback,                            //
                          task_runners = std::move(task_runners),          //
                          window_data,                                     //
                          settings,                                        //
                          isolate_snapshot = std::move(isolate_snapshot),  //
                          on_create_platform_view,                         //
                          on_create_rasterizer                             //
   ]() mutable {
-        shell = CreateShellOnPlatformThread(std::move(vm),
+        shell = CreateShellOnPlatformThread(async_init_callback,          //
+                                            std::move(vm),                //
                                             std::move(task_runners),      //
                                             window_data,                  //
                                             settings,                     //

shell/common/shell.h

@@ -101,6 +101,9 @@ class Shell final : public PlatformView::Delegate,
   ///             If this is the first instance of a shell in the process, this
   ///             call also bootstraps the Dart VM.
   ///
+  /// @param[in]  async_init_callback      if null,init sync.
+  ///                                      else init async.and called when
+  ///                                      asyncInit end
   /// @param[in]  task_runners             The task runners
   /// @param[in]  settings                 The settings
   /// @param[in]  on_create_platform_view  The callback that must return a
@@ -121,6 +124,7 @@ class Shell final : public PlatformView::Delegate,
   ///             immediately after getting a pointer to it.
   ///
   static std::unique_ptr<Shell> Create(
+      fml::closure& async_init_callback,
       TaskRunners task_runners,
       Settings settings,
       const CreateCallback<PlatformView>& on_create_platform_view,
@@ -134,7 +138,9 @@ class Shell final : public PlatformView::Delegate,
   ///             allows for specification of window data. If this is the first
   ///             instance of a shell in the process, this call also bootstraps
   ///             the Dart VM.
-  ///
+  /// @param[in]  async_init_callback      if null,init sync.
+  ///                                      else init async.and called when
+  ///                                      asyncInit end
   /// @param[in]  task_runners             The task runners
   /// @param[in]  window_data              The default data for setting up
   ///                                      ui.Window that attached to this
@@ -158,6 +164,7 @@ class Shell final : public PlatformView::Delegate,
   ///             immediately after getting a pointer to it.
   ///
   static std::unique_ptr<Shell> Create(
+      fml::closure& async_init_callback,
       TaskRunners task_runners,
       const WindowData window_data,
       Settings settings,
@@ -172,7 +179,9 @@ class Shell final : public PlatformView::Delegate,
   ///             allows for the specification of an isolate snapshot that
   ///             cannot be adequately described in the settings. This call also
   ///             requires the specification of a running VM instance.
-  ///
+  /// @param[in]  async_init_callback      if null,init sync.
+  ///                                      else init async.and called when
+  ///                                      asyncInit end
   /// @param[in]  task_runners             The task runners
   /// @param[in]  window_data              The default data for setting up
   ///                                      ui.Window that attached to this
@@ -200,6 +209,7 @@ class Shell final : public PlatformView::Delegate,
   ///             immediately after getting a pointer to it.
   ///
   static std::unique_ptr<Shell> Create(
+      fml::closure& async_init_callback,
       TaskRunners task_runners,
       const WindowData window_data,
       Settings settings,
@@ -419,6 +429,7 @@ class Shell final : public PlatformView::Delegate,
   Shell(DartVMRef vm, TaskRunners task_runners, Settings settings);
 
   static std::unique_ptr<Shell> CreateShellOnPlatformThread(
+      fml::closure& async_init_callback,
       DartVMRef vm,
       TaskRunners task_runners,
       const WindowData window_data,
@@ -432,6 +443,14 @@ class Shell final : public PlatformView::Delegate,
              std::unique_ptr<Rasterizer> rasterizer,
              std::unique_ptr<ShellIOManager> io_manager);
 
+  // called on asyncInit mode,set params
+  void BindParams(std::unique_ptr<PlatformView> platform_view,
+                  std::unique_ptr<Rasterizer> rasterizer,
+                  std::unique_ptr<ShellIOManager> io_manager);
+
+  // called on asyncInit mode,setup env
+  void OnEngineInit(std::unique_ptr<Engine> engine);
+
   void ReportTimings();
 
   // |PlatformView::Delegate|

shell/platform/android/android_shell_holder.cc

@@ -18,6 +18,7 @@
 #include "flutter/fml/message_loop.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/platform/android/platform_view_android.h"
+#include "flutter/shell/platform/android/platform_view_android_jni.h"
 
 namespace flutter {
 
@@ -30,7 +31,8 @@ static WindowData GetDefaultWindowData() {
 AndroidShellHolder::AndroidShellHolder(
     flutter::Settings settings,
     fml::jni::JavaObjectWeakGlobalRef java_object,
-    bool is_background_view)
+    bool is_background_view,
+    bool init_async_mode)
     : settings_(std::move(settings)), java_object_(java_object) {
   static size_t shell_count = 1;
   auto thread_label = std::to_string(shell_count++);
@@ -106,9 +108,18 @@ AndroidShellHolder::AndroidShellHolder(
                                     ui_runner,        // ui
                                     io_runner         // io
   );
+  fml::closure asyncInitCallback;
+  if (init_async_mode) {
+    asyncInitCallback = [java_object]() {
+      JNIEnv* env = fml::jni::AttachCurrentThread();
+      auto scoped_jni_obj = java_object.get(env);
+      FlutterViewHandleEngineInit(env, scoped_jni_obj.obj());
+    };
+  }
 
   shell_ =
-      Shell::Create(task_runners,             // task runners
+      Shell::Create(asyncInitCallback,        // callback
+                    task_runners,             // task runners
                     GetDefaultWindowData(),   // window data
                     settings_,                // settings
                     on_create_platform_view,  // platform view create callback

shell/platform/android/android_shell_holder.h

@@ -23,7 +23,8 @@ class AndroidShellHolder {
  public:
   AndroidShellHolder(flutter::Settings settings,
                      fml::jni::JavaObjectWeakGlobalRef java_object,
-                     bool is_background_view);
+                     bool is_background_view,
+                     bool async_init);
 
   ~AndroidShellHolder();
 

shell/platform/android/io/flutter/embedding/engine/FlutterEngine.java

@@ -101,7 +101,13 @@ public void onPreEngineRestart() {
 
           platformViewsController.onPreEngineRestart();
         }
-      };
+        // new api,called when engine init success for aync mode
+        public void onEngineInit() {
+            for (EngineLifecycleListener lifecycleListener : engineLifecycleListeners) {
+                lifecycleListener.onEngineInit();
+            }
+        }
+    };
 
   /**
    * Constructs a new {@code FlutterEngine}.
@@ -200,12 +206,53 @@ public FlutterEngine(
       @NonNull PlatformViewsController platformViewsController,
       @Nullable String[] dartVmArgs,
       boolean automaticallyRegisterPlugins) {
+    this (context,
+        flutterLoader,
+        flutterJNI,
+        platformViewsController,
+        dartVmArgs,
+        automaticallyRegisterPlugins,
+        null);
+  }
+
+  /**
+   * Same as {@link #FlutterEngine(Context, FlutterLoader, FlutterJNI)},
+   * but init native env with async mode
+   * {@code asyncInitListener} async init callback, called when async init finish
+   */
+  public static FlutterEngine createEngineAndinitAsync(
+      @NonNull Context context,
+      @NonNull EngineLifecycleListener asyncInitListener){
+    return new FlutterEngine(
+        context,
+        FlutterLoader.getInstance(),
+        new FlutterJNI(),
+        new PlatformViewsController(),
+        null,
+        true,
+        asyncInitListener);
+  }
+
+  /**
+   * Fully configurable {@code FlutterEngine} constructor.
+   * {@code asyncInitListener} if null,init native env sycnc,
+   * if not null,will init native env async, and called when async init end
+   */
+  public FlutterEngine(
+      @NonNull Context context,
+      @NonNull FlutterLoader flutterLoader,
+      @NonNull FlutterJNI flutterJNI,
+      @NonNull PlatformViewsController platformViewsController,
+      @Nullable String[] dartVmArgs,
+      boolean automaticallyRegisterPlugins,
+      EngineLifecycleListener asyncInitListener) {
     this.flutterJNI = flutterJNI;
     flutterLoader.startInitialization(context.getApplicationContext());
     flutterLoader.ensureInitializationComplete(context, dartVmArgs);
 
     flutterJNI.addEngineLifecycleListener(engineLifecycleListener);
-    attachToJni();
+    addEngineLifecycleListener(asyncInitListener);
+    attachToJni(asyncInitListener != null);
 
     this.dartExecutor = new DartExecutor(flutterJNI, context.getAssets());
     this.dartExecutor.onAttachedToJNI();
@@ -234,10 +281,10 @@ public FlutterEngine(
     }
   }
 
-  private void attachToJni() {
+  private void attachToJni(boolean asyncInitMode) {
     Log.v(TAG, "Attaching to JNI.");
     // TODO(mattcarroll): update native call to not take in "isBackgroundView"
-    flutterJNI.attachToNative(false);
+    flutterJNI.attachToNative(false,asyncInitMode);
 
     if (!isAttachedToJni()) {
       throw new RuntimeException("FlutterEngine failed to attach to its native Object reference.");
@@ -436,5 +483,7 @@ public ContentProviderControlSurface getContentProviderControlSurface() {
   public interface EngineLifecycleListener {
     /** Lifecycle callback invoked before a hot restart of the Flutter engine. */
     void onPreEngineRestart();
+    /** Lifecycle callback invoked after flutter engine async init success .*/
+    void onEngineInit();
   }
 }