cargo_zng/res/built_in/
apk.rs1use 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 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 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 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 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 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 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 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 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 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 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 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 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}