🔀 Merge develop into main (pull request #8)

Release 1.1.1

# External changes
- Fix crash on devices with no package matches (#7).

# Internal changes
- Move declarations around to adhere to code style.

Author: matheusamazonas

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "batch_apk_installer"
 description = "A command-line tool for batch installation of Android Packages (APKs)."
-version = "1.1.0"
+version = "1.1.1"
 edition = "2024"
 license = "MIT"
 authors = ["Matheus Amazonas"]

Cargo.toml

@@ -4,9 +4,6 @@ use serde::Deserialize;
 use std::fs::{self, File};
 use std::io::Write;
 
-pub type Platform = String;
-pub type PackageID = String;
-
 const CONFIG_PATH: &str = "Batch APK Installer";
 const CONFIG_FILE: &str = "config.toml";
 const CONFIG_TEMPLATE: &str = r#"directory = "/Users/user_name/Desktop"
@@ -27,6 +24,9 @@ id = "com.company.product.quest_only_app"
 platforms = [ "pico" ]
 match_file_name = true"#;
 
+pub type Platform = String;
+pub type PackageID = String;
+
 #[derive(Deserialize)]
 pub struct Config {
 	directory: String,

src/config.rs

@@ -22,46 +22,57 @@ impl Device {
 	pub fn platform(&self) -> &String {
 		&self.platform
 	}
-}
 
-impl Display for Device {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f, "[{}] {} ({})", self.platform, self.name, self.id)
+	fn from_str_with_platforms(line: &str, platforms: &[Platform]) -> Option<Device> {
+		let (id, platform) = Self::parse_info(line, platforms)?;
+		let name = Self::parse_name(&id).ok()?;
+		let device = Self { name, id, platform };
+		Some(device)
 	}
-}
 
-pub fn get_devices(platforms: &[Platform]) -> Result<Vec<Device>, Error> {
-	let output = Command::new("adb").args(["devices", "-l"]).output()?;
-	let output = String::from_utf8(output.stdout)?;
-	let header_line_ix = output
-		.lines()
-		.position(|l| l.contains("List of devices attached"))
-		.ok_or(Error::DevicesFetching)?;
-
-	let devices = output
-		.lines()
-		.skip(header_line_ix + 1)
-		.filter(|l| !l.is_empty())
-		.filter_map(|l| parse_device(l, platforms))
-		.collect();
-	Ok(devices)
-}
+	fn parse_name(id: &str) -> Result<String, Error> {
+		let output = Command::new("adb")
+			.args(["-s", id, "shell", "settings get global device_name"])
+			.output()?;
+		let name = String::from_utf8(output.stdout)?;
+		match name.len() {
+			0 => Err(Error::NoDeviceName),
+			_ => Ok(String::from(name.trim_end())),
+		}
+	}
+
+	fn parse_info(line: &str, platforms: &[Platform]) -> Option<(String, Platform)> {
+		let regex = Regex::new(r"(\w+)\s+.*model:(\w+)\sdevice:(\w+)").ok()?;
+		let caps = regex.captures(line)?;
+		let id = String::from(caps.get(1)?.as_str());
+		let model = caps.get(2)?.as_str();
+		let device_name = caps.get(3)?.as_str();
+		let platform = get_platform(model, platforms).or(get_platform(device_name, platforms))?;
+		Some((id, platform))
+	}
 
-fn parse_device(line: &str, platforms: &[Platform]) -> Option<Device> {
-	let (id, platform) = parse_device_info(line, platforms)?;
-	let name = get_device_name(&id).ok()?;
-	let device = Device { name, id, platform };
-	Some(device)
+	pub fn get_devices(platforms: &[Platform]) -> Result<Vec<Device>, Error> {
+		let output = Command::new("adb").args(["devices", "-l"]).output()?;
+		let output = String::from_utf8(output.stdout)?;
+		let header_line_ix = output
+			.lines()
+			.position(|l| l.contains("List of devices attached"))
+			.ok_or(Error::DevicesFetching)?;
+
+		let devices = output
+			.lines()
+			.skip(header_line_ix + 1)
+			.filter(|l| !l.is_empty())
+			.filter_map(|l| Self::from_str_with_platforms(l, platforms))
+			.collect();
+		Ok(devices)
+	}
 }
 
-fn parse_device_info(line: &str, platforms: &[Platform]) -> Option<(String, Platform)> {
-	let regex = Regex::new(r"(\w+)\s+.*model:(\w+)\sdevice:(\w+)").ok()?;
-	let caps = regex.captures(line)?;
-	let id = String::from(caps.get(1)?.as_str());
-	let model = caps.get(2)?.as_str();
-	let device_name = caps.get(3)?.as_str();
-	let platform = get_platform(model, platforms).or(get_platform(device_name, platforms))?;
-	Some((id, platform))
+impl Display for Device {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "[{}] {} ({})", self.platform, self.name, self.id)
+	}
 }
 
 fn get_platform(identifier: &str, platforms: &[Platform]) -> Option<Platform> {
@@ -70,17 +81,6 @@ fn get_platform(identifier: &str, platforms: &[Platform]) -> Option<Platform> {
 	Some(platform.clone())
 }
 
-fn get_device_name(id: &str) -> Result<String, Error> {
-	let output = Command::new("adb")
-		.args(["-s", id, "shell", "settings get global device_name"])
-		.output()?;
-	let name = String::from_utf8(output.stdout)?;
-	match name.len() {
-		0 => Err(Error::NoDeviceName),
-		_ => Ok(String::from(name.trim_end())),
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -122,7 +122,7 @@ mod tests {
 		let data = "PA7L50MGF8290021W      device usb:34873344X product:A7H10 model:Pico_Neo_3 \
 		 device:PICOA7H10 transport_id:2";
 		let platforms = get_platforms();
-		let info = parse_device_info(data, &platforms);
+		let info = Device::parse_info(data, &platforms);
 		assert!(info.is_some());
 		let (id, platform) = info.unwrap();
 		assert_eq!(id, String::from("PA7L50MGF8290021W"));
@@ -134,7 +134,7 @@ mod tests {
 		let data = "PA8150MGGB230744G      device usb:34603008X product:Phoenix_ovs model:A8110 \
 		 device:PICOA8110 transport_id:7";
 		let platforms = get_platforms();
-		let info = parse_device_info(data, &platforms);
+		let info = Device::parse_info(data, &platforms);
 		assert!(info.is_some());
 		let (id, platform) = info.unwrap();
 		assert_eq!(id, String::from("PA8150MGGB230744G"));
@@ -146,7 +146,7 @@ mod tests {
 		let data = "1WMHHA63PR1501         device usb:34603008X product:hollywood model:Quest_2 \
 		 device:hollywood transport_id:9";
 		let platforms = get_platforms();
-		let info = parse_device_info(data, &platforms);
+		let info = Device::parse_info(data, &platforms);
 		assert!(info.is_some());
 		let (id, platform) = info.unwrap();
 		assert_eq!(id, String::from("1WMHHA63PR1501"));
@@ -158,7 +158,7 @@ mod tests {
 		let data = "ce031713396bc92803     device usb:1048576X product:dreamltexx model:SM_G950F \
 		 device:dreamlte transport_id:4";
 		let platforms = get_platforms();
-		let info = parse_device_info(data, &platforms);
+		let info = Device::parse_info(data, &platforms);
 		assert!(info.is_some());
 		let (id, platform) = info.unwrap();
 		assert_eq!(id, String::from("ce031713396bc92803"));

src/device.rs

@@ -6,12 +6,6 @@ use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
-pub struct DeviceInstallations {
-	device: Arc<Device>,
-	packages: Vec<Arc<Package>>,
-	uninstall_first: bool,
-}
-
 pub struct CommandOutcome {
 	description: String,
 	error: Option<Error>,
@@ -27,21 +21,32 @@ impl CommandOutcome {
 	}
 }
 
+pub struct DeviceInstallations {
+	device: Arc<Device>,
+	packages: Vec<Arc<Package>>,
+	uninstall_first: bool,
+}
+
 impl DeviceInstallations {
 	pub fn build_requests(
 		devices: &[Arc<Device>], packages: &[Arc<Package>], uninstall_first: bool,
 	) -> Vec<DeviceInstallations> {
 		let mut requests: Vec<DeviceInstallations> = Vec::new();
 		for device in devices {
-			let matches = packages.iter().filter(|p| is_package_match(device, p));
-			let mut packages = vec![];
+			let matches: Vec<_> = packages
+				.iter()
+				.filter(|p| is_package_match(device, p))
+				.collect();
+			if matches.is_empty() {
+				continue;
+			}
+			let mut packages = Vec::with_capacity(matches.len());
 			for package in matches {
 				let package = package.clone();
 				packages.push(package);
 			}
-			let device = device.clone();
 			let installations = DeviceInstallations {
-				device,
+				device: device.clone(),
 				packages,
 				uninstall_first,
 			};

src/installation.rs

@@ -1,6 +1,8 @@
 use crate::config::Config;
+use crate::device::Device;
 use crate::error::Error;
 use crate::installation::DeviceInstallations;
+use crate::package::Package;
 use futures::{StreamExt, stream};
 use std::env;
 use std::path::PathBuf;
@@ -92,7 +94,7 @@ async fn main() {
 		}
 	};
 
-	let devices: Vec<_> = match device::get_devices(config.platforms()) {
+	let devices: Vec<_> = match Device::get_devices(config.platforms()) {
 		Ok(devices) if !devices.is_empty() => devices.into_iter().map(Arc::new).collect(),
 		Ok(_) => {
 			print_error("No devices were found.");
@@ -110,7 +112,7 @@ async fn main() {
 	}
 
 	let packages_dir = PathBuf::from(config.directory()).join(packages_folder);
-	let packages: Vec<_> = match package::find_all_packages(&packages_dir, config.packages()) {
+	let packages: Vec<_> = match Package::find_all(&packages_dir, config.packages()) {
 		Ok(packages) => packages.into_iter().map(Arc::new).collect(),
 		Err(e) => {
 			print_error(&e.to_string());

src/main.rs

@@ -5,26 +5,44 @@ use std::fs;
 use std::path::PathBuf;
 use std::process::Command;
 
-pub struct Package {
-	id: PackageID,
-	path: String,
-	file_name: String,
-	platforms: Vec<Platform>,
-	match_file_name: bool,
-}
-
 pub struct PackageFile {
 	path: PathBuf,
 	id: PackageID,
 }
 
+impl PackageFile {
+	fn try_from_path(path: &PathBuf) -> Result<PackageFile, Error> {
+		let path_str = path.to_str().ok_or(Error::MalformedPackageFilePath)?;
+		let output = Command::new("aapt2")
+			.args(["dump", "packagename", path_str])
+			.output()?;
+		if output.status.success() {
+			let output = String::from_utf8(output.stdout)?;
+			let id = String::from(output.trim_end());
+			let path = PathBuf::from(path);
+			let package = PackageFile { path, id };
+			Ok(package)
+		} else {
+			Err(Error::PackageNameNotFound)
+		}
+	}
+}
+
 #[derive(Deserialize)]
 pub struct PackageConfig {
 	id: PackageID,
 	platforms: Vec<Platform>,
 	match_file_name: bool,
 }
 
+pub struct Package {
+	id: PackageID,
+	path: String,
+	file_name: String,
+	platforms: Vec<Platform>,
+	match_file_name: bool,
+}
+
 impl Package {
 	pub fn try_new(
 		file: PackageFile, platforms: Vec<Platform>, match_file_name: bool,
@@ -60,25 +78,25 @@ impl Package {
 	pub fn match_file_name(&self) -> bool {
 		self.match_file_name
 	}
-}
 
-pub fn find_all_packages(dir: &PathBuf, configs: &[PackageConfig]) -> Result<Vec<Package>, Error> {
 	fn build_package(file: PackageFile, configs: &[PackageConfig]) -> Option<Package> {
 		let config = configs.iter().find(|c| c.id == file.id)?;
-		let package = Package::try_new(file, config.platforms.clone(), config.match_file_name)?;
+		let package = Self::try_new(file, config.platforms.clone(), config.match_file_name)?;
 		Some(package)
 	}
 
-	if let Ok(true) = fs::exists(dir) {
-		let files = find_apk_files(dir)?
-			.into_iter()
-			.filter_map(|f| get_package_file(&f).ok())
-			.filter_map(|f| build_package(f, configs))
-			.collect();
-		Ok(files)
-	} else {
-		let path = dir.to_string_lossy().to_string();
-		Err(Error::NoPackageDirectory(path))
+	pub fn find_all(dir: &PathBuf, configs: &[PackageConfig]) -> Result<Vec<Package>, Error> {
+		if let Ok(true) = fs::exists(dir) {
+			let files = find_apk_files(dir)?
+				.into_iter()
+				.filter_map(|f| PackageFile::try_from_path(&f).ok())
+				.filter_map(|f| Self::build_package(f, configs))
+				.collect();
+			Ok(files)
+		} else {
+			let path = dir.to_string_lossy().to_string();
+			Err(Error::NoPackageDirectory(path))
+		}
 	}
 }
 
@@ -90,19 +108,3 @@ fn find_apk_files(dir: &PathBuf) -> Result<Vec<PathBuf>, Error> {
 		.collect();
 	Ok(entries)
 }
-
-fn get_package_file(path: &PathBuf) -> Result<PackageFile, Error> {
-	let path_str = path.to_str().ok_or(Error::MalformedPackageFilePath)?;
-	let output = Command::new("aapt2")
-		.args(["dump", "packagename", path_str])
-		.output()?;
-	if output.status.success() {
-		let output = String::from_utf8(output.stdout)?;
-		let id = String::from(output.trim_end());
-		let path = PathBuf::from(path);
-		let package = PackageFile { path, id };
-		Ok(package)
-	} else {
-		Err(Error::PackageNameNotFound)
-	}
-}