Error: 'gh pr view' is disabled in your shell. Instead, use your builtin git_view_pr command.

packages/accessibility-android-sys/examples/emulator_raw_capture_probe.rs

@@ -17,7 +17,7 @@ const PROBE_DURATION: Duration = Duration::from_secs(5);
 #[tokio::main]
 async fn main() -> Result<()> {
     let selector = std::env::args().nth(1);
-    let discovery = discover_emulator(selector.as_deref())?;
+    let discovery = discover_emulator(selector.as_deref()).await?;
     let serial = discovery
         .properties
         .get("port.serial")
@@ -34,15 +34,19 @@ async fn main() -> Result<()> {
     let stimulus_serial = serial.clone();
     let stimulus = std::thread::spawn(move || {
         let adb = AdbClient::discover(Some(&stimulus_serial));
-        let Ok((width, height)) = adb.get_screen_size() else {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let Ok((width, height)) = runtime.block_on(adb.get_screen_size()) else {
             return;
         };
         while !stimulus_stop.load(Ordering::Relaxed) {
-            let _ = adb.swipe(
+            let _ = runtime.block_on(adb.swipe(
                 (width as f64 * 0.5, height as f64 * 0.75),
                 (width as f64 * 0.5, height as f64 * 0.25),
                 250,
-            );
+            ));
             std::thread::sleep(Duration::from_millis(150));
         }
     });

packages/accessibility-android-sys/examples/emulator_webrtc_probe.rs

@@ -31,7 +31,7 @@ const RECOVERY_TIMEOUT: Duration = Duration::from_secs(5);
 #[tokio::main]
 async fn main() -> Result<()> {
     let selector = std::env::args().nth(1);
-    let discovery = discover_emulator(selector.as_deref())?;
+    let discovery = discover_emulator(selector.as_deref()).await?;
     println!("discovery : {}", discovery.path.display());
     println!("endpoint  : {}", discovery.endpoint());
 

packages/accessibility-android-sys/examples/screenrecord_probe.rs

@@ -11,26 +11,31 @@ use anyhow::{Context, Result, bail};
 const IDLE_FLUSH: Duration = Duration::from_millis(75);
 const PROBE_DURATION: Duration = Duration::from_secs(5);
 
-fn main() -> Result<()> {
+#[tokio::main]
+async fn main() -> Result<()> {
     let serial = std::env::args()
         .nth(1)
         .unwrap_or_else(|| "emulator-5554".to_string());
     let adb = AdbClient::discover(Some(&serial));
-    adb.check_connection()?;
-    let (width, height) = adb.get_screen_size()?;
+    adb.check_connection().await?;
+    let (width, height) = adb.get_screen_size().await?;
     let config = ScreenRecordConfig::for_max_dimension(width, height, Some(1280), 5_000_000);
     println!("device    : {serial}");
     println!("source    : {width}x{height}");
     println!("encoded   : {}x{}", config.width, config.height);
 
     let stimulus = adb.clone();
     std::thread::spawn(move || {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
         std::thread::sleep(Duration::from_secs(1));
-        let _ = stimulus.swipe(
+        let _ = runtime.block_on(stimulus.swipe(
             (width as f64 * 0.5, height as f64 * 0.75),
             (width as f64 * 0.5, height as f64 * 0.25),
             800,
-        );
+        ));
     });
 
     let started = Instant::now();

packages/accessibility-android-sys/src/emulator.rs

@@ -11,6 +11,8 @@ pub mod raw;
 pub mod screenrecord;
 
 pub mod protocol {
+    #![allow(clippy::result_large_err)]
+
     pub mod controller {
         tonic::include_proto!("android.emulation.control");
     }
@@ -38,9 +40,9 @@ pub struct EmulatorDiscovery {
 }
 
 impl EmulatorDiscovery {
-    pub fn from_file(path: impl AsRef<Path>) -> Result<Self> {
+    pub async fn from_file(path: impl AsRef<Path>) -> Result<Self> {
         let path = path.as_ref();
-        let contents = std::fs::read_to_string(path).with_context(|| {
+        let contents = tokio::fs::read_to_string(path).await.with_context(|| {
             format!("failed to read emulator discovery file {}", path.display())
         })?;
         let properties = parse_properties(&contents);
@@ -246,17 +248,17 @@ impl EmulatorGrpcClient {
     }
 }
 
-pub fn discover_emulator(selector: Option<&str>) -> Result<EmulatorDiscovery> {
-    discover_emulator_in(&discovery_directories(), selector)
+pub async fn discover_emulator(selector: Option<&str>) -> Result<EmulatorDiscovery> {
+    discover_emulator_in(&discovery_directories(), selector).await
 }
 
-pub fn discover_emulator_in(
+pub async fn discover_emulator_in(
     directories: &[PathBuf],
     selector: Option<&str>,
 ) -> Result<EmulatorDiscovery> {
     let mut paths = BTreeSet::new();
     for directory in directories {
-        let entries = match std::fs::read_dir(directory) {
+        let mut entries = match tokio::fs::read_dir(directory).await {
             Ok(entries) => entries,
             Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
             Err(error) => {
@@ -268,8 +270,8 @@ pub fn discover_emulator_in(
                 });
             }
         };
-        for entry in entries {
-            let path = entry?.path();
+        while let Some(entry) = entries.next_entry().await? {
+            let path = entry.path();
             let Some(name) = path.file_name().and_then(|name| name.to_str()) else {
                 continue;
             };
@@ -279,10 +281,12 @@ pub fn discover_emulator_in(
         }
     }
 
-    let mut discoveries = paths
-        .into_iter()
-        .filter_map(|path| EmulatorDiscovery::from_file(path).ok())
-        .collect::<Vec<_>>();
+    let mut discoveries = Vec::new();
+    for path in paths {
+        if let Ok(discovery) = EmulatorDiscovery::from_file(path).await {
+            discoveries.push(discovery);
+        }
+    }
     if let Some(selector) = selector {
         discoveries.retain(|discovery| discovery.matches(selector));
     }
@@ -351,17 +355,17 @@ mod tests {
         path
     }
 
-    #[test]
+    #[tokio::test]
     #[cfg_attr(miri, ignore)]
-    fn parses_discovery_file() {
+    async fn parses_discovery_file() {
         let directory = test_directory("parse");
         let path = directory.join("pid_1234.ini");
         std::fs::write(
             &path,
             "grpc.port = 8554\ngrpc.token = secret\navd.name = Pixel_8\nport.serial = 5554\n",
         )
         .unwrap();
-        let discovery = EmulatorDiscovery::from_file(&path).unwrap();
+        let discovery = EmulatorDiscovery::from_file(&path).await.unwrap();
         assert_eq!(discovery.pid, Some(1234));
         assert_eq!(discovery.grpc_port, 8554);
         assert_eq!(discovery.grpc_token.as_deref(), Some("secret"));
@@ -370,9 +374,9 @@ mod tests {
         std::fs::remove_dir_all(directory).unwrap();
     }
 
-    #[test]
+    #[tokio::test]
     #[cfg_attr(miri, ignore)]
-    fn selects_one_emulator() {
+    async fn selects_one_emulator() {
         let directory = test_directory("select");
         std::fs::write(
             directory.join("pid_1.ini"),
@@ -384,10 +388,15 @@ mod tests {
             "grpc.port=8555\navd.name=tablet\n",
         )
         .unwrap();
-        let discovery =
-            discover_emulator_in(std::slice::from_ref(&directory), Some("tablet")).unwrap();
+        let discovery = discover_emulator_in(std::slice::from_ref(&directory), Some("tablet"))
+            .await
+            .unwrap();
         assert_eq!(discovery.grpc_port, 8555);
-        assert!(discover_emulator_in(std::slice::from_ref(&directory), None).is_err());
+        assert!(
+            discover_emulator_in(std::slice::from_ref(&directory), None)
+                .await
+                .is_err()
+        );
         std::fs::remove_dir_all(directory).unwrap();
     }
 }

packages/accessibility-android-sys/src/emulator/raw.rs

@@ -48,7 +48,7 @@ impl RawFrameStream {
         if config.width == 0 || config.height == 0 {
             bail!("raw Android capture requires non-zero dimensions");
         }
-        let discovery = discover_emulator(selector)?;
+        let discovery = discover_emulator(selector).await?;
         Self::start_with_discovery(discovery, config).await
     }