Improve the LaunchSingleInstance in cvd start

base/cvd/cuttlefish/host/commands/cvd/cli/commands/start.cpp

@@ -326,27 +326,47 @@ Result<std::vector<Flag>> GetCvdInternalStartFlags(
   return flags;
 }
 
-}  // namespace
-
-CvdStartCommandHandler::CvdStartCommandHandler(
-    InstanceManager& instance_manager)
-    : instance_manager_(instance_manager) {
-  own_flags_.daemon = true;
-}
+bool CanBypassToSingleInstance(const LocalInstance& instance,
+                               const LocalInstanceGroup& group,
+                               const std::vector<std::string>& subcmd_args) {
+  if (instance.State() != cvd::INSTANCE_STATE_STOPPED) {
+    return false;
+  }
+  if (group.StartTime() == TimeStamp{}) {
+    return false;
+  }
 
-static bool HasUnsafeFlagsForBypass(const std::vector<std::string>& args) {
-  std::vector<std::string> args_copy = args;
+  std::vector<std::string> args_copy = subcmd_args;
   bool daemon = true;
-  std::string report_anonymous = "";
   std::vector<Flag> safe_flags = {
       GflagsCompatFlag("daemon", daemon),
-      GflagsCompatFlag("report_anonymous_usage_stats", report_anonymous),
   };
   auto res = ConsumeFlags(safe_flags, args_copy);
-  if (!res.ok()) {
-    return true;
+  if (!res.ok() || !daemon || !args_copy.empty()) {
+    return false;
+  }
+
+  auto instances = group.Instances();
+  if (instances.empty()) {
+    return false;
   }
-  return !args_copy.empty();
+  const LocalInstance& main_instance = instances[0];
+  if (instance.Id() == main_instance.Id()) {
+    return false;
+  }
+  if (main_instance.State() != cvd::INSTANCE_STATE_RUNNING) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace
+
+CvdStartCommandHandler::CvdStartCommandHandler(
+    InstanceManager& instance_manager)
+    : instance_manager_(instance_manager) {
+  own_flags_.daemon = true;
 }
 
 Result<void> CvdStartCommandHandler::Handle(const CommandRequest& request) {
@@ -364,13 +384,11 @@ Result<void> CvdStartCommandHandler::Handle(const CommandRequest& request) {
     auto [instance, group] =
         CF_EXPECT(selector::SelectInstance(instance_manager_, request));
 
-    if (instance.State() == cvd::INSTANCE_STATE_STOPPED &&
-        group.StartTime() != TimeStamp{} &&
-        !HasUnsafeFlagsForBypass(subcmd_args)) {
+    if (CanBypassToSingleInstance(instance, group, subcmd_args)) {
       CF_EXPECT(LaunchSingleInstance(instance, group, request));
       return {};
     } else {
-      VLOG(1) << "Instance is not in stopped state. Proceeding with "
+      VLOG(1) << "Cannot bypass to single instance start. Proceeding with "
                  "normal group start.";
     }
   }
@@ -601,9 +619,11 @@ Result<void> CvdStartCommandHandler::LaunchSingleInstance(
   run_cvd_envs[kAndroidSoongHostOut] = group.HostArtifactsPath();
   run_cvd_envs[kCvdMarkEnv] = "true";
 
+  const cvd_common::Args run_cvd_args = {"--daemon=true"};
+
   ConstructCommandParam construct_cmd_param{.bin_path = bin_path,
                                             .home = group.HomeDir(),
-                                            .args = cvd_common::Args{},
+                                            .args = run_cvd_args,
                                             .envs = run_cvd_envs,
                                             .working_dir = CurrentDirectory(),
                                             .command_name = "run_cvd"};