feat: android bundling, red/blue exe names, session cache (#3608)

* feat: android bundling

* fix: add hashing to exe names for red/blue exes

* feat: implement session cache for window restoration

Author: jkelleyrtp

packages/cli-config/src/lib.rs

@@ -67,6 +67,7 @@ pub const APP_TITLE_ENV: &str = "DIOXUS_APP_TITLE";
 #[deprecated(since = "0.6.0", note = "The CLI currently does not set this.")]
 #[doc(hidden)]
 pub const OUT_DIR: &str = "DIOXUS_OUT_DIR";
+pub const SESSION_CACHE_DIR: &str = "DIOXUS_SESSION_CACHE_DIR";
 
 /// Reads an environment variable at runtime in debug mode or at compile time in
 /// release mode. When bundling in release mode, we will not be running under the
@@ -277,3 +278,15 @@ pub fn out_dir() -> Option<PathBuf> {
         std::env::var(OUT_DIR).ok().map(PathBuf::from)
     }
 }
+
+/// Get the directory where this app can write to for this session that's guaranteed to be stable
+/// between reloads of the same app. This is useful for emitting state like window position and size
+/// so the app can restore it when it's next opened.
+///
+/// Note that this cache dir is really only useful for platforms that can access it. Web/Android
+/// don't have access to this directory, so it's not useful for them.
+///
+/// This is designed with desktop executables in mind.
+pub fn session_cache_dir() -> Option<PathBuf> {
+    std::env::var(SESSION_CACHE_DIR).ok().map(PathBuf::from)
+}

packages/cli/src/build/bundle.rs

@@ -730,23 +730,7 @@ impl AppBundle {
         if let Platform::Android = self.build.build.platform() {
             self.build.status_running_gradle();
 
-            // make sure we can execute the gradlew script
-            #[cfg(unix)]
-            {
-                use std::os::unix::prelude::PermissionsExt;
-                std::fs::set_permissions(
-                    self.build.root_dir().join("gradlew"),
-                    std::fs::Permissions::from_mode(0o755),
-                )?;
-            }
-
-            let gradle_exec_name = match cfg!(windows) {
-                true => "gradlew.bat",
-                false => "gradlew",
-            };
-            let gradle_exec = self.build.root_dir().join(gradle_exec_name);
-
-            let output = Command::new(gradle_exec)
+            let output = Command::new(self.gradle_exe()?)
                 .arg("assembleDebug")
                 .current_dir(self.build.root_dir())
                 .stderr(std::process::Stdio::piped())
@@ -762,6 +746,62 @@ impl AppBundle {
         Ok(())
     }
 
+    /// Run bundleRelease and return the path to the `.aab` file
+    ///
+    /// https://stackoverflow.com/questions/57072558/whats-the-difference-between-gradlewassemblerelease-gradlewinstallrelease-and
+    pub(crate) async fn android_gradle_bundle(&self) -> Result<PathBuf> {
+        let output = Command::new(self.gradle_exe()?)
+            .arg("bundleRelease")
+            .current_dir(self.build.root_dir())
+            .output()
+            .await
+            .context("Failed to run gradle bundleRelease")?;
+
+        if !output.status.success() {
+            return Err(anyhow::anyhow!("Failed to bundleRelease: {output:?}").into());
+        }
+
+        let app_release = self
+            .build
+            .root_dir()
+            .join("app")
+            .join("build")
+            .join("outputs")
+            .join("bundle")
+            .join("release");
+
+        // Rename it to Name-arch.aab
+        let from = app_release.join("app-release.aab");
+        let to = app_release.join(format!(
+            "{}-{}.aab",
+            self.build.krate.bundled_app_name(),
+            self.build.build.target_args.arch()
+        ));
+
+        std::fs::rename(from, &to).context("Failed to rename aab")?;
+
+        Ok(to)
+    }
+
+    fn gradle_exe(&self) -> Result<PathBuf> {
+        // make sure we can execute the gradlew script
+        #[cfg(unix)]
+        {
+            use std::os::unix::prelude::PermissionsExt;
+            std::fs::set_permissions(
+                self.build.root_dir().join("gradlew"),
+                std::fs::Permissions::from_mode(0o755),
+            )?;
+        }
+
+        let gradle_exec_name = match cfg!(windows) {
+            true => "gradlew.bat",
+            false => "gradlew",
+        };
+
+        Ok(self.build.root_dir().join(gradle_exec_name))
+    }
+
     pub(crate) fn apk_path(&self) -> PathBuf {
         self.build
             .root_dir()

packages/cli/src/cli/bundle.rs

@@ -76,11 +76,12 @@ impl Bundle {
             Platform::Server => bundles.push(bundle.build.root_dir()),
             Platform::Liveview => bundles.push(bundle.build.root_dir()),
 
-            // todo(jon): we can technically create apks (already do...) just need to expose it
             Platform::Android => {
-                return Err(Error::UnsupportedFeature(
-                    "Android bundles are not yet supported".into(),
-                ));
+                let aab = bundle
+                    .android_gradle_bundle()
+                    .await
+                    .context("Failed to run gradle bundleRelease")?;
+                bundles.push(aab);
             }
         };
 

packages/cli/src/cli/run.rs

@@ -46,7 +46,7 @@ impl RunArgs {
                     tracing::info!("[{platform}]: {msg}")
                 }
                 ServeUpdate::ProcessExited { platform, status } => {
-                    runner.kill(platform).await;
+                    runner.cleanup().await;
                     tracing::info!("[{platform}]: process exited with status: {status:?}");
                     break;
                 }

packages/cli/src/cli/target.rs

@@ -217,3 +217,15 @@ impl TryFrom<String> for Arch {
         }
     }
 }
+
+impl std::fmt::Display for Arch {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Arch::Arm => "armv7l",
+            Arch::Arm64 => "aarch64",
+            Arch::X86 => "i386",
+            Arch::X64 => "x86_64",
+        }
+        .fmt(f)
+    }
+}

