Make FlutterEngineGroup support initialRoute (#28884)

Author: ColdPaleLight

shell/common/engine.cc

@@ -112,7 +112,8 @@ std::unique_ptr<Engine> Engine::Spawn(
     Delegate& delegate,
     const PointerDataDispatcherMaker& dispatcher_maker,
     Settings settings,
-    std::unique_ptr<Animator> animator) const {
+    std::unique_ptr<Animator> animator,
+    const std::string& initial_route) const {
   auto result = std::make_unique<Engine>(
       /*delegate=*/delegate,
       /*dispatcher_maker=*/dispatcher_maker,
@@ -133,6 +134,7 @@ std::unique_ptr<Engine> Engine::Spawn(
       settings_.isolate_shutdown_callback,   // isolate shutdown callback
       settings_.persistent_isolate_data      // persistent isolate data
   );
+  result->initial_route_ = initial_route;
   return result;
 }
 

shell/common/engine.h

@@ -375,7 +375,8 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
       Delegate& delegate,
       const PointerDataDispatcherMaker& dispatcher_maker,
       Settings settings,
-      std::unique_ptr<Animator> animator) const;
+      std::unique_ptr<Animator> animator,
+      const std::string& initial_route) const;
 
   //----------------------------------------------------------------------------
   /// @brief      Destroys the engine engine. Called by the shell on the UI task

shell/common/engine_unittests.cc

@@ -268,13 +268,39 @@ TEST_F(EngineTest, SpawnSharesFontLibrary) {
         /*font_collection=*/std::make_shared<FontCollection>(),
         /*runtime_controller=*/std::move(mock_runtime_controller));
 
-    auto spawn =
-        engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr);
+    auto spawn = engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr,
+                               std::string());
     EXPECT_TRUE(spawn != nullptr);
     EXPECT_EQ(&engine->GetFontCollection(), &spawn->GetFontCollection());
   });
 }
 
