Make FlutterEngineGroup support dart entrypoint args

common/settings.h

@@ -127,6 +127,8 @@ struct Settings {
   std::string temp_directory_path;
   std::vector<std::string> dart_flags;
   // Arguments passed as a List<String> to Dart's entrypoint function.
+  // TODO(93459): Remove it when it is no longer used.
+  // https://github.com/flutter/flutter/issues/93459
   std::vector<std::string> dart_entrypoint_args;
 
   // Isolate settings

fml/platform/android/jni_util.cc

@@ -125,6 +125,35 @@ std::vector<std::string> StringArrayToVector(JNIEnv* env, jobjectArray array) {
   return out;
 }
 
+std::vector<std::string> StringListToVector(JNIEnv* env, jobject list) {
+  std::vector<std::string> out;
+  if (env == nullptr || list == nullptr) {
+    return out;
+  }
+
+  ScopedJavaLocalRef<jclass> list_clazz(env, env->FindClass("java/util/List"));
+  FML_DCHECK(!list_clazz.is_null());
+
+  jmethodID list_get =
+      env->GetMethodID(list_clazz.obj(), "get", "(I)Ljava/lang/Object;");
+  jmethodID list_size = env->GetMethodID(list_clazz.obj(), "size", "()I");
+
+  jint size = env->CallIntMethod(list, list_size);
+
+  if (size == 0) {
+    return out;
+  }
+
+  out.resize(size);
+  for (jint i = 0; i < size; ++i) {
+    ScopedJavaLocalRef<jstring> java_string(
+        env, static_cast<jstring>(env->CallObjectMethod(list, list_get, i)));
+    out[i] = JavaStringToString(env, java_string.obj());
+  }
+
+  return out;
+}
+
 ScopedJavaLocalRef<jobjectArray> VectorToStringArray(
     JNIEnv* env,
     const std::vector<std::string>& vector) {

fml/platform/android/jni_util.h

@@ -30,6 +30,8 @@ ScopedJavaLocalRef<jstring> StringToJavaString(JNIEnv* env,
 
 std::vector<std::string> StringArrayToVector(JNIEnv* env, jobjectArray jargs);
 
+std::vector<std::string> StringListToVector(JNIEnv* env, jobject list);
+
 ScopedJavaLocalRef<jobjectArray> VectorToStringArray(
     JNIEnv* env,
     const std::vector<std::string>& vector);

runtime/dart_isolate.cc

@@ -93,6 +93,7 @@ std::weak_ptr<DartIsolate> DartIsolate::SpawnIsolate(
     const fml::closure& isolate_shutdown_callback,
     std::optional<std::string> dart_entrypoint,
     std::optional<std::string> dart_entrypoint_library,
+    const std::vector<std::string>& dart_entrypoint_args,
     std::unique_ptr<IsolateConfiguration> isolate_configuration) const {
   return CreateRunningRootIsolate(
       settings,                                          //
@@ -104,6 +105,7 @@ std::weak_ptr<DartIsolate> DartIsolate::SpawnIsolate(
       isolate_shutdown_callback,                         //
       dart_entrypoint,                                   //
       dart_entrypoint_library,                           //
+      dart_entrypoint_args,                              //
       std::move(isolate_configuration),                  //
       UIDartState::Context{GetTaskRunners(),             //
                            snapshot_delegate,            //
@@ -128,6 +130,7 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
     const fml::closure& isolate_shutdown_callback,
     std::optional<std::string> dart_entrypoint,
     std::optional<std::string> dart_entrypoint_library,
+    const std::vector<std::string>& dart_entrypoint_args,
     std::unique_ptr<IsolateConfiguration> isolate_configuration,
     const UIDartState::Context& context,
     const DartIsolate* spawning_isolate) {
@@ -195,10 +198,14 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRunningRootIsolate(
     root_isolate_create_callback();
   }
 
-  if (!isolate->RunFromLibrary(dart_entrypoint_library,       //
-                               dart_entrypoint,               //
-                               settings.dart_entrypoint_args  //
-                               )) {
+  FML_DCHECK(dart_entrypoint_args.empty() ||
+             settings.dart_entrypoint_args.empty());
+  const std::vector<std::string>& args = !dart_entrypoint_args.empty()
+                                             ? dart_entrypoint_args
+                                             : settings.dart_entrypoint_args;
+  if (!isolate->RunFromLibrary(dart_entrypoint_library,  //
+                               dart_entrypoint,          //
+                               args)) {
     FML_LOG(ERROR) << "Could not run the run main Dart entrypoint.";
     return {};
   }

runtime/dart_isolate.h

@@ -170,6 +170,8 @@ class DartIsolate : public UIDartState {
   ///                                         function to invoke.
   /// @param[in]  dart_entrypoint_library     The name of the dart library
   ///                                         containing the entrypoint.
+  /// @param[in]  dart_entrypoint_args        Arguments passed as a List<String>
+  ///                                         to Dart's entrypoint function.
   /// @param[in]  isolate_configuration       The isolate configuration used to
   ///                                         configure the isolate before
   ///                                         invoking the entrypoint.
@@ -215,6 +217,7 @@ class DartIsolate : public UIDartState {
       const fml::closure& isolate_shutdown_callback,
       std::optional<std::string> dart_entrypoint,
       std::optional<std::string> dart_entrypoint_library,
+      const std::vector<std::string>& dart_entrypoint_args,
       std::unique_ptr<IsolateConfiguration> isolate_configuration,
       const UIDartState::Context& context,
       const DartIsolate* spawning_isolate = nullptr);
@@ -245,6 +248,7 @@ class DartIsolate : public UIDartState {
       const fml::closure& isolate_shutdown_callback,
       std::optional<std::string> dart_entrypoint,
       std::optional<std::string> dart_entrypoint_library,
+      const std::vector<std::string>& dart_entrypoint_args,
       std::unique_ptr<IsolateConfiguration> isolate_configuration) const;
 
   // |UIDartState|

runtime/dart_isolate_unittests.cc

@@ -64,6 +64,7 @@ TEST_F(DartIsolateTest, RootIsolateCreationAndShutdown) {
       settings.isolate_shutdown_callback,  // isolate shutdown callback
       "main",                              // dart entrypoint
       std::nullopt,                        // dart entrypoint library
+      {},                                  // dart entrypoint arguments
       std::move(isolate_configuration),    // isolate configuration
       std::move(context)                   // engine context
   );
@@ -103,6 +104,7 @@ TEST_F(DartIsolateTest, SpawnIsolate) {
       settings.isolate_shutdown_callback,  // isolate shutdown callback
       "main",                              // dart entrypoint
       std::nullopt,                        // dart entrypoint library
+      {},                                  // dart entrypoint arguments
       std::move(isolate_configuration),    // isolate configuration
       std::move(context)                   // engine context
   );
@@ -123,6 +125,7 @@ TEST_F(DartIsolateTest, SpawnIsolate) {
       /*isolate_shutdown_callback=*/settings.isolate_shutdown_callback,
       /*dart_entrypoint=*/"main",
       /*dart_entrypoint_library=*/std::nullopt,
+      /*dart_entrypoint_args=*/{},
       /*isolate_configuration=*/std::move(spawn_configuration));
   auto spawn = weak_spawn.lock();
   ASSERT_TRUE(spawn);
@@ -177,6 +180,7 @@ TEST_F(DartIsolateTest, IsolateShutdownCallbackIsInIsolateScope) {
       settings.isolate_shutdown_callback,  // isolate shutdown callback
       "main",                              // dart entrypoint
       std::nullopt,                        // dart entrypoint library
+      {},                                  // dart entrypoint arguments
       std::move(isolate_configuration),    // isolate configuration
       std::move(context)                   // engine context
   );
@@ -400,6 +404,7 @@ TEST_F(DartIsolateTest, CanCreateServiceIsolate) {
       settings.isolate_shutdown_callback,  // isolate shutdown callback
       "main",                              // dart entrypoint
       std::nullopt,                        // dart entrypoint library
+      {},                                  // dart entrypoint arguments
       std::move(isolate_configuration),    // isolate configuration
       std::move(context)                   // engine context
   );
@@ -499,6 +504,7 @@ TEST_F(DartIsolateTest, InvalidLoadingUnitFails) {
       settings.isolate_shutdown_callback,  // isolate shutdown callback
       "main",                              // dart entrypoint
       std::nullopt,                        // dart entrypoint library
+      {},                                  // dart entrypoint arguments
       std::move(isolate_configuration),    // isolate configuration
       std::move(context)                   // engine context
   );

runtime/dart_lifecycle_unittests.cc

@@ -69,6 +69,7 @@ static std::shared_ptr<DartIsolate> CreateAndRunRootIsolate(
           settings.isolate_shutdown_callback,  // isolate shutdown callback,
           entrypoint,                          // dart entrypoint
           std::nullopt,                        // dart entrypoint library
+          {},                                  // dart entrypoint arguments
           std::move(isolate_configuration),    // isolate configuration
           std::move(context)                   // engine context
           )

runtime/runtime_controller.cc

@@ -358,6 +358,7 @@ bool RuntimeController::LaunchRootIsolate(
     fml::closure root_isolate_create_callback,
     std::optional<std::string> dart_entrypoint,
     std::optional<std::string> dart_entrypoint_library,
+    const std::vector<std::string>& dart_entrypoint_args,
     std::unique_ptr<IsolateConfiguration> isolate_configuration) {
   if (root_isolate_.lock()) {
     FML_LOG(ERROR) << "Root isolate was already running.";
@@ -375,6 +376,7 @@ bool RuntimeController::LaunchRootIsolate(
           isolate_shutdown_callback_,                     //
           dart_entrypoint,                                //
           dart_entrypoint_library,                        //
+          dart_entrypoint_args,                           //
           std::move(isolate_configuration),               //
           context_,                                       //
           spawning_isolate_.lock().get())                 //

runtime/runtime_controller.h

@@ -132,6 +132,8 @@ class RuntimeController : public PlatformConfigurationClient {
   /// @param[in]  dart_entrypoint_library  The dart entrypoint library. If
   ///                                      `std::nullopt` or empty, the core
   ///                                      library will be attempted.
+  /// @param[in]  dart_entrypoint_args     Arguments passed as a List<String>
+  ///                                      to Dart's entrypoint function.
   /// @param[in]  isolate_configuration    The isolate configuration
   ///
   /// @return     If the isolate could be launched and guided to the
@@ -142,6 +144,7 @@ class RuntimeController : public PlatformConfigurationClient {
       fml::closure root_isolate_create_callback,
       std::optional<std::string> dart_entrypoint,
       std::optional<std::string> dart_entrypoint_library,
+      const std::vector<std::string>& dart_entrypoint_args,
       std::unique_ptr<IsolateConfiguration> isolate_configuration);
 
   //----------------------------------------------------------------------------

shell/common/engine.cc

@@ -199,6 +199,10 @@ Engine::RunStatus Engine::Run(RunConfiguration configuration) {
 
   last_entry_point_ = configuration.GetEntrypoint();
   last_entry_point_library_ = configuration.GetEntrypointLibrary();
+#if (FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG)
+  // This is only used to support restart.
+  last_entry_point_args_ = configuration.GetEntrypointArgs();
+#endif
 
   UpdateAssetManager(configuration.GetAssetManager());
 
@@ -220,6 +224,7 @@ Engine::RunStatus Engine::Run(RunConfiguration configuration) {
           root_isolate_create_callback,              //
           configuration.GetEntrypoint(),             //
           configuration.GetEntrypointLibrary(),      //
+          configuration.GetEntrypointArgs(),         //
           configuration.TakeIsolateConfiguration())  //
   ) {
     return RunStatus::Failure;
@@ -570,6 +575,10 @@ const std::string& Engine::GetLastEntrypointLibrary() const {
   return last_entry_point_library_;
 }
 
+const std::vector<std::string>& Engine::GetLastEntrypointArgs() const {
+  return last_entry_point_args_;
+}
+
 // |RuntimeDelegate|
 void Engine::RequestDartDeferredLibrary(intptr_t loading_unit_id) {
   return delegate_.RequestDartDeferredLibrary(loading_unit_id);

shell/common/engine.h

@@ -834,6 +834,13 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
   ///
   const std::string& GetLastEntrypointLibrary() const;
 
+  //----------------------------------------------------------------------------
+  /// @brief      Get the last Entrypoint Arguments that was used in the
+  ///             RunConfiguration when |Engine::Run| was called.This is only
+  ///             valid in debug mode.
+  ///
+  const std::vector<std::string>& GetLastEntrypointArgs() const;
+
   //----------------------------------------------------------------------------
   /// @brief      Getter for the initial route.  This can be set with a platform
   ///             message.
@@ -970,6 +977,7 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
 
   std::string last_entry_point_;
   std::string last_entry_point_library_;
+  std::vector<std::string> last_entry_point_args_;
   std::string initial_route_;
   ViewportMetrics viewport_metrics_;
   std::shared_ptr<AssetManager> asset_manager_;

shell/common/fixtures/shell_test.dart

@@ -247,3 +247,17 @@ void canAccessResourceFromAssetDir() async {
     },
   );
 }
+
+void notifyNativeWhenEngineRun(bool success) native 'NotifyNativeWhenEngineRun';
+
+void notifyNativeWhenEngineSpawn(bool success) native 'NotifyNativeWhenEngineSpawn';
+
+@pragma('vm:entry-point')
+void canRecieveArgumentsWhenEngineRun(List<String> args) {
+  notifyNativeWhenEngineRun(args.length == 2 && args[0] == 'foo' && args[1] == 'bar');
+}
+
+@pragma('vm:entry-point')
+void canRecieveArgumentsWhenEngineSpawn(List<String> args) {
+  notifyNativeWhenEngineSpawn(args.length == 2 && args[0] == 'arg1' && args[1] == 'arg2');
+}

shell/common/run_configuration.cc

@@ -77,6 +77,11 @@ void RunConfiguration::SetEntrypointAndLibrary(std::string entrypoint,
   entrypoint_library_ = std::move(library);
 }
 
+void RunConfiguration::SetEntrypointArgs(
+    const std::vector<std::string>& entrypoint_args) {
+  entrypoint_args_ = entrypoint_args;
+}
+
 std::shared_ptr<AssetManager> RunConfiguration::GetAssetManager() const {
   return asset_manager_;
 }
@@ -89,6 +94,10 @@ const std::string& RunConfiguration::GetEntrypointLibrary() const {
   return entrypoint_library_;
 }
 
+const std::vector<std::string>& RunConfiguration::GetEntrypointArgs() const {
+  return entrypoint_args_;
+}
+
 std::unique_ptr<IsolateConfiguration>
 RunConfiguration::TakeIsolateConfiguration() {
   return std::move(isolate_configuration_);

shell/common/run_configuration.h

@@ -151,6 +151,12 @@ class RunConfiguration {
   ///
   void SetEntrypointAndLibrary(std::string entrypoint, std::string library);
 
+  //----------------------------------------------------------------------------
+  /// @brief      Updates the main application entrypoint arguments.
+  ///
+  /// @param[in]  entrypoint_args  The entrypoint arguments to use.
+  void SetEntrypointArgs(const std::vector<std::string>& entrypoint_args);
+
   //----------------------------------------------------------------------------
   /// @return     The asset manager referencing all previously registered asset
   ///             resolvers.
@@ -168,6 +174,12 @@ class RunConfiguration {
   ///
   const std::string& GetEntrypointLibrary() const;
 
+  //----------------------------------------------------------------------------
+  /// @return     Arguments passed as a List<String> to Dart's entrypoint
+  ///             function.
+  ///
+  const std::vector<std::string>& GetEntrypointArgs() const;
+
   //----------------------------------------------------------------------------
   /// @brief      The engine uses this to take the isolate configuration from
   ///             the run configuration. The run configuration is no longer
@@ -184,6 +196,7 @@ class RunConfiguration {
   std::shared_ptr<AssetManager> asset_manager_;
   std::string entrypoint_ = "main";
   std::string entrypoint_library_ = "";
+  std::vector<std::string> entrypoint_args_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(RunConfiguration);
 };

shell/common/shell.cc

@@ -1573,6 +1573,7 @@ bool Shell::OnServiceProtocolRunInView(
 
   configuration.SetEntrypointAndLibrary(engine_->GetLastEntrypoint(),
                                         engine_->GetLastEntrypointLibrary());
+  configuration.SetEntrypointArgs(engine_->GetLastEntrypointArgs());
 
   configuration.AddAssetResolver(std::make_unique<DirectoryAssetBundle>(
       fml::OpenDirectory(asset_directory_path.c_str(), false,