Pass arbitrary arguments in x run via -- suffix

I.e. if you want to pass string "extras" into an Android intent via `am
start`, call `-e extraKey "extra string"` (and similar for other types
like `--ez key bool` for booleans, or `-d URI` for data URIs).  All
arguments listed by `am help` under the `start` command (including the
`INTENT` specification) is supported.

On the host, this should pass the arguments as-is to the running
executable, `cargo run .. -- <these args>` style.

For IMD, it's unknown what should happen here.

Author: MarijnS95

xbuild/Cargo.toml

@@ -32,6 +32,7 @@ quick-xml = { version = "0.26.0", features = ["serialize"] }
 reqwest = { version = "0.11.13", default-features = false, features = ["blocking", "rustls-tls"] }
 serde = { version = "1.0.151", features = ["derive"] }
 serde_yaml = "0.9.16"
+shlex = "1"
 symlink = "0.1.0"
 tar = "0.4.38"
 toml = "0.5.10"

xbuild/src/command/mod.rs

@@ -26,10 +26,10 @@ pub fn devices() -> Result<()> {
     Ok(())
 }
 
-pub fn run(env: &BuildEnv) -> Result<()> {
+pub fn run(env: &BuildEnv, launch_params: &[String]) -> Result<()> {
     let out = env.executable();
     if let Some(device) = env.target().device() {
-        device.run(env, &out)?;
+        device.run(env, &out, launch_params)?;
     } else {
         anyhow::bail!("no device specified");
     }

xbuild/src/devices/adb.rs

@@ -93,7 +93,16 @@ impl Adb {
     }
 
     /// To run a native activity use "android.app.NativeActivity" as the activity name
-    fn start(&self, device: &str, package: &str, activity: &str) -> Result<()> {
+    fn start(
+        &self,
+        device: &str,
+        package: &str,
+        activity: &str,
+        launch_params: &[String],
+    ) -> Result<()> {
+        // Quote arguments for `am` so that they don't already get parsed by `adb`.
+        let launch_params = shlex::try_join(launch_params.iter().map(String::as_str))
+            .context("Failed to re-quote launch parameters")?;
         let status = self
             .shell(device, None)
             .arg("am")
@@ -102,6 +111,7 @@ impl Adb {
             .arg("android.intent.action.MAIN")
             .arg("-n")
             .arg(format!("{}/{}", package, activity))
+            .arg(launch_params)
             .status()?;
         anyhow::ensure!(
             status.success(),
@@ -340,6 +350,7 @@ impl Adb {
         &self,
         device: &str,
         path: &Path,
+        launch_params: &[String],
         debug_config: &AndroidDebugConfig,
         debug: bool,
     ) -> Result<()> {
@@ -355,7 +366,7 @@ impl Adb {
         self.install(device, path)?;
         self.forward_reverse(device, debug_config)?;
         let last_timestamp = self.logcat_last_timestamp(device)?;
-        self.start(device, package, activity)?;
+        self.start(device, package, activity, launch_params)?;
         let uid = self.uidof(device, package)?;
         let logcat = self.logcat(device, uid, &last_timestamp)?;
         for line in logcat {

xbuild/src/devices/host.rs

@@ -46,8 +46,8 @@ impl Host {
         }
     }
 
-    pub fn run(&self, path: &Path) -> Result<()> {
-        Command::new(path).status()?;
+    pub fn run(&self, path: &Path, launch_params: &[String]) -> Result<()> {
+        Command::new(path).args(launch_params).status()?;
         Ok(())
     }
 

xbuild/src/devices/imd.rs

@@ -48,12 +48,14 @@ impl IMobileDevice {
         Ok(())
     }
 
-    fn start(&self, device: &str, bundle_identifier: &str) -> Result<()> {
+    fn start(&self, device: &str, bundle_identifier: &str, launch_params: &[String]) -> Result<()> {
         let status = Command::new(&self.idevicedebug)
             .arg("--udid")
             .arg(device)
             .arg("run")
             .arg(bundle_identifier)
+            // TODO: Is this even supported?
+            .args(launch_params)
             .status()?;
         anyhow::ensure!(status.success(), "failed to run idevicedebug");
         Ok(())
@@ -92,11 +94,17 @@ impl IMobileDevice {
         Ok(())
     }
 
-    pub fn run(&self, env: &BuildEnv, device: &str, path: &Path) -> Result<()> {
+    pub fn run(
+        &self,
+        env: &BuildEnv,
+        device: &str,
+        path: &Path,
+        launch_params: &[String],
+    ) -> Result<()> {
         let bundle_identifier = appbundle::app_bundle_identifier(path)?;
         self.mount_disk_image(env, device)?;
         self.install(device, path)?;
-        self.start(device, &bundle_identifier)?;
+        self.start(device, &bundle_identifier, launch_params)?;
         Ok(())
     }
 

xbuild/src/devices/mod.rs

@@ -110,11 +110,17 @@ impl Device {
         }
     }
 
-    pub fn run(&self, env: &BuildEnv, path: &Path) -> Result<()> {
+    pub fn run(&self, env: &BuildEnv, path: &Path, launch_params: &[String]) -> Result<()> {
         match &self.backend {
-            Backend::Adb(adb) => adb.run(&self.id, path, &env.config.android().debug, false),
-            Backend::Host(host) => host.run(path),
-            Backend::Imd(imd) => imd.run(env, &self.id, path),
+            Backend::Adb(adb) => adb.run(
+                &self.id,
+                path,
+                launch_params,
+                &env.config.android().debug,
+                false,
+            ),
+            Backend::Host(host) => host.run(path, launch_params),
+            Backend::Imd(imd) => imd.run(env, &self.id, path, launch_params),
         }?;
         Ok(())
     }

xbuild/src/main.rs

@@ -46,6 +46,10 @@ enum Commands {
     Run {
         #[clap(flatten)]
         args: BuildArgs,
+
+        /// Arbitrary platform-specific arguments to pass to the launch command (i.e. to `adb`'s `am start`).
+        #[clap(last = true)]
+        launch_params: Vec<String>,
     },
     /// Launch app in a debugger on an attached device
     Lldb {
@@ -104,10 +108,13 @@ impl Commands {
                 let env = BuildEnv::new(args)?;
                 command::build(&env)?;
             }
-            Self::Run { args } => {
+            Self::Run {
+                args,
+                launch_params,
+            } => {
                 let env = BuildEnv::new(args)?;
                 command::build(&env)?;
-                command::run(&env)?;
+                command::run(&env, &launch_params)?;
             }
             Self::Lldb { args } => {
                 let env = BuildEnv::new(args)?;