feat: make search_adb_devices and is_adb_device public

Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://github.com/cocool97/adb_client"
 keywords = ["adb", "android", "tcp", "usb"]
 license = "MIT"
 repository = "https://github.com/cocool97/adb_client"
-version = "2.1.13"
+version = "2.1.14"
 
 # To build locally when working on a new release
 [patch.crates-io]

adb_client/Cargo.toml

@@ -14,7 +14,7 @@ base64 = { version = "0.22.1" }
 bincode = { version = "1.3.3" }
 byteorder = { version = "1.5.0" }
 chrono = { version = "0.4.40", default-features = false, features = ["std"] }
-homedir = { version = "0.3.4" }
+homedir = { version = "= 0.3.4" }
 image = { version = "0.25.5", default-features = false }
 log = { version = "0.4.26" }
 mdns-sd = { version = "0.13.9", default-features = false, features = [

adb_client/src/device/adb_message_device.rs

@@ -11,18 +11,18 @@ use super::{ADBTransportMessage, MessageCommand, models::MessageSubcommand};
 #[derive(Debug)]
 pub struct ADBMessageDevice<T: ADBMessageTransport> {
     transport: T,
-}
+    local_id: Option<u32>,
-
+    remote_id: Option<u32>,
-#[derive(Debug, Clone, Copy)]
-pub struct ADBSession {
-    pub local_id: u32,
-    pub remote_id: u32,
 }
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     /// Instantiate a new [`ADBMessageTransport`]
     pub fn new(transport: T) -> Self {
-        Self { transport }
+        Self {
+            transport,
+            local_id: None,
+            remote_id: None,
+        }
     }
 
     pub(crate) fn get_transport(&mut self) -> &T {
@@ -34,15 +34,12 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     }
 
     /// Receive a message and acknowledge it by replying with an `OKAY` command
-    pub(crate) fn recv_and_reply_okay(
+    pub(crate) fn recv_and_reply_okay(&mut self) -> Result<ADBTransportMessage> {
-        &mut self,
-        session: ADBSession,
-    ) -> Result<ADBTransportMessage> {
         let message = self.transport.read_message()?;
         self.transport.write_message(ADBTransportMessage::new(
             MessageCommand::Okay,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             &[],
         ))?;
         Ok(message)
@@ -63,12 +60,11 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
     pub(crate) fn recv_file<W: std::io::Write>(
         &mut self,
-        session: ADBSession,
         mut output: W,
     ) -> std::result::Result<(), RustADBError> {
         let mut len: Option<u64> = None;
         loop {
-            let payload = self.recv_and_reply_okay(session)?.into_payload();
+            let payload = self.recv_and_reply_okay()?.into_payload();
             let mut rdr = Cursor::new(&payload);
             while rdr.position() != payload.len() as u64 {
                 match len.take() {
@@ -101,7 +97,8 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
     pub(crate) fn push_file<R: std::io::Read>(
         &mut self,
-        session: ADBSession,
+        local_id: u32,
+        remote_id: u32,
         mut reader: R,
     ) -> std::result::Result<(), RustADBError> {
         let mut buffer = [0; BUFFER_SIZE];
@@ -114,8 +111,8 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         let message = ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            local_id,
-            session.remote_id,
+            remote_id,
             &serialized_message,
         );
 
@@ -134,8 +131,8 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
                     let message = ADBTransportMessage::new(
                         MessageCommand::Write,
-                        session.local_id,
+                        local_id,
-                        session.remote_id,
+                        remote_id,
                         &serialized_message,
                     );
 
@@ -162,8 +159,8 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
                     let message = ADBTransportMessage::new(
                         MessageCommand::Write,
-                        session.local_id,
+                        local_id,
-                        session.remote_id,
+                        remote_id,
                         &serialized_message,
                     );
 
@@ -176,27 +173,24 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
         }
     }
 
-    pub(crate) fn begin_synchronization(&mut self) -> Result<ADBSession> {
+    pub(crate) fn begin_synchronization(&mut self) -> Result<()> {
-        self.open_session(b"sync:\0")
+        self.open_session(b"sync:\0")?;
+        Ok(())
     }
 
-    pub(crate) fn stat_with_explicit_ids(
+    pub(crate) fn stat_with_explicit_ids(&mut self, remote_path: &str) -> Result<AdbStatResponse> {
-        &mut self,
-        session: ADBSession,
-        remote_path: &str,
-    ) -> Result<AdbStatResponse> {
         let stat_buffer = MessageSubcommand::Stat.with_arg(remote_path.len() as u32);
         let message = ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             &bincode::serialize(&stat_buffer).map_err(|_e| RustADBError::ConversionError)?,
         );
         self.send_and_expect_okay(message)?;
         self.send_and_expect_okay(ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             remote_path.as_bytes(),
         ))?;
         let response = self.transport.read_message()?;
@@ -206,25 +200,24 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
             .map_err(|_e| RustADBError::ConversionError)
     }
 
-    pub(crate) fn end_transaction(&mut self, session: ADBSession) -> Result<()> {
+    pub(crate) fn end_transaction(&mut self) -> Result<()> {
         let quit_buffer = MessageSubcommand::Quit.with_arg(0u32);
         self.send_and_expect_okay(ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             &bincode::serialize(&quit_buffer).map_err(|_e| RustADBError::ConversionError)?,
         ))?;
         let _discard_close = self.transport.read_message()?;
         Ok(())
     }
 
-    pub(crate) fn open_session(&mut self, data: &[u8]) -> Result<ADBSession> {
+    pub(crate) fn open_session(&mut self, data: &[u8]) -> Result<ADBTransportMessage> {
         let mut rng = rand::rng();
-        let local_id: u32 = rng.random();
 
         let message = ADBTransportMessage::new(
             MessageCommand::Open,
-            local_id, // Our 'local-id'
+            rng.random(), // Our 'local-id'
             0,
             data,
         );
@@ -232,25 +225,21 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         let response = self.get_transport_mut().read_message()?;
 
-        if response.header().command() != MessageCommand::Okay {
+        self.local_id = Some(response.header().arg1());
-            return Err(RustADBError::ADBRequestFailed(format!(
+        self.remote_id = Some(response.header().arg0());
-                "Open session failed: got {} in respone instead of OKAY",
-                response.header().command()
-            )));
-        }
 
-        if response.header().arg1() != local_id {
+        Ok(response)
-            return Err(RustADBError::ADBRequestFailed(format!(
+    }
-                "Open session failed: respones used {} for our local_id instead of {local_id}",
-                response.header().arg1()
-            )));
-        }
 
-        let session = ADBSession {
+    pub(crate) fn get_local_id(&self) -> Result<u32> {
-            local_id,
+        self.local_id.ok_or(RustADBError::ADBRequestFailed(
-            remote_id: response.header().arg0(),
+            "connection not opened, no local_id".into(),
-        };
+        ))
+    }
 
-        Ok(session)
+    pub(crate) fn get_remote_id(&self) -> Result<u32> {
+        self.remote_id.ok_or(RustADBError::ADBRequestFailed(
+            "connection not opened, no remote_id".into(),
+        ))
     }
 }

adb_client/src/device/adb_usb_device.rs

@@ -31,7 +31,7 @@ pub fn read_adb_private_key<P: AsRef<Path>>(private_key_path: P) -> Result<Optio
 }
 
 /// Search for adb devices with known interface class and subclass values
-fn search_adb_devices() -> Result<Option<(u16, u16)>> {
+pub fn search_adb_devices() -> Result<Option<(u16, u16)>> {
     let mut found_devices = vec![];
     for device in rusb::devices()?.iter() {
         let Ok(des) = device.device_descriptor() else {
@@ -57,7 +57,8 @@ fn search_adb_devices() -> Result<Option<(u16, u16)>> {
     }
 }
 
-fn is_adb_device<T: UsbContext>(device: &Device<T>, des: &DeviceDescriptor) -> bool {
+/// Check whether a device with given descriptor is an ADB device
+pub fn is_adb_device<T: UsbContext>(device: &Device<T>, des: &DeviceDescriptor) -> bool {
     const ADB_SUBCLASS: u8 = 0x42;
     const ADB_PROTOCOL: u8 = 0x1;
 
@@ -180,6 +181,11 @@ impl ADBUSBDevice {
         self.get_transport_mut().write_message(message)?;
 
         let message = self.get_transport_mut().read_message()?;
+        // If the device returned CNXN instead of AUTH it does not require authentication,
+        // so we can skip the auth steps.
+        if message.header().command() == MessageCommand::Cnxn {
+            return Ok(());
+        }
         message.assert_command(MessageCommand::Auth)?;
 
         // At this point, we should have receive an AUTH message with arg0 == 1

adb_client/src/device/commands/framebuffer.rs

@@ -11,9 +11,9 @@ use crate::{
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn framebuffer_inner(&mut self) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>> {
-        let session = self.open_session(b"framebuffer:\0")?;
+        self.open_session(b"framebuffer:\0")?;
 
-        let response = self.recv_and_reply_okay(session)?;
+        let response = self.recv_and_reply_okay()?;
 
         let mut payload_cursor = Cursor::new(response.payload());
 
@@ -36,7 +36,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
                         break;
                     }
 
-                    let response = self.recv_and_reply_okay(session)?;
+                    let response = self.recv_and_reply_okay()?;
 
                     framebuffer_data.extend_from_slice(&response.into_payload());
 
@@ -69,7 +69,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
                         break;
                     }
 
-                    let response = self.recv_and_reply_okay(session)?;
+                    let response = self.recv_and_reply_okay()?;
 
                     framebuffer_data.extend_from_slice(&response.into_payload());
 

adb_client/src/device/commands/install.rs

@@ -14,12 +14,11 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         let file_size = apk_file.metadata()?.len();
 
-        let session =
+        self.open_session(format!("exec:cmd package 'install' -S {}\0", file_size).as_bytes())?;
-            self.open_session(format!("exec:cmd package 'install' -S {}\0", file_size).as_bytes())?;
 
         let transport = self.get_transport().clone();
 
-        let mut writer = MessageWriter::new(transport, session.local_id, session.remote_id);
+        let mut writer = MessageWriter::new(transport, self.get_local_id()?, self.get_remote_id()?);
 
         std::io::copy(&mut apk_file, &mut writer)?;
 

adb_client/src/device/commands/pull.rs

@@ -10,10 +10,10 @@ use crate::{
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn pull<A: AsRef<str>, W: Write>(&mut self, source: A, output: W) -> Result<()> {
-        let session = self.begin_synchronization()?;
+        self.begin_synchronization()?;
         let source = source.as_ref();
 
-        let adb_stat_response = self.stat_with_explicit_ids(session, source)?;
+        let adb_stat_response = self.stat_with_explicit_ids(source)?;
 
         if adb_stat_response.file_perm == 0 {
             return Err(RustADBError::UnknownResponseType(
@@ -21,13 +21,11 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
             ));
         }
 
+        let local_id = self.get_local_id()?;
+        let remote_id = self.get_remote_id()?;
+
         self.get_transport_mut().write_message_with_timeout(
-            ADBTransportMessage::new(
+            ADBTransportMessage::new(MessageCommand::Okay, local_id, remote_id, &[]),
-                MessageCommand::Okay,
-                session.local_id,
-                session.remote_id,
-                &[],
-            ),
             std::time::Duration::from_secs(4),
         )?;
 
@@ -36,19 +34,19 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
             bincode::serialize(&recv_buffer).map_err(|_e| RustADBError::ConversionError)?;
         self.send_and_expect_okay(ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             &recv_buffer,
         ))?;
         self.send_and_expect_okay(ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             source.as_bytes(),
         ))?;
 
-        self.recv_file(session, output)?;
+        self.recv_file(output)?;
-        self.end_transaction(session)?;
+        self.end_transaction()?;
         Ok(())
     }
 }

adb_client/src/device/commands/push.rs

@@ -10,7 +10,7 @@ use crate::{
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn push<R: Read, A: AsRef<str>>(&mut self, stream: R, path: A) -> Result<()> {
-        let session = self.begin_synchronization()?;
+        self.begin_synchronization()?;
 
         let path_header = format!("{},0777", path.as_ref());
 
@@ -21,13 +21,14 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         self.send_and_expect_okay(ADBTransportMessage::new(
             MessageCommand::Write,
-            session.local_id,
+            self.get_local_id()?,
-            session.remote_id,
+            self.get_remote_id()?,
             &send_buffer,
         ))?;
 
-        self.push_file(session, stream)?;
+        self.push_file(self.get_local_id()?, self.get_remote_id()?, stream)?;
-        self.end_transaction(session)?;
+
+        self.end_transaction()?;
 
         Ok(())
     }

adb_client/src/device/commands/shell.rs

@@ -10,7 +10,14 @@ use crate::{
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     /// Runs 'command' in a shell on the device, and write its output and error streams into output.
     pub(crate) fn shell_command(&mut self, command: &[&str], output: &mut dyn Write) -> Result<()> {
-        let session = self.open_session(format!("shell:{}\0", command.join(" "),).as_bytes())?;
+        let response = self.open_session(format!("shell:{}\0", command.join(" "),).as_bytes())?;
+
+        if response.header().command() != MessageCommand::Okay {
+            return Err(RustADBError::ADBRequestFailed(format!(
+                "wrong command {}",
+                response.header().command()
+            )));
+        }
 
         loop {
             let response = self.get_transport_mut().read_message()?;
@@ -31,22 +38,21 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
         mut reader: &mut dyn Read,
         mut writer: Box<(dyn Write + Send)>,
     ) -> Result<()> {
-        let session = self.open_session(b"shell:\0")?;
+        self.open_session(b"shell:\0")?;
 
         let mut transport = self.get_transport().clone();
 
+        let local_id = self.get_local_id()?;
+        let remote_id = self.get_remote_id()?;
+
         // Reading thread, reads response from adbd
         std::thread::spawn(move || -> Result<()> {
             loop {
                 let message = transport.read_message()?;
 
                 // Acknowledge for more data
-                let response = ADBTransportMessage::new(
+                let response =
-                    MessageCommand::Okay,
+                    ADBTransportMessage::new(MessageCommand::Okay, local_id, remote_id, &[]);
-                    session.local_id,
-                    session.remote_id,
-                    &[],
-                );
                 transport.write_message(response)?;
 
                 match message.header().command() {
@@ -61,8 +67,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
         });
 
         let transport = self.get_transport().clone();
-        let mut shell_writer =
+        let mut shell_writer = ShellMessageWriter::new(transport, local_id, remote_id);
-            ShellMessageWriter::new(transport, session.local_id, session.remote_id);
 
         // Read from given reader (that could be stdin e.g), and write content to device adbd
         if let Err(e) = std::io::copy(&mut reader, &mut shell_writer) {

adb_client/src/device/commands/stat.rs

@@ -4,9 +4,9 @@ use crate::{
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn stat(&mut self, remote_path: &str) -> Result<AdbStatResponse> {
-        let session = self.begin_synchronization()?;
+        self.begin_synchronization()?;
-        let adb_stat_response = self.stat_with_explicit_ids(session, remote_path)?;
+        let adb_stat_response = self.stat_with_explicit_ids(remote_path)?;
-        self.end_transaction(session)?;
+        self.end_transaction()?;
         Ok(adb_stat_response)
     }
 }

adb_client/src/device/message_writer.rs

@@ -35,10 +35,10 @@ impl<T: ADBMessageTransport> Write for MessageWriter<T> {
             Ok(response) => {
                 response
                     .assert_command(MessageCommand::Okay)
-                    .map_err(|e| Error::new(ErrorKind::Other, e))?;
+                    .map_err(Error::other)?;
                 Ok(buf.len())
             }
-            Err(e) => Err(Error::new(ErrorKind::Other, e)),
+            Err(e) => Err(Error::other(e)),
         }
     }
 

adb_client/src/device/mod.rs

@@ -11,7 +11,9 @@ mod shell_message_writer;
 use adb_message_device::ADBMessageDevice;
 pub use adb_tcp_device::ADBTcpDevice;
 pub use adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader};
-pub use adb_usb_device::{ADBUSBDevice, get_default_adb_key_path};
+pub use adb_usb_device::{
+    ADBUSBDevice, get_default_adb_key_path, is_adb_device, search_adb_devices,
+};
 pub use message_writer::MessageWriter;
 pub use models::{ADBRsaKey, MessageCommand, MessageSubcommand};
 pub use shell_message_writer::ShellMessageWriter;

adb_client/src/lib.rs

@@ -17,7 +17,7 @@ mod transports;
 mod utils;
 
 pub use adb_device_ext::ADBDeviceExt;
-pub use device::{ADBTcpDevice, ADBUSBDevice};
+pub use device::{ADBTcpDevice, ADBUSBDevice, is_adb_device, search_adb_devices};
 pub use emulator_device::ADBEmulatorDevice;
 pub use error::{Result, RustADBError};
 pub use mdns::*;

adb_client/src/server_device/commands/recv.rs

@@ -42,18 +42,15 @@ impl<R: Read> Read for ADBRecvCommandReader<R> {
                     let mut error_msg = vec![0; length];
                     self.inner.read_exact(&mut error_msg)?;
 
-                    Err(std::io::Error::new(
+                    Err(std::io::Error::other(format!(
-                        std::io::ErrorKind::Other,
+                        "ADB request failed: {}",
-                        format!(
+                        String::from_utf8_lossy(&error_msg)
-                            "ADB request failed: {}",
+                    )))
-                            String::from_utf8_lossy(&error_msg)
-                        ),
-                    ))
                 }
-                _ => Err(std::io::Error::new(
+                _ => Err(std::io::Error::other(format!(
-                    std::io::ErrorKind::Other,
+                    "Unknown response from device {:#?}",
-                    format!("Unknown response from device {:#?}", header),
+                    header
-                )),
+                ))),
             }
         } else {
             // Computing minimum to ensure to stop reading before next header...