Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

App windows: show the phone's apps at once

Bee338defa341b7
diff --git a/android/app/src/main/kotlin/app/nectarlink/android/mirror/AppWindows.kt b/android/app/src/main/kotlin/app/nectarlink/android/mirror/AppWindows.kt
index 2ba91c4..a0dfad4 100644
--- a/android/app/src/main/kotlin/app/nectarlink/android/mirror/AppWindows.kt
+++ b/android/app/src/main/kotlin/app/nectarlink/android/mirror/AppWindows.kt
@@ -281,7 +281,8 @@ class AppWindows(
@Suppress("DEPRECATION")
manager.queryIntentActivities(launcher, 0)
}
- return found
+ val used = HashSet<String>()
+ val apps = found
.map { it.activityInfo }
.filter { it.packageName != context.packageName }
.distinctBy { it.packageName }
@@ -289,10 +290,32 @@ class AppWindows(
PhoneApp(
pkg = info.packageName,
label = info.loadLabel(manager).toString().trim().ifEmpty { info.packageName },
- icon = runCatching { icon(info.loadIcon(manager)) }.getOrNull(),
+ icon = cachedIcon(info, manager, used),
)
}
.sortedBy { it.label.lowercase() }
+ // Forget uninstalled and updated apps' icons.
+ icons.keys.retainAll(used)
+ return apps
+ }
+
+ /**
+ * Icons drawn for an earlier list, by package and its installed APK
+ * (a new path after every update) and icon: drawing and compressing
+ * every icon again made every list slow to arrive.
+ */
+ private val icons = java.util.concurrent.ConcurrentHashMap<String, ByteArray>()
+ private val NO_ICON = ByteArray(0)
+
+ private fun cachedIcon(
+ info: android.content.pm.ActivityInfo,
+ manager: PackageManager,
+ used: MutableSet<String>,
+ ): ByteArray? {
+ val key = "${info.packageName}|${info.applicationInfo?.sourceDir}|${info.iconResource}"
+ used += key
+ val png = icons.getOrPut(key) { runCatching { icon(info.loadIcon(manager)) }.getOrNull() ?: NO_ICON }
+ return png.takeIf { it.isNotEmpty() }
}
/** A PNG of the icon: 64 pixels, or 48 when that's too big. */
diff --git a/desktop/app/i18n/rust_strings.h b/desktop/app/i18n/rust_strings.h
index 800d6d1..dc1cb77 100644
--- a/desktop/app/i18n/rust_strings.h
+++ b/desktop/app/i18n/rust_strings.h
@@ -68,6 +68,7 @@ static const char *const nectarlink_rust_strings[] = {
QT_TRANSLATE_NOOP("Mirror", "Couldn't start recording."), // desktop/app/src/mirror.rs
QT_TRANSLATE_NOOP("Mirror", "Saved %1 to Downloads\\Nectarlink."), // desktop/app/src/mirror.rs
QT_TRANSLATE_NOOP("Mirror", "Screenshot copied to clipboard."), // desktop/app/src/mirror.rs
+ QT_TRANSLATE_NOOP("Mirror", "Set up Wireless debugging in NectarLink on the phone to open its apps here."), // desktop/app/src/mirror.rs
QT_TRANSLATE_NOOP("Mirror", "The screenshot couldn't be copied to the clipboard."), // desktop/app/src/mirror.rs
QT_TRANSLATE_NOOP("Mirror", "The screenshot couldn't be saved."), // desktop/app/src/mirror.rs
QT_TRANSLATE_NOOP("Mirror", "Wait for the screen to appear first."), // desktop/app/src/mirror.rs
diff --git a/desktop/app/src/mirror.rs b/desktop/app/src/mirror.rs
index b31f2b7..f20da75 100644
--- a/desktop/app/src/mirror.rs
+++ b/desktop/app/src/mirror.rs
@@ -1070,31 +1070,60 @@ pub fn apps(device: &DeviceId) -> Option<Apps> {
state(|s| s.apps.get(device).cloned())
}
-/// Loads (or reloads) a phone's apps, with their icons.
+/// Loads (or reloads) a phone's apps, with their icons. A list already
+/// loaded (this run, or saved by an earlier one) shows at once and stays up
+/// while the phone sends a fresh one: only the first load ever waits.
pub fn load_apps(device: DeviceId) {
- state(|s| s.apps.insert(device, Apps::Loading));
+ let data_dir = core_host::host().data_dir.clone();
+ let shown = state(|s| match s.apps.get(&device) {
+ Some(Apps::Ready(_)) => true,
+ _ => match saved_apps(&data_dir, &device) {
+ Some(saved) => {
+ s.apps.insert(device, Apps::Ready(saved));
+ true
+ }
+ None => {
+ s.apps.insert(device, Apps::Loading);
+ false
+ }
+ },
+ });
core_host::host().hub.changed(Changes::MIRROR);
let Some(node) = core_host::node() else { return };
core_host::spawn(async move {
+ let started = Instant::now();
let loaded = match node.mirror_apps(device).await {
Ok(apps) => {
- let data_dir = core_host::host().data_dir.clone();
let apps = tokio::task::spawn_blocking(move || {
- apps.into_iter()
+ let apps: Vec<App> = apps
+ .into_iter()
.map(|a| App {
icon: a.icon.and_then(|png| crate::icons::save(&data_dir, &a.pkg, &png).ok()),
pkg: a.pkg,
label: a.label,
})
- .collect()
+ .collect();
+ save_apps(&data_dir, &device, &apps);
+ apps
})
.await
.unwrap_or_default();
+ tracing::info!(
+ apps = apps.len(),
+ ms = started.elapsed().as_millis() as u64,
+ "loaded a phone's apps"
+ );
Apps::Ready(apps)
}
- Err(Error::Unsupported) => Apps::Failed(
- "Set up Wireless debugging in NectarLink on the phone to open its apps here.".into(),
- ),
+ // A list on screen stays: it is a moment old, not wrong.
+ Err(e) if shown => {
+ tracing::info!(error = %e, "can't refresh a phone's apps; keeping the last list");
+ return;
+ }
+ Err(Error::Unsupported) => Apps::Failed(tr!(
+ "Mirror",
+ "Set up Wireless debugging in NectarLink on the phone to open its apps here."
+ )),
Err(e) => Apps::Failed(describe(&e)),
};
state(|s| s.apps.insert(device, loaded));
@@ -1102,6 +1131,42 @@ pub fn load_apps(device: DeviceId) {
});
}
+fn saved_apps_path(data_dir: &Path, device: &DeviceId) -> PathBuf {
+ data_dir.join("cache").join("apps").join(format!("{device}.json"))
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct SavedApp {
+ pkg: String,
+ label: String,
+}
+
+/// The phone's apps as an earlier run saved them, with the icons it kept.
+fn saved_apps(data_dir: &Path, device: &DeviceId) -> Option<Vec<App>> {
+ let bytes = std::fs::read(saved_apps_path(data_dir, device)).ok()?;
+ let saved: Vec<SavedApp> = serde_json::from_slice(&bytes).ok()?;
+ let apps: Vec<App> = saved
+ .into_iter()
+ .filter(|a| nectarlink_core::is_package_name(&a.pkg))
+ .map(|a| App { icon: crate::icons::existing(data_dir, &a.pkg), pkg: a.pkg, label: a.label })
+ .collect();
+ (!apps.is_empty()).then_some(apps)
+}
+
+fn save_apps(data_dir: &Path, device: &DeviceId, apps: &[App]) {
+ let path = saved_apps_path(data_dir, device);
+ let saved: Vec<SavedApp> =
+ apps.iter().map(|a| SavedApp { pkg: a.pkg.clone(), label: a.label.clone() }).collect();
+ let written = path.parent().map_or(Ok(()), std::fs::create_dir_all).and_then(|()| {
+ let tmp = path.with_extension("json.tmp");
+ std::fs::write(&tmp, serde_json::to_vec(&saved).map_err(std::io::Error::other)?)?;
+ std::fs::rename(&tmp, &path)
+ });
+ if let Err(e) = written {
+ tracing::warn!(error = %e, "can't save a phone's apps");
+ }
+}
+
/// Returns cached `(pkg, label)` pairs for `device` synchronously (0 ms) for
/// the Command Palette, placing recently mirrored apps first and triggering a
/// background app list load if not yet cached.
@@ -1832,8 +1897,8 @@ impl Stats {
#[cfg(test)]
mod tests {
use super::{
- GamepadState, LEFT_THUMB_DEADZONE, RIGHT_THUMB_DEADZONE, TRIGGER_THRESHOLD, merge_recent_apps,
- normalize_gamepad_state, parse_dropped_file_urls,
+ App, GamepadState, LEFT_THUMB_DEADZONE, RIGHT_THUMB_DEADZONE, TRIGGER_THRESHOLD, merge_recent_apps,
+ normalize_gamepad_state, parse_dropped_file_urls, save_apps, saved_apps, saved_apps_path,
};
#[test]
@@ -1905,4 +1970,25 @@ mod tests {
assert_eq!(win.map(|w| w.device), Some(dev));
assert_eq!(paths, vec![file_a]);
}
+
+ #[test]
+ fn a_phones_apps_are_kept_for_the_next_run_with_their_icons() {
+ let dir = tempfile::tempdir().unwrap();
+ let phone = nectarlink_core::DeviceId([0x22; 32]);
+ assert!(saved_apps(dir.path(), &phone).is_none(), "nothing saved yet");
+
+ let png = b"\x89PNG\r\n\x1a\nicon";
+ let icon = crate::icons::save(dir.path(), "org.example.maps", png).unwrap();
+ let apps = vec![
+ App { pkg: "org.example.maps".into(), label: "Maps".into(), icon: Some(icon.clone()) },
+ App { pkg: "org.example.notes".into(), label: "Notes".into(), icon: None },
+ ];
+ save_apps(dir.path(), &phone, &apps);
+ assert_eq!(saved_apps(dir.path(), &phone), Some(apps));
+
+ // Another phone has its own list; a damaged file is no list.
+ assert!(saved_apps(dir.path(), &nectarlink_core::DeviceId([0x33; 32])).is_none());
+ std::fs::write(saved_apps_path(dir.path(), &phone), b"{not json").unwrap();
+ assert!(saved_apps(dir.path(), &phone).is_none());
+ }
}