refactor: move Android project to the tauri crate (#6241)

.github/workflows/test-mobile.yml

@@ -5,11 +5,11 @@ on:
     paths:
       - '.github/workflows/test-mobile.yml'
       - 'tooling/cli/templates/mobile/**'
-      - 'tooling/cli/mobile/android/**'
       - 'tooling/cli/src/mobile/**'
       - '!tooling/cli/src/mobile/ios.rs'
       - '!tooling/cli/src/mobile/ios/**'
       - 'core/tauri-build/src/mobile.rs'
+      - 'core/tauri/mobile/android/**'
   workflow_dispatch:
 
 concurrency:

core/tauri-build/src/mobile.rs

@@ -1,7 +1,7 @@
 use std::{
   env::var,
   fs::{self, rename},
-  path::{PathBuf, MAIN_SEPARATOR},
+  path::{Path, PathBuf},
 };
 
 use anyhow::Result;
@@ -29,50 +29,18 @@ impl PluginBuilder {
     if target_os == "android" {
       if let Some(path) = self.android_path {
         let manifest_dir = var("CARGO_MANIFEST_DIR").map(PathBuf::from).unwrap();
-        if let (Ok(out_dir), Ok(gradle_settings_path), Ok(app_build_gradle_path)) = (
-          var("TAURI_PLUGIN_OUTPUT_PATH"),
-          var("TAURI_GRADLE_SETTINGS_PATH"),
-          var("TAURI_APP_GRADLE_BUILD_PATH"),
-        ) {
+        if let Ok(project_dir) = var("TAURI_ANDROID_PROJECT_PATH") {
           let source = manifest_dir.join(path);
           let pkg_name = var("CARGO_PKG_NAME").unwrap();
 
           println!("cargo:rerun-if-env-changed=TAURI_PLUGIN_OUTPUT_PATH");
           println!("cargo:rerun-if-env-changed=TAURI_GRADLE_SETTINGS_PATH");
-          println!("cargo:rerun-if-changed={out_dir}{MAIN_SEPARATOR}{pkg_name}",);
-          println!("cargo:rerun-if-changed={gradle_settings_path}");
-          println!("cargo:rerun-if-changed={app_build_gradle_path}");
-
-          let out_dir = PathBuf::from(out_dir);
-          let target = out_dir.join(&pkg_name);
-
-          // keep build folder if it exists
-          let build_path = target.join("build");
-          let out_dir = if build_path.exists() {
-            let out_dir = out_dir.join(".tauri-plugin-build");
-            rename(&build_path, &out_dir)?;
-            Some(out_dir)
-          } else {
-            None
-          };
-
-          let _ = fs::remove_dir_all(&target);
-
-          for entry in walkdir::WalkDir::new(&source) {
-            let entry = entry?;
-            let rel_path = entry.path().strip_prefix(&source)?;
-            let dest_path = target.join(rel_path);
-            if entry.file_type().is_dir() {
-              fs::create_dir(dest_path)?;
-            } else {
-              fs::copy(entry.path(), dest_path)?;
-            }
-          }
 
-          if let Some(out_dir) = out_dir {
-            rename(out_dir, &build_path)?;
-          }
+          let project_dir = PathBuf::from(project_dir);
 
+          inject_android_project(source, project_dir.join("tauri-plugins").join(&pkg_name))?;
+
+          let gradle_settings_path = project_dir.join("tauri.settings.gradle");
           let gradle_settings = fs::read_to_string(&gradle_settings_path)?;
           let include = format!(
             "include ':{pkg_name}'
@@ -85,6 +53,7 @@ project(':{pkg_name}').projectDir = new File('./tauri-plugins/{pkg_name}')"
             )?;
           }
 
+          let app_build_gradle_path = project_dir.join("app").join("tauri.build.gradle.kts");
           let app_build_gradle = fs::read_to_string(&app_build_gradle_path)?;
           let implementation = format!(r#"implementation(project(":{pkg_name}"))"#);
           let target = "dependencies {";
@@ -101,3 +70,38 @@ project(':{pkg_name}').projectDir = new File('./tauri-plugins/{pkg_name}')"
     Ok(())
   }
 }
+
+#[doc(hidden)]
+pub fn inject_android_project(source: impl AsRef<Path>, target: impl AsRef<Path>) -> Result<()> {
+  let source = source.as_ref();
+  let target = target.as_ref();
+
+  // keep build folder if it exists
+  let build_path = target.join("build");
+  let out_dir = if build_path.exists() {
+    let out_dir = target.parent().unwrap().join(".tauri-tmp-build");
+    rename(&build_path, &out_dir)?;
+    Some(out_dir)
+  } else {
+    None
+  };
+
+  let _ = fs::remove_dir_all(target);
+
+  for entry in walkdir::WalkDir::new(source) {
+    let entry = entry?;
+    let rel_path = entry.path().strip_prefix(source)?;
+    let dest_path = target.join(rel_path);
+    if entry.file_type().is_dir() {
+      fs::create_dir(dest_path)?;
+    } else {
+      fs::copy(entry.path(), dest_path)?;
+    }
+  }
+
+  if let Some(out_dir) = out_dir {
+    rename(out_dir, &build_path)?;
+  }
+
+  Ok(())
+}

core/tauri/Cargo.toml

@@ -119,6 +119,7 @@ libc = "0.2"
 [build-dependencies]
 heck = "0.4"
 once_cell = "1"
+tauri-build = { path = "../tauri-build/" }
 
 [dev-dependencies]
 mockito = "0.31"

core/tauri/build.rs

@@ -8,6 +8,8 @@ use heck::ToSnakeCase;
 
 use once_cell::sync::OnceCell;
 
+use std::env::var;
+use std::path::PathBuf;
 use std::{path::Path, sync::Mutex};
 
 static CHECKED_FEATURES: OnceCell<Mutex<Vec<String>>> = OnceCell::new();
@@ -141,6 +143,17 @@ fn main() {
     CHECKED_FEATURES.get().unwrap().lock().unwrap().join(","),
   )
   .expect("failed to write checked_features file");
+
+  if target_os == "android" {
+    if let Ok(project_dir) = var("TAURI_ANDROID_PROJECT_PATH") {
+      let project_dir = PathBuf::from(project_dir);
+      tauri_build::mobile::inject_android_project(
+        "./mobile/android",
+        project_dir.join("tauri-api"),
+      )
+      .expect("failed to copy tauri-api Android project");
+    }
+  }
 }
 
 // create aliases for the given module with its apis.

examples/api/src-tauri/Cargo.lock

@@ -3037,6 +3037,7 @@ dependencies = [
  "shared_child",
  "state",
  "tar",
+ "tauri-build",
  "tauri-macros",
  "tauri-runtime",
  "tauri-runtime-wry",

tooling/cli/src/mobile/android.rs

@@ -136,6 +136,7 @@ pub fn get_config(
       ))
       .join("generated"),
   );
+  set_var("TAURI_ANDROID_PROJECT_PATH", config.project_dir());
   let plugin_output_path = config.project_dir().join("tauri-plugins");
   set_var("TAURI_PLUGIN_OUTPUT_PATH", plugin_output_path);
   set_var(

tooling/cli/src/mobile/mod.rs

@@ -11,8 +11,7 @@ use crate::{
   },
   interface::{AppInterface, AppSettings, DevProcess, Interface, Options as InterfaceOptions},
 };
-use anyhow::{bail, Context, Result};
-use include_dir::{include_dir, Dir};
+use anyhow::{bail, Result};
 use jsonrpsee::client_transport::ws::WsTransportClientBuilder;
 use jsonrpsee::core::client::{Client, ClientBuilder, ClientT};
 use jsonrpsee::rpc_params;
@@ -25,7 +24,7 @@ use std::{
   env::{set_var, temp_dir},
   ffi::OsString,
   fmt::Write,
-  fs::{create_dir_all, read_to_string, remove_dir_all, rename, write},
+  fs::{create_dir_all, read_to_string, write},
   net::SocketAddr,
   path::PathBuf,
   process::ExitStatus,
@@ -53,7 +52,6 @@ mod init;
 pub mod ios;
 
 const MIN_DEVICE_MATCH_SCORE: isize = 0;
-static ANDROID_API_PROJECT_DIR: Dir<'_> = include_dir!("mobile/android");
 
 #[derive(Clone)]
 pub struct DevChild {
@@ -314,36 +312,6 @@ fn ensure_init(project_dir: PathBuf, target: Target) -> Result<()> {
     )
   } else {
     create_dir_all(project_dir.join("tauri-plugins"))?;
-
-    #[allow(irrefutable_let_patterns)]
-    if let Target::Android = target {
-      let tauri_api_dir_path = project_dir.join("tauri-api");
-      let build_path = if tauri_api_dir_path.exists() {
-        // keep build folder if it exists
-        let build_path = tauri_api_dir_path.join("build");
-        let out_dir = if build_path.exists() {
-          let out_dir = project_dir.join(".tauri-api-build");
-          rename(&build_path, &out_dir)?;
-          Some(out_dir)
-        } else {
-          None
-        };
-        remove_dir_all(&tauri_api_dir_path)?;
-        out_dir
-      } else {
-        None
-      };
-      create_dir_all(&tauri_api_dir_path)?;
-
-      ANDROID_API_PROJECT_DIR
-        .extract(&tauri_api_dir_path)
-        .context("failed to extract Tauri API project")?;
-
-      if let Some(build_path) = build_path {
-        rename(build_path, tauri_api_dir_path.join("build"))?;
-      }
-    }
-
     Ok(())
   }
 }