fix(dashboard): 🐛 Fix SteamVR fail to launch for dangling ADB process

Author: zmerp

alvr/adb/src/commands.rs

@@ -1,12 +1,11 @@
 // https://android.googlesource.com/platform/packages/modules/adb/+/refs/heads/main/docs/user/adb.1.md
 
 use crate::parse::{self, Device, ForwardedPorts};
-use alvr_filesystem::Layout;
+use alvr_filesystem as afs;
 use anyhow::{anyhow, Context, Result};
 use std::{
     collections::HashSet,
     io::{Cursor, Read},
-    path::PathBuf,
     process::Command,
     time::Duration,
 };
@@ -137,7 +136,7 @@ pub fn is_activity_resumed(
 // ADB Installation
 
 pub fn require_adb(
-    layout: &Layout,
+    layout: &afs::Layout,
     progress_callback: impl Fn(usize, Option<usize>),
 ) -> Result<String> {
     match get_adb_path(layout) {
@@ -150,11 +149,12 @@ pub fn require_adb(
     }
 }
 
-fn install_adb(layout: &Layout, progress_callback: impl Fn(usize, Option<usize>)) -> Result<()> {
-    let buffer = download_adb(progress_callback)?;
-    let mut reader = Cursor::new(buffer);
-    let path = get_installation_path(layout);
-    ZipArchive::new(&mut reader)?.extract(path)?;
+fn install_adb(
+    layout: &afs::Layout,
+    progress_callback: impl Fn(usize, Option<usize>),
+) -> Result<()> {
+    let mut reader = Cursor::new(download_adb(progress_callback)?);
+    ZipArchive::new(&mut reader)?.extract(layout.executables_dir.clone())?;
 
     Ok(())
 }
@@ -261,36 +261,24 @@ pub fn list_installed_packages(adb_path: &str, device_serial: &str) -> Result<Ha
 // Paths
 
 /// Returns the path of a local (i.e. installed by ALVR) or OS version of `adb` if found, `None` otherwise.
-fn get_adb_path(layout: &Layout) -> Option<String> {
+fn get_adb_path(layout: &afs::Layout) -> Option<String> {
     get_os_adb_path().or(get_local_adb_path(layout))
 }
 
 fn get_os_adb_path() -> Option<String> {
-    let name = get_executable_name().to_owned();
+    let name = afs::exec_fname("adb").to_owned();
 
     get_command(&name, &[]).output().is_ok().then_some(name)
 }
 
-fn get_local_adb_path(layout: &Layout) -> Option<String> {
-    let path = get_platform_tools_path(layout).join(get_executable_name());
+fn get_local_adb_path(layout: &afs::Layout) -> Option<String> {
+    let path = layout.local_adb_exe();
 
     path.try_exists()
-        .is_ok_and(|e| e)
+        .unwrap_or(false)
         .then(|| path.to_string_lossy().to_string())
 }
 
-fn get_installation_path(layout: &Layout) -> PathBuf {
-    layout.executables_dir.to_owned()
-}
-
-fn get_platform_tools_path(layout: &Layout) -> PathBuf {
-    get_installation_path(layout).join("platform-tools")
-}
-
-fn get_executable_name() -> String {
-    alvr_filesystem::exec_fname("adb")
-}
-
 //////////////////
 // Port forwarding
 

alvr/dashboard/src/data_sources.rs

@@ -4,7 +4,6 @@ use alvr_packets::ServerRequest;
 use alvr_server_io::ServerSessionManager;
 use eframe::egui;
 use std::{
-    env,
     io::ErrorKind,
     net::{SocketAddr, TcpStream},
     str::FromStr,
@@ -25,9 +24,7 @@ enum SessionSource {
 }
 
 pub fn get_local_session_source() -> ServerSessionManager {
-    let session_file_path =
-        alvr_filesystem::filesystem_layout_from_dashboard_exe(&env::current_exe().unwrap())
-            .session();
+    let session_file_path = crate::get_filesystem_layout().session();
 
     ServerSessionManager::new(Some(session_file_path))
 }
@@ -150,10 +147,7 @@ impl DataSources {
                                 }
                                 ServerRequest::RegisterAlvrDriver => {
                                     let alvr_driver_dir =
-                                        alvr_filesystem::filesystem_layout_from_dashboard_exe(
-                                            &env::current_exe().unwrap(),
-                                        )
-                                        .openvr_driver_root_dir;
+                                        crate::get_filesystem_layout().openvr_driver_root_dir;
 
                                     alvr_server_io::driver_registration(&[alvr_driver_dir], true)
                                         .ok();

alvr/dashboard/src/main.rs

@@ -17,8 +17,13 @@ use data_sources::DataSources;
 #[cfg(target_arch = "wasm32")]
 use data_sources_wasm::DataSources;
 
+use alvr_filesystem as afs;
 use dashboard::Dashboard;
 
+fn get_filesystem_layout() -> afs::Layout {
+    afs::filesystem_layout_from_dashboard_exe(&std::env::current_exe().unwrap())
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use alvr_common::ALVR_VERSION;

alvr/dashboard/src/steamvr_launcher/mod.rs

@@ -115,6 +115,18 @@ pub struct Launcher {
 
 impl Launcher {
     pub fn launch_steamvr(&self) {
+        // The ADB server might be left running because of a unclean termination of SteamVR
+        let local_adb_path = crate::get_filesystem_layout().local_adb_exe();
+        for proc in
+            sysinfo::System::new_all().processes_by_name(OsStr::new(&afs::exec_fname("adb")))
+        {
+            if let Some(proc_path) = proc.exe() {
+                if proc_path == local_adb_path {
+                    proc.kill();
+                }
+            }
+        }
+
         #[cfg(target_os = "linux")]
         linux_steamvr::linux_hardware_checks();
 

alvr/filesystem/src/lib.rs

@@ -199,6 +199,14 @@ impl Layout {
         self.executables_dir.join(dashboard_fname())
     }
 
+    pub fn local_adb_dir(&self) -> PathBuf {
+        self.executables_dir.join("platform-tools")
+    }
+
+    pub fn local_adb_exe(&self) -> PathBuf {
+        self.local_adb_dir().join(exec_fname("adb"))
+    }
+
     pub fn resources_dir(&self) -> PathBuf {
         self.openvr_driver_root_dir.join("resources")
     }