+TEST_F(EngineTest, SpawnWithCustomInitialRoute) {
+  PostUITaskSync([this] {
+    MockRuntimeDelegate client;
+    auto mock_runtime_controller =
+        std::make_unique<MockRuntimeController>(client, task_runners_);
+    auto vm_ref = DartVMRef::Create(settings_);
+    EXPECT_CALL(*mock_runtime_controller, GetDartVM())
+        .WillRepeatedly(::testing::Return(vm_ref.get()));
+    auto engine = std::make_unique<Engine>(
+        /*delegate=*/delegate_,
+        /*dispatcher_maker=*/dispatcher_maker_,
+        /*image_decoder_task_runner=*/image_decoder_task_runner_,
+        /*task_runners=*/task_runners_,
+        /*settings=*/settings_,
+        /*animator=*/std::move(animator_),
+        /*io_manager=*/io_manager_,
+        /*font_collection=*/std::make_shared<FontCollection>(),
+        /*runtime_controller=*/std::move(mock_runtime_controller));
+
+    auto spawn =
+        engine->Spawn(delegate_, dispatcher_maker_, settings_, nullptr, "/foo");
+    EXPECT_TRUE(spawn != nullptr);
+    ASSERT_EQ("/foo", spawn->InitialRoute());
+  });
+}
+
 TEST_F(EngineTest, PassesLoadDartDeferredLibraryErrorToRuntime) {
   PostUITaskSync([this] {
     intptr_t error_id = 123;

shell/common/shell.cc

@@ -480,6 +480,7 @@ Shell::~Shell() {
 
 std::unique_ptr<Shell> Shell::Spawn(
     RunConfiguration run_configuration,
+    const std::string& initial_route,
     const CreateCallback<PlatformView>& on_create_platform_view,
     const CreateCallback<Rasterizer>& on_create_rasterizer) const {
   FML_DCHECK(task_runners_.IsValid());
@@ -488,7 +489,7 @@ std::unique_ptr<Shell> Shell::Spawn(
         PlatformData{}, task_runners_, rasterizer_->GetRasterThreadMerger(),
         GetSettings(), vm_, vm_->GetVMData()->GetIsolateSnapshot(),
         on_create_platform_view, on_create_rasterizer,
-        [engine = this->engine_.get()](
+        [engine = this->engine_.get(), initial_route](
             Engine::Delegate& delegate,
             const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
             fml::RefPtr<const DartSnapshot> isolate_snapshot,
@@ -501,7 +502,8 @@ std::unique_ptr<Shell> Shell::Spawn(
           return engine->Spawn(/*delegate=*/delegate,
                                /*dispatcher_maker=*/dispatcher_maker,
                                /*settings=*/settings,
-                               /*animator=*/std::move(animator));
+                               /*animator=*/std::move(animator),
+                               /*initial_route=*/initial_route);
         },
         is_gpu_disabled));
     return result;

shell/common/shell.h

@@ -194,6 +194,7 @@ class Shell final : public PlatformView::Delegate,
   /// @see        http://flutter.dev/go/multiple-engines
   std::unique_ptr<Shell> Spawn(
       RunConfiguration run_configuration,
+      const std::string& initial_route,
       const CreateCallback<PlatformView>& on_create_platform_view,
       const CreateCallback<Rasterizer>& on_create_rasterizer) const;
 

shell/common/shell_unittests.cc

@@ -2695,6 +2695,8 @@ TEST_F(ShellTest, Spawn) {
   ASSERT_TRUE(second_configuration.IsValid());
   second_configuration.SetEntrypoint("testCanLaunchSecondaryIsolate");
 
+  const std::string initial_route("/foo");
+
   fml::AutoResetWaitableEvent main_latch;
   std::string last_entry_point;
   // Fulfill native function for the first Shell's entrypoint.
@@ -2719,10 +2721,11 @@ TEST_F(ShellTest, Spawn) {
 
   PostSync(
       shell->GetTaskRunners().GetPlatformTaskRunner(),
-      [this, &spawner = shell, &second_configuration, &second_latch]() {
+      [this, &spawner = shell, &second_configuration, &second_latch,
+       initial_route]() {
         MockPlatformViewDelegate platform_view_delegate;
         auto spawn = spawner->Spawn(
-            std::move(second_configuration),
+            std::move(second_configuration), initial_route,
             [&platform_view_delegate](Shell& shell) {
               auto result = std::make_unique<MockPlatformView>(
                   platform_view_delegate, shell.GetTaskRunners());
@@ -2736,10 +2739,11 @@ TEST_F(ShellTest, Spawn) {
         ASSERT_TRUE(ValidateShell(spawn.get()));
 
         PostSync(spawner->GetTaskRunners().GetUITaskRunner(),
-                 [&spawn, &spawner] {
+                 [&spawn, &spawner, initial_route] {
                    // Check second shell ran the second entrypoint.
                    ASSERT_EQ("testCanLaunchSecondaryIsolate",
                              spawn->GetEngine()->GetLastEntrypoint());
+                   ASSERT_EQ(initial_route, spawn->GetEngine()->InitialRoute());
 
                    // TODO(74520): Remove conditional once isolate groups are
                    // supported by JIT.

shell/platform/android/android_shell_holder.cc

@@ -174,7 +174,8 @@ const flutter::Settings& AndroidShellHolder::GetSettings() const {
 std::unique_ptr<AndroidShellHolder> AndroidShellHolder::Spawn(
     std::shared_ptr<PlatformViewAndroidJNI> jni_facade,
     const std::string& entrypoint,
-    const std::string& libraryUrl) const {
+    const std::string& libraryUrl,
+    const std::string& initial_route) const {
   FML_DCHECK(shell_ && shell_->IsSetup())
       << "A new Shell can only be spawned "
          "if the current Shell is properly constructed";
@@ -226,8 +227,9 @@ std::unique_ptr<AndroidShellHolder> AndroidShellHolder::Spawn(
     return nullptr;
   }
 
-  std::unique_ptr<flutter::Shell> shell = shell_->Spawn(
-      std::move(config.value()), on_create_platform_view, on_create_rasterizer);
+  std::unique_ptr<flutter::Shell> shell =
+      shell_->Spawn(std::move(config.value()), initial_route,
+                    on_create_platform_view, on_create_rasterizer);
 
   return std::unique_ptr<AndroidShellHolder>(
       new AndroidShellHolder(GetSettings(), jni_facade, thread_host_,

shell/platform/android/android_shell_holder.h

@@ -78,7 +78,8 @@ class AndroidShellHolder {
   std::unique_ptr<AndroidShellHolder> Spawn(
       std::shared_ptr<PlatformViewAndroidJNI> jni_facade,
       const std::string& entrypoint,
-      const std::string& libraryUrl) const;
+      const std::string& libraryUrl,
+      const std::string& initial_route) const;
 
   void Launch(std::shared_ptr<AssetManager> asset_manager,
               const std::string& entrypoint,

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

@@ -384,15 +384,19 @@ private boolean isAttachedToJni() {
    */
   @NonNull
   /*package*/ FlutterEngine spawn(
-      @NonNull Context context, @NonNull DartEntrypoint dartEntrypoint) {
+      @NonNull Context context,
+      @NonNull DartEntrypoint dartEntrypoint,
+      @Nullable String initialRoute) {
     if (!isAttachedToJni()) {
       throw new IllegalStateException(
           "Spawn can only be called on a fully constructed FlutterEngine");
     }
 
     FlutterJNI newFlutterJNI =
         flutterJNI.spawn(
-            dartEntrypoint.dartEntrypointFunctionName, dartEntrypoint.dartEntrypointLibrary);
+            dartEntrypoint.dartEntrypointFunctionName,
+            dartEntrypoint.dartEntrypointLibrary,
+            initialRoute);
     return new FlutterEngine(
         context, // Context.
         null, // FlutterLoader. A null value passed here causes the constructor to get it from the

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

@@ -96,6 +96,27 @@ public FlutterEngine createAndRunDefaultEngine(@NonNull Context context) {
    */
   public FlutterEngine createAndRunEngine(
       @NonNull Context context, @Nullable DartEntrypoint dartEntrypoint) {
+    return createAndRunEngine(context, dartEntrypoint, null);
+  }
+
+  /**
+   * Creates a {@link io.flutter.embedding.engine.FlutterEngine} in this group and run its {@link
+   * io.flutter.embedding.engine.dart.DartExecutor} with the specified {@link DartEntrypoint} and
+   * the specified {@code initialRoute}.
+   *
+   * <p>If no prior {@link io.flutter.embedding.engine.FlutterEngine} were created in this group,
+   * the initialization cost will be slightly higher than subsequent engines. The very first {@link
+   * io.flutter.embedding.engine.FlutterEngine} created per program, regardless of
+   * FlutterEngineGroup, also incurs the Dart VM creation time.
+   *
+   * <p>Subsequent engine creations will share resources with existing engines. However, if all
+   * existing engines were {@link io.flutter.embedding.engine.FlutterEngine#destroy()}ed, the next
+   * engine created will recreate its dependencies.
+   */
+  public FlutterEngine createAndRunEngine(
+      @NonNull Context context,
+      @Nullable DartEntrypoint dartEntrypoint,
+      @Nullable String initialRoute) {
     FlutterEngine engine = null;
 
     if (dartEntrypoint == null) {
@@ -104,9 +125,12 @@ public FlutterEngine createAndRunEngine(
 
     if (activeEngines.size() == 0) {
       engine = createEngine(context);
+      if (initialRoute != null) {
+        engine.getNavigationChannel().setInitialRoute(initialRoute);
+      }
       engine.getDartExecutor().executeDartEntrypoint(dartEntrypoint);
     } else {
-      engine = activeEngines.get(0).spawn(context, dartEntrypoint);
+      engine = activeEngines.get(0).spawn(context, dartEntrypoint, initialRoute);
     }
 
     activeEngines.add(engine);