packages/cli/src/dioxus_crate.rs

@@ -149,6 +149,16 @@ impl DioxusCrate {
         files
     }
 
+    /// Get the directory where this app can write to for this session that's guaranteed to be stable
+    /// for the same app. This is useful for emitting state like window position and size.
+    ///
+    /// The directory is specific for this app and might be
+    pub(crate) fn session_cache_dir(&self) -> PathBuf {
+        self.internal_out_dir()
+            .join(self.executable_name())
+            .join("session-cache")
+    }
+
     /// Get the outdir specified by the Dioxus.toml, relative to the crate directory.
     /// We don't support workspaces yet since that would cause a collision of bundles per project.
     pub(crate) fn crate_out_dir(&self) -> Option<PathBuf> {

packages/cli/src/error.rs

@@ -33,6 +33,7 @@ pub(crate) enum Error {
     #[error("Failed to bundle project: {0}")]
     BundleFailed(#[from] tauri_bundler::Error),
 
+    #[allow(unused)]
     #[error("Unsupported feature: {0}")]
     UnsupportedFeature(String),
 

packages/cli/src/serve/handle.rs

@@ -38,6 +38,11 @@ pub(crate) struct AppHandle {
     pub(crate) server_stdout: Option<Lines<BufReader<ChildStdout>>>,
     pub(crate) server_stderr: Option<Lines<BufReader<ChildStderr>>>,
 
+    /// The executables but with some extra entropy in their name so we can run two instances of the
+    /// same app without causing collisions on the filesystem.
+    pub(crate) entropy_app_exe: Option<PathBuf>,
+    pub(crate) entropy_server_exe: Option<PathBuf>,
+
     /// The virtual directory that assets will be served from
     /// Used mostly for apk/ipa builds since they live in simulator
     pub(crate) runtime_asst_dir: Option<PathBuf>,
@@ -54,6 +59,8 @@ impl AppHandle {
             server_child: None,
             server_stdout: None,
             server_stderr: None,
+            entropy_app_exe: None,
+            entropy_server_exe: None,
         })
     }
 
@@ -79,6 +86,15 @@ impl AppHandle {
             // unset the cargo dirs in the event we're running `dx` locally
             // since the child process will inherit the env vars, we don't want to confuse the downstream process
             ("CARGO_MANIFEST_DIR", "".to_string()),
+            (
+                dioxus_cli_config::SESSION_CACHE_DIR,
+                self.app
+                    .build
+                    .krate
+                    .session_cache_dir()
+                    .display()
+                    .to_string(),
+            ),
         ];
 
         if let Some(base_path) = &self.app.build.krate.config.web.app.base_path {
@@ -87,7 +103,7 @@ impl AppHandle {
 
         // Launch the server if we were given an address to start it on, and the build includes a server. After we
         // start the server, consume its stdout/stderr.
-        if let (Some(addr), Some(server)) = (start_fullstack_on_address, self.app.server_exe()) {
+        if let (Some(addr), Some(server)) = (start_fullstack_on_address, self.server_exe()) {
             tracing::debug!("Proxying fullstack server from port {:?}", addr);
             envs.push((dioxus_cli_config::SERVER_IP_ENV, addr.ip().to_string()));
             envs.push((dioxus_cli_config::SERVER_PORT_ENV, addr.port().to_string()));
@@ -147,6 +163,70 @@ impl AppHandle {
         Ok(())
     }
 
+    /// Gracefully kill the process and all of its children
+    ///
+    /// Uses the `SIGTERM` signal on unix and `taskkill` on windows.
+    /// This complex logic is necessary for things like window state preservation to work properly.
+    ///
+    /// Also wipes away the entropy executables if they exist.
+    pub(crate) async fn cleanup(&mut self) {
+        tracing::debug!("Cleaning up process");
+
+        // Soft-kill the process by sending a sigkill, allowing the process to clean up
+        self.soft_kill().await;
+
+        // Wipe out the entropy executables if they exist
+        if let Some(entropy_app_exe) = self.entropy_app_exe.take() {
+            _ = std::fs::remove_file(entropy_app_exe);
+        }
+
+        if let Some(entropy_server_exe) = self.entropy_server_exe.take() {
+            _ = std::fs::remove_file(entropy_server_exe);
+        }
+    }
+
+    /// Kill the app and server exes
+    pub(crate) async fn soft_kill(&mut self) {
+        use futures_util::FutureExt;
+
+        // Kill any running executables on Windows
+        let server_process = self.server_child.take();
+        let client_process = self.app_child.take();
+        let processes = [server_process, client_process]
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+
+        for mut process in processes {
+            let Some(pid) = process.id() else {
+                _ = process.kill().await;
+                continue;
+            };
+
+            // on unix, we can send a signal to the process to shut down
+            #[cfg(unix)]
+            {
+                _ = Command::new("kill")
+                    .args(["-s", "TERM", &pid.to_string()])
+                    .spawn();
+            }
+
+            // on windows, use the `taskkill` command
+            #[cfg(windows)]
+            {
+                _ = Command::new("taskkill")
+                    .args(["/F", "/PID", &pid.to_string()])
+                    .spawn();
+            }
+
+            // join the wait with a 100ms timeout
+            futures_util::select! {
+                _ = process.wait().fuse() => {}
+                _ = tokio::time::sleep(std::time::Duration::from_millis(1000)).fuse() => {}
+            };
+        }
+    }
+
     /// Hotreload an asset in the running app.
     ///
     /// This will modify the build dir in place! Be careful! We generally assume you want all bundles
@@ -236,12 +316,15 @@ impl AppHandle {
     ///
     /// Server/liveview/desktop are all basically the same, though
     fn open_with_main_exe(&mut self, envs: Vec<(&str, String)>) -> Result<Child> {
-        let child = Command::new(self.app.main_exe())
+        // Create a new entropy app exe if we need to
+        let main_exe = self.app_exe();
+        let child = Command::new(main_exe)
             .envs(envs)
             .stderr(Stdio::piped())
             .stdout(Stdio::piped())
             .kill_on_drop(true)
             .spawn()?;
+
         Ok(child)
     }
 
@@ -650,4 +733,72 @@ We checked the folder: {}
             };
         });
     }
+
+    fn make_entropy_path(exe: &PathBuf) -> PathBuf {
+        let id = uuid::Uuid::new_v4();
+        let name = id.to_string();
+        let some_entropy = name.split('-').next().unwrap();
+
+        // Make a copy of the server exe with a new name
+        let entropy_server_exe = exe.with_file_name(format!(
+            "{}-{}",
+            exe.file_name().unwrap().to_str().unwrap(),
+            some_entropy
+        ));
+
+        std::fs::copy(exe, &entropy_server_exe).unwrap();
+
+        entropy_server_exe
+    }
+
+    fn server_exe(&mut self) -> Option<PathBuf> {
+        let mut server = self.app.server_exe()?;
+
+        // Create a new entropy server exe if we need to
+        if cfg!(target_os = "windows") || cfg!(target_os = "linux") {
+            // If we already have an entropy server exe, return it - this is useful for re-opening the same app
+            if let Some(existing_server) = self.entropy_server_exe.clone() {
+                return Some(existing_server);
+            }
+
+            // Otherwise, create a new entropy server exe and save it for re-opning
+            let entropy_server_exe = Self::make_entropy_path(&server);
+            self.entropy_server_exe = Some(entropy_server_exe.clone());
+            server = entropy_server_exe;
+        }
+
+        Some(server)
+    }
+
+    fn app_exe(&mut self) -> PathBuf {
+        let mut main_exe = self.app.main_exe();
+
+        // The requirement here is based on the platform, not necessarily our current architecture.
+        let requires_entropy = match self.app.build.build.platform() {
+            // When running "bundled", we don't need entropy
+            Platform::Web => false,
+            Platform::MacOS => false,
+            Platform::Ios => false,
+            Platform::Android => false,
+
+            // But on platforms that aren't running as "bundled", we do.
+            Platform::Windows => true,
+            Platform::Linux => true,
+            Platform::Server => true,
+            Platform::Liveview => true,
+        };
+
+        if requires_entropy || std::env::var("DIOXUS_ENTROPY").is_ok() {
+            // If we already have an entropy app exe, return it - this is useful for re-opening the same app
+            if let Some(existing_app_exe) = self.entropy_app_exe.clone() {
+                return existing_app_exe;
+            }
+
+            let entropy_app_exe = Self::make_entropy_path(&main_exe);
+            self.entropy_app_exe = Some(entropy_app_exe.clone());
+            main_exe = entropy_app_exe;
+        }
+
+        main_exe
+    }
 }