Skip to main content

cargo_zng/res/built_in/
apk.rs

1use std::process::Command;
2
3use crate::util::glob_walker;
4
5use super::*;
6
7const APK_HELP: &str = r#"
8Build an Android APK from a staging directory
9
10The expected file system layout:
11
12| apk/
13| ├── lib/
14| |   └── arm64-v8a
15| |       └── my-app.so
16| ├── assets/
17| |   └── res
18| |       └── zng-res.txt
19| ├── res/
20| |   └── android-res
21| └── AndroidManifest.xml
22| my-app 'apk
23
24Both 'apk/' and 'my-app 'apk' will be replaced with the built my-app.apk
25
26Expected 'apk file content:
27
28| # Relative path to the staging directory. If not set uses ./apk if it exists
29| # or the parent dir .. if it is named something.apk
30| apk-dir = ./apk
31|
32| # Sign using the debug key. Note that if ZR_APK_KEYSTORE or ZR_APK_KEY_ALIAS are not
33| # set the APK is also signed using the debug key.
34| debug = true
35|
36| # Don't sign and don't zipalign the APK. This outputs an incomplete package that
37| # cannot be installed, but can be modified such as custom linking and signing.
38| raw = true
39|
40| # Don't tar assets. By default `assets/res` are packed as `assets/res.tar`
41| # for use with `android_install_res`.
42| tar-assets-res = false
43
44APK signing is configured using these environment variables:
45
46ZR_APK_KEYSTORE - path to the private .keystore file
47ZR_APK_KEYSTORE_PASS - keystore file password
48ZR_APK_KEY_ALIAS - key name in the keystore
49ZR_APK_KEY_PASS - key password
50"#;
51pub(super) fn apk() {
52    help(APK_HELP);
53    // read config
54    let mut apk_dir = String::new();
55    let mut debug = false;
56    let mut raw = false;
57    let mut tar_assets = true;
58    for line in read_lines(&path(ZR_REQUEST)) {
59        let (ln, line) = line.unwrap_or_else(|e| fatal!("error reading 'apk request, {e}"));
60        if let Some((key, value)) = line.split_once('=') {
61            let key = key.trim();
62            let value = value.trim();
63
64            let bool_value = || match value {
65                "true" => true,
66                "false" => false,
67                _ => {
68                    error!("unexpected value, line {ln}\n   {line}");
69                    false
70                }
71            };
72            match key {
73                "apk-dir" => apk_dir = value.to_owned(),
74                "debug" => debug = bool_value(),
75                "raw" => raw = bool_value(),
76                "tar-assets" => tar_assets = bool_value(),
77                _ => error!("unknown key, line {ln}\n   {line}"),
78            }
79        } else {
80            error!("syntax error, line {ln}\n{line}");
81        }
82    }
83    let mut keystore = PathBuf::from(env::var("ZR_APK_KEYSTORE").unwrap_or_default());
84    let mut keystore_pass = env::var("ZR_APK_KEYSTORE_PASS").unwrap_or_default();
85    let mut key_alias = env::var("ZR_APK_KEY_ALIAS").unwrap_or_default();
86    let mut key_pass = env::var("ZR_APK_KEY_PASS").unwrap_or_default();
87    if keystore.as_os_str().is_empty() || key_alias.is_empty() {
88        debug = true;
89    }
90
91    let mut apk_folder = path(ZR_TARGET_DD);
92    let output_file;
93    if apk_dir.is_empty() {
94        let apk = apk_folder.join("apk");
95        if apk.exists() {
96            apk_folder = apk;
97            output_file = path(ZR_TARGET).with_extension("apk");
98        } else if apk_folder.extension().map(|e| e.eq_ignore_ascii_case("apk")).unwrap_or(false) {
99            output_file = apk_folder.clone();
100        } else {
101            fatal!("missing ./apk")
102        }
103    } else {
104        apk_folder = apk_folder.join(apk_dir);
105        if !apk_folder.is_dir() {
106            fatal!("{} not found or not a directory", apk_folder.display());
107        }
108        output_file = path(ZR_TARGET).with_extension("apk");
109    }
110    let apk_folder = apk_folder;
111
112    // find <sdk>/build-tools
113    let android_home = match env::var("ANDROID_HOME") {
114        Ok(h) if !h.is_empty() => h,
115        _ => fatal!("please set ANDROID_HOME to the android-sdk dir"),
116    };
117    let build_tools = Path::new(&android_home).join("build-tools/");
118    let mut best_build = None;
119    let mut best_version = semver::Version::new(0, 0, 0);
120
121    #[cfg(not(windows))]
122    const AAPT2_NAME: &str = "aapt2";
123    #[cfg(windows)]
124    const AAPT2_NAME: &str = "aapt2.exe";
125
126    for dir in fs::read_dir(build_tools).unwrap_or_else(|e| fatal!("cannot read $ANDROID_HOME/build-tools/, {e}")) {
127        let dir = dir
128            .unwrap_or_else(|e| fatal!("cannot read $ANDROID_HOME/build-tools/ entry, {e}"))
129            .path();
130
131        if let Some(ver) = dir
132            .file_name()
133            .and_then(|f| f.to_str())
134            .and_then(|f| semver::Version::parse(f).ok())
135            && ver > best_version
136            && dir.join(AAPT2_NAME).exists()
137        {
138            best_build = Some(dir);
139            best_version = ver;
140        }
141    }
142    let build_tools = match best_build {
143        Some(p) => p,
144        None => fatal!("cannot find $ANDROID_HOME/build-tools/<version>/{AAPT2_NAME}"),
145    };
146    let aapt2_path = build_tools.join(AAPT2_NAME);
147
148    // temp target dir
149    let temp_dir = apk_folder.with_extension("apk.tmp");
150    let _ = fs::remove_dir_all(&temp_dir);
151    fs::create_dir(&temp_dir).unwrap_or_else(|e| fatal!("cannot create {}, {e}", temp_dir.display()));
152
153    // tar assets
154    let assets = apk_folder.join("assets");
155    let assets_res = assets.join("res");
156    if tar_assets && assets_res.exists() {
157        let tar_path = assets.join("res.tar");
158        let r = Command::new("tar")
159            .arg("-cf")
160            .arg(&tar_path)
161            .arg("res")
162            .current_dir(&assets)
163            .status();
164        match r {
165            Ok(s) => {
166                if !s.success() {
167                    fatal!("tar failed")
168                }
169            }
170            Err(e) => fatal!("cannot run 'tar', {e}"),
171        }
172        if let Err(e) = fs::remove_dir_all(&assets_res) {
173            fatal!("failed tar-assets-res cleanup, {e}")
174        }
175    }
176
177    // build resources
178    let compiled_res = temp_dir.join("compiled_res.zip");
179    let res = apk_folder.join("res");
180    if res.exists() {
181        let mut aapt2 = Command::new(&aapt2_path);
182        aapt2.arg("compile").arg("-o").arg(&compiled_res).arg("--dir").arg(res);
183
184        if aapt2.status().map(|s| !s.success()).unwrap_or(true) {
185            fatal!("resources build failed");
186        }
187    }
188
189    let manifest_path = apk_folder.join("AndroidManifest.xml");
190    let manifest = fs::read_to_string(&manifest_path).unwrap_or_else(|e| fatal!("cannot read AndroidManifest.xml, {e}"));
191    let manifest: AndroidManifest = quick_xml::de::from_str(&manifest).unwrap_or_else(|e| fatal!("error parsing AndroidManifest.xml, {e}"));
192
193    // find <sdk>/platforms
194    let platforms = Path::new(&android_home).join("platforms");
195    let mut best_platform = None;
196    let mut best_version = 0;
197    for dir in fs::read_dir(platforms).unwrap_or_else(|e| fatal!("cannot read $ANDROID_HOME/platforms/, {e}")) {
198        let dir = dir
199            .unwrap_or_else(|e| fatal!("cannot read $ANDROID_HOME/platforms/ entry, {e}"))
200            .path();
201
202        if let Some(ver) = dir
203            .file_name()
204            .and_then(|f| f.to_str())
205            .and_then(|f| f.strip_prefix("android-"))
206            .and_then(|f| f.parse().ok())
207            && manifest.uses_sdk.matches(ver)
208            && ver > best_version
209            && dir.join("android.jar").exists()
210        {
211            best_platform = Some(dir);
212            best_version = ver;
213        }
214    }
215    let platform = match best_platform {
216        Some(p) => p,
217        None => fatal!("cannot find $ANDROID_HOME/platforms/<version>/android.jar"),
218    };
219
220    // make apk (link)
221    let apk_path = temp_dir.join("output.apk");
222    let mut aapt2 = Command::new(&aapt2_path);
223    aapt2
224        .arg("link")
225        .arg("-o")
226        .arg(&apk_path)
227        .arg("--manifest")
228        .arg(manifest_path)
229        .arg("-I")
230        .arg(platform.join("android.jar"));
231    if compiled_res.exists() {
232        aapt2.arg(&compiled_res);
233    }
234    if assets.exists() {
235        aapt2.arg("-A").arg(&assets);
236    }
237    if aapt2.status().map(|s| !s.success()).unwrap_or(true) {
238        fatal!("apk linking failed");
239    }
240
241    // add libs
242    let aapt_path = build_tools.join("aapt");
243    for lib in glob_walker(apk_folder.join("lib/*/*.so").display().to_string().as_str(), false).unwrap() {
244        let lib = lib.unwrap_or_else(|e| fatal!("error searching libs, {e}")).into_path();
245
246        let lib = lib.display().to_string().replace('\\', "/");
247        let lib = &lib[lib.rfind("/lib/").unwrap() + 1..];
248
249        let mut aapt = Command::new(&aapt_path);
250        aapt.arg("add").arg(&apk_path).arg(lib).current_dir(&apk_folder);
251        if aapt.status().map(|s| !s.success()).unwrap_or(true) {
252            fatal!("apk linking failed");
253        }
254    }
255
256    let final_apk = if raw {
257        apk_path
258    } else {
259        // align
260        let aligned_apk_path = temp_dir.join("output-aligned.apk");
261        let zipalign_path = build_tools.join("zipalign");
262        let mut zipalign = Command::new(zipalign_path);
263        zipalign.arg("-v").arg("4").arg(apk_path).arg(&aligned_apk_path);
264        if zipalign.status().map(|s| !s.success()).unwrap_or(true) {
265            fatal!("zipalign failed");
266        }
267
268        // sign
269        let signed_apk_path = temp_dir.join("output-signed.apk");
270        if debug {
271            let dirs = directories::BaseDirs::new().unwrap_or_else(|| fatal!("cannot fine $HOME"));
272            keystore = dirs.home_dir().join(".android/debug.keystore");
273            keystore_pass = "android".to_owned();
274            key_alias = "androiddebugkey".to_owned();
275            key_pass = "android".to_owned();
276            if !keystore.exists() {
277                // generate debug.keystore
278                let _ = fs::create_dir_all(keystore.parent().unwrap());
279                let keytool_path = Path::new(&env::var("JAVA_HOME").expect("please set JAVA_HOME")).join("bin/keytool");
280                let mut keytool = Command::new(&keytool_path);
281                keytool
282                    .arg("-genkey")
283                    .arg("-v")
284                    .arg("-keystore")
285                    .arg(&keystore)
286                    .arg("-storepass")
287                    .arg(&keystore_pass)
288                    .arg("-alias")
289                    .arg(&key_alias)
290                    .arg("-keypass")
291                    .arg(&key_pass)
292                    .arg("-keyalg")
293                    .arg("RSA")
294                    .arg("-keysize")
295                    .arg("2048")
296                    .arg("-validity")
297                    .arg("10000")
298                    .arg("-dname")
299                    .arg("CN=Android Debug,O=Android,C=US")
300                    .arg("-storetype")
301                    .arg("pkcs12");
302
303                match keytool.status() {
304                    Ok(s) => {
305                        if !s.success() {
306                            fatal!("keytool failed generating debug keys");
307                        }
308                    }
309                    Err(e) => fatal!("cannot run '{}', {e}", keytool_path.display()),
310                }
311            }
312        }
313
314        #[cfg(not(windows))]
315        const APKSIGNER_NAME: &str = "apksigner";
316        #[cfg(windows)]
317        const APKSIGNER_NAME: &str = "apksigner.bat";
318
319        let apksigner_path = build_tools.join(APKSIGNER_NAME);
320        let mut apksigner = Command::new(&apksigner_path);
321        apksigner
322            .arg("sign")
323            .arg("--ks")
324            .arg(keystore)
325            .arg("--ks-pass")
326            .arg(format!("pass:{keystore_pass}"))
327            .arg("--ks-key-alias")
328            .arg(key_alias)
329            .arg("--key-pass")
330            .arg(format!("pass:{key_pass}"))
331            .arg("--out")
332            .arg(&signed_apk_path)
333            .arg(&aligned_apk_path);
334
335        match apksigner.status() {
336            Ok(s) => {
337                if !s.success() {
338                    fatal!("apksigner failed")
339                }
340            }
341            Err(e) => fatal!("cannot run '{}', {e}", apksigner_path.display()),
342        }
343        signed_apk_path
344    };
345
346    // finalize
347    fs::remove_dir_all(&apk_folder).unwrap_or_else(|e| fatal!("apk folder cleanup failed, {e}"));
348    fs::rename(final_apk, output_file).unwrap_or_else(|e| fatal!("cannot copy built apk to final place, {e}"));
349    fs::remove_dir_all(&temp_dir).unwrap_or_else(|e| fatal!("temp dir cleanup failed, {e}"));
350    let _ = fs::remove_file(path(ZR_TARGET));
351}
352#[derive(serde::Deserialize)]
353#[serde(rename = "manifest")]
354struct AndroidManifest {
355    #[serde(rename = "uses-sdk")]
356    #[serde(default)]
357    pub uses_sdk: AndroidSdk,
358}
359#[derive(Default, serde::Deserialize)]
360#[serde(rename = "uses-sdk")]
361struct AndroidSdk {
362    #[serde(rename(serialize = "android:minSdkVersion"))]
363    pub min_sdk_version: Option<u32>,
364    #[serde(rename(serialize = "android:targetSdkVersion"))]
365    pub target_sdk_version: Option<u32>,
366    #[serde(rename(serialize = "android:maxSdkVersion"))]
367    pub max_sdk_version: Option<u32>,
368}
369impl AndroidSdk {
370    pub fn matches(&self, version: u32) -> bool {
371        if let Some(v) = self.target_sdk_version {
372            return v == version;
373        }
374        if let Some(m) = self.min_sdk_version
375            && version < m
376        {
377            return false;
378        }
379        if let Some(m) = self.max_sdk_version
380            && version > m
381        {
382            return false;
383        }
384        true
385    }
386}