chore: v2.1.17

* feat: add fastboot reboot type

* feat: add fastboot command to cli

---------

Co-authored-by: LIAUD Corentin <corentinliaud26@gmail.com>

.github/workflows/python-build.yml

@@ -1,49 +1,36 @@
 name: Python - Build packages & Release
 
 on:
-  push: {}
-  pull_request: {}
+  push:
+    branches:
+      - main
+  pull_request:
   release:
     types: [created]
 
 jobs:
-  gen-stubs:
-    name: "build-release"
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Build project
-      run: cargo run --bin stub_gen
-
   build-python-packages:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v4
 
+      - name: Build Python stubs
+        run: cargo run --bin stub_gen
+
       - name: Install Python build dependencies
         run: pip install maturin==1.8.2
 
       - name: Build Python packages
-        run: maturin build --release -m pyadb_client/Cargo.toml --compatibility manylinux_2_25 --auditwheel=skip
-
-  publish-python-packages:
-    runs-on: ubuntu-latest
-    needs: [build-python-packages]
-    if: github.event_name == 'release' && github.event.action == 'created'
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Python build dependencies
-        run: pip install maturin==1.8.2
+        run: maturin build --sdist --release -m pyadb_client/Cargo.toml
 
       - name: Publish Python packages
-        run: maturin publish -m pyadb_client/Cargo.toml --non-interactive --compatibility manylinux_2_25 --auditwheel=skip
+        if: github.event_name == 'release' && github.event.action == 'created'
+        run: maturin publish -m pyadb_client/Cargo.toml --non-interactive
         env:
           MATURIN_PYPI_TOKEN: ${{ secrets.MATURIN_PYPI_TOKEN }}
 
       - name: "Publish GitHub artefacts"
+        if: github.event_name == 'release' && github.event.action == 'created'
         uses: softprops/action-gh-release@v2
         with:
           files: |

.github/workflows/rust-build.yml

@@ -1,14 +1,22 @@
 name: Rust - Build
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build-release:
-    name: "build-release"
-    runs-on: ubuntu-latest
+  build:
+    name: "Build on ${{ matrix.os }}"
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
     steps:
     - uses: actions/checkout@v4
     - name: Build project

.github/workflows/rust-quality.yml

@@ -1,6 +1,10 @@
 name: Rust - Quality
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
 
 env:
   CARGO_TERM_COLOR: always

.github/workflows/rust-release.yml

@@ -4,46 +4,101 @@ on:
   release:
     types: [created]
 
+env:
+  CARGO_TERM_COLOR: always
+
 jobs:
-  create-release:
+  release-linux:
+    name: Linux - Build and Publish
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
-      - name: "Set up Rust"
+      - name: Set up Rust
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
           override: true
 
-      - name: "Install dependencies"
+      - name: Install dependencies
         run: |
           sudo apt update
           sudo apt install -y rpm
           cargo install cargo-deb
           cargo install cargo-generate-rpm
 
-      - name: "Publish crates"
+      - name: Publish crates
         run: |
           cargo publish -p adb_client --token ${CRATES_IO_TOKEN}
           cargo publish -p adb_cli --token ${CRATES_IO_TOKEN}
         env:
           CRATES_IO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
 
-      - name: "build-release"
+      - name: Build release
         run: cargo build --all-features --release
 
-      - name: "Build DEB package"
+      - name: Rename binary
+        run: mv target/release/adb_cli target/release/adb_cli-linux
+
+      - name: Build DEB package
         run: cargo deb -p adb_cli
 
-      - name: "Build RPM package"
+      - name: Build RPM package
         run: cargo generate-rpm -p adb_cli
 
-      - name: "Publish GitHub artefacts"
+      - name: Upload Linux artifacts
         uses: softprops/action-gh-release@v2
         with:
           files: |
             target/debian/*.deb
             target/generate-rpm/*.rpm
-            target/release/adb_cli
+            target/release/adb_cli-linux
+
+  release-macos:
+    name: macOS - Build Binary
+    runs-on: macos-13
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Build release
+        run: cargo build --all-features --release
+
+      - name: Rename binary
+        run: mv target/release/adb_cli target/release/adb_cli-macos
+
+      - name: Upload macOS binary
+        uses: softprops/action-gh-release@v2
+        with:
+          files: target/release/adb_cli-macos
+
+  release-windows:
+    name: Windows - Build Binary
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Build release
+        run: cargo build --all-features --release
+
+      - name: Rename binary
+        run: Rename-Item -Path target/release/adb_cli.exe -NewName adb_cli-windows.exe
+
+      - name: Upload Windows binary
+        uses: softprops/action-gh-release@v2
+        with:
+          files: target/release/adb_cli-windows.exe

Cargo.toml

@@ -4,12 +4,13 @@ resolver = "2"
 
 [workspace.package]
 authors = ["Corentin LIAUD"]
-edition = "2021"
+edition = "2024"
 homepage = "https://github.com/cocool97/adb_client"
 keywords = ["adb", "android", "tcp", "usb"]
 license = "MIT"
 repository = "https://github.com/cocool97/adb_client"
-version = "2.1.6"
+version = "2.1.17"
+rust-version = "1.85.1"
 
 # To build locally when working on a new release
 [patch.crates-io]

README.md

@@ -8,6 +8,9 @@
         <a href="https://crates.io/crates/adb_client">
             <img alt="crates.io" src="https://img.shields.io/crates/v/adb_client.svg"/>
         </a>
+        <a href="https://crates.io/crates/adb_client">
+            <img alt="msrv" src="https://img.shields.io/crates/msrv/adb_client"/>
+        </a>
         <a href="https://github.com/cocool97/adb_client/actions">
             <img alt="ci status" src="https://github.com/cocool97/adb_client/actions/workflows/rust-build.yml/badge.svg"/>
         </a>

adb_cli/Cargo.toml

@@ -7,6 +7,7 @@ license.workspace = true
 name = "adb_cli"
 readme = "README.md"
 repository.workspace = true
+rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
@@ -14,7 +15,7 @@ adb_client = { version = "^2.0.0" }
 anyhow = { version = "1.0.94" }
 clap = { version = "4.5.23", features = ["derive"] }
 env_logger = { version = "0.11.5" }
-log = { version = "0.4.22" }
+log = { version = "0.4.26" }
 
 [target.'cfg(unix)'.dependencies]
 termios = { version = "0.3.3" }

adb_cli/README.md

@@ -2,6 +2,7 @@
 
 [![MIT licensed](https://img.shields.io/crates/l/adb_cli.svg)](./LICENSE-MIT)
 ![Crates.io Total Downloads](https://img.shields.io/crates/d/adb_cli)
+![MSRV](https://img.shields.io/crates/msrv/adb_cli)
 
 Rust binary providing an improved version of `adb` CLI.
 
@@ -10,7 +11,7 @@ Rust binary providing an improved version of `adb` CLI.
 This crate provides a lightweight binary based on the `adb_client` crate. You can install it by running the following command :
 
 ```shell
-cargo install adb_cli 
+cargo install adb_cli
 ```
 
 Usage is quite simple, and tends to look like `adb`:
@@ -64,4 +65,4 @@ Options:
   -p, --product-id <PID>                   Hexadecimal product id of this USB device
   -k, --private-key <PATH_TO_PRIVATE_KEY>  Path to a custom private key to use for authentication
   -h, --help                               Print help
-```
+```

adb_cli/src/adb_termios.rs

@@ -2,7 +2,7 @@
 
 use std::os::unix::prelude::{AsRawFd, RawFd};
 
-use termios::{tcsetattr, Termios, TCSANOW, VMIN, VTIME};
+use termios::{TCSANOW, Termios, VMIN, VTIME, tcsetattr};
 
 use crate::Result;
 

adb_cli/src/handlers/host_commands.rs

@@ -1,4 +1,4 @@
-use adb_client::{ADBServer, DeviceShort, MDNSBackend, Result};
+use adb_client::{ADBServer, DeviceShort, MDNSBackend, Result, WaitForDeviceState};
 
 use crate::models::{HostCommand, MdnsCommand, ServerCommand};
 
@@ -8,7 +8,7 @@ pub fn handle_host_commands(server_command: ServerCommand<HostCommand>) -> Resul
     match server_command.command {
         HostCommand::Version => {
             let version = adb_server.version()?;
-            log::info!("Android Debug Bridge version {}", version);
+            log::info!("Android Debug Bridge version {version}");
             log::info!("Package version {}-rust", std::env!("CARGO_PKG_VERSION"));
         }
         HostCommand::Kill => {
@@ -18,18 +18,18 @@ pub fn handle_host_commands(server_command: ServerCommand<HostCommand>) -> Resul
             if long {
                 log::info!("List of devices attached (extended)");
                 for device in adb_server.devices_long()? {
-                    log::info!("{}", device);
+                    log::info!("{device}");
                 }
             } else {
                 log::info!("List of devices attached");
                 for device in adb_server.devices()? {
-                    log::info!("{}", device);
+                    log::info!("{device}");
                 }
             }
         }
         HostCommand::TrackDevices => {
             let callback = |device: DeviceShort| {
-                log::info!("{}", device);
+                log::info!("{device}");
                 Ok(())
             };
             log::info!("Live list of devices attached");
@@ -65,13 +65,17 @@ pub fn handle_host_commands(server_command: ServerCommand<HostCommand>) -> Resul
             MdnsCommand::Services => {
                 log::info!("List of discovered mdns services");
                 for service in adb_server.mdns_services()? {
-                    log::info!("{}", service);
+                    log::info!("{service}");
                 }
             }
         },
         HostCommand::ServerStatus => {
             log::info!("{}", adb_server.server_status()?);
         }
+        HostCommand::WaitForDevice { transport } => {
+            log::info!("waiting for device to be connected...");
+            adb_server.wait_for_device(WaitForDeviceState::Device, transport)?;
+        }
     }
 
     Ok(())

adb_cli/src/handlers/local_commands.rs

@@ -1,7 +1,7 @@
 use std::{fs::File, io::Write};
 
 use adb_client::ADBServerDevice;
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 
 use crate::models::LocalDeviceCommand;
 

adb_cli/src/main.rs

@@ -7,21 +7,33 @@ mod handlers;
 mod models;
 mod utils;
 
-use adb_client::{ADBDeviceExt, ADBServer, ADBTcpDevice, ADBUSBDevice, MDNSDiscoveryService};
+use adb_client::{
+    ADBDeviceExt, ADBServer, ADBServerDevice, ADBTcpDevice, ADBUSBDevice, MDNSDiscoveryService,
+};
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 use adb_termios::ADBTermios;
+
 use anyhow::Result;
 use clap::Parser;
 use handlers::{handle_emulator_commands, handle_host_commands, handle_local_commands};
 use models::{DeviceCommands, LocalCommand, MainCommand, Opts};
+use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 use utils::setup_logger;
 
 fn main() -> Result<()> {
+    // This depends on `clap`
     let opts = Opts::parse();
 
-    setup_logger(opts.debug);
+    // SAFETY:
+    // We are assuming the entire process is single-threaded
+    // at this point.
+    // This seems true for the current version of `clap`,
+    // but there's no guarantee for future updates
+    unsafe { setup_logger(opts.debug) };
 
     // Directly handling methods / commands that aren't linked to [`ADBDeviceExt`] trait.
     // Other methods just have to create a concrete [`ADBDeviceExt`] instance, and return it.
@@ -30,17 +42,21 @@ fn main() -> Result<()> {
         MainCommand::Host(server_command) => return Ok(handle_host_commands(server_command)?),
         MainCommand::Emu(emulator_command) => return handle_emulator_commands(emulator_command),
         MainCommand::Local(server_command) => {
-            let mut adb_server = ADBServer::new(server_command.address);
+            // Must start server to communicate with device, but only if this is a local one.
+            let server_address_ip = server_command.address.ip();
+            if server_address_ip.is_loopback() || server_address_ip.is_unspecified() {
+                ADBServer::start(&HashMap::default(), &None);
+            }
 
             let device = match server_command.serial {
-                Some(serial) => adb_server.get_device_by_name(&serial)?,
-                None => adb_server.get_device()?,
+                Some(serial) => ADBServerDevice::new(serial, Some(server_command.address)),
+                None => ADBServerDevice::autodetect(Some(server_command.address)),
             };
 
             match server_command.command {
                 LocalCommand::DeviceCommands(device_commands) => (device.boxed(), device_commands),
                 LocalCommand::LocalDeviceCommand(local_device_command) => {
-                    return handle_local_commands(device, local_device_command)
+                    return handle_local_commands(device, local_device_command);
                 }
             }
         }
@@ -55,7 +71,9 @@ fn main() -> Result<()> {
                     None => ADBUSBDevice::autodetect()?,
                 },
                 _ => {
-                    anyhow::bail!("please either supply values for both the --vendor-id and --product-id flags or none.");
+                    anyhow::bail!(
+                        "please either supply values for both the --vendor-id and --product-id flags or none."
+                    );
                 }
             };
             (device.boxed(), usb_command.commands)
@@ -97,7 +115,7 @@ fn main() -> Result<()> {
 
                 #[cfg(not(any(target_os = "linux", target_os = "macos")))]
                 {
-                    device.shell(std::io::stdin(), std::io::stdout())?;
+                    device.shell(&mut std::io::stdin(), Box::new(std::io::stdout()))?;
                 }
             } else {
                 let commands: Vec<&str> = commands.iter().map(|v| v.as_str()).collect();
@@ -114,10 +132,10 @@ fn main() -> Result<()> {
         }
         DeviceCommands::Stat { path } => {
             let stat_response = device.stat(&path)?;
-            println!("{}", stat_response);
+            println!("{stat_response}");
         }
         DeviceCommands::Reboot { reboot_type } => {
-            log::info!("Reboots device in mode {:?}", reboot_type);
+            log::info!("Reboots device in mode {reboot_type:?}");
             device.reboot(reboot_type.into())?
         }
         DeviceCommands::Push { filename, path } => {
@@ -134,7 +152,7 @@ fn main() -> Result<()> {
             device.install(&path)?;
         }
         DeviceCommands::Uninstall { package } => {
-            log::info!("Uninstalling the package {}...", package);
+            log::info!("Uninstalling the package {package}...");
             device.uninstall(&package)?;
         }
         DeviceCommands::Framebuffer { path } => {

adb_cli/src/models/host.rs

@@ -1,7 +1,14 @@
 use std::net::SocketAddrV4;
 
+use adb_client::{RustADBError, WaitForDeviceTransport};
 use clap::Parser;
 
+fn parse_wait_for_device_device_transport(
+    value: &str,
+) -> Result<WaitForDeviceTransport, RustADBError> {
+    WaitForDeviceTransport::try_from(value)
+}
+
 #[derive(Parser, Debug)]
 pub enum HostCommand {
     /// Print current ADB version.
@@ -28,6 +35,12 @@ pub enum HostCommand {
     },
     /// Display server status
     ServerStatus,
+    /// Wait for a device, on optionally given transport
+    WaitForDevice {
+        /// Transport on which wait for devices
+        #[clap(short = 't', long = "transport", value_parser = parse_wait_for_device_device_transport)]
+        transport: Option<WaitForDeviceTransport>,
+    },
 }
 
 #[derive(Parser, Debug)]

adb_cli/src/models/reboot_type.rs

@@ -8,6 +8,7 @@ pub enum RebootTypeCommand {
     Recovery,
     Sideload,
     SideloadAutoReboot,
+    Fastboot,
 }
 
 impl From<RebootTypeCommand> for RebootType {
@@ -18,6 +19,7 @@ impl From<RebootTypeCommand> for RebootType {
             RebootTypeCommand::Recovery => RebootType::Recovery,
             RebootTypeCommand::Sideload => RebootType::Sideload,
             RebootTypeCommand::SideloadAutoReboot => RebootType::SideloadAutoReboot,
+            RebootTypeCommand::Fastboot => RebootType::Fastboot,
         }
     }
 }

adb_cli/src/utils.rs

@@ -1,4 +1,8 @@
-pub fn setup_logger(debug: bool) {
+/// # Safety
+///
+/// This conditionally mutates the process' environment.
+/// See [`std::env::set_var`] for more info.
+pub unsafe fn setup_logger(debug: bool) {
     // RUST_LOG variable has more priority then "--debug" flag
     if std::env::var("RUST_LOG").is_err() {
         let level = match debug {
@@ -6,7 +10,7 @@ pub fn setup_logger(debug: bool) {
             false => "info",
         };
 
-        std::env::set_var("RUST_LOG", level);
+        unsafe { std::env::set_var("RUST_LOG", level) };
     }
 
     env_logger::init();

adb_client/Cargo.toml

@@ -7,28 +7,33 @@ license.workspace = true
 name = "adb_client"
 readme = "README.md"
 repository.workspace = true
+rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
 base64 = { version = "0.22.1" }
 bincode = { version = "1.3.3" }
 byteorder = { version = "1.5.0" }
-chrono = { version = "0.4.39" }
-homedir = { version = "0.3.4" }
-image = { version = "0.25.5" }
-lazy_static = { version = "1.5.0" }
-log = { version = "0.4.22" }
-mdns-sd = { version = "0.13.2" }
+chrono = { version = "0.4.40", default-features = false, features = ["std"] }
+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 = [
+    "logging",
+] }
 num-bigint = { version = "0.8.4", package = "num-bigint-dig" }
 num-traits = { version = "0.2.19" }
 quick-protobuf = { version = "0.8.1" }
 rand = { version = "0.9.0" }
-rcgen = { version = "0.13.1" }
+rcgen = { version = "0.13.1", default-features = false, features = [
+    "aws_lc_rs",
+    "pem",
+] }
 regex = { version = "1.11.1", features = ["perf", "std", "unicode"] }
 rsa = { version = "0.9.7" }
 rusb = { version = "0.9.4", features = ["vendored"] }
-rustls = { version = "0.23.22" }
-rustls-pki-types = "1.11.0"
+rustls = { version = "0.23.27" }
+rustls-pki-types = { version = "1.11.0" }
 serde = { version = "1.0.216", features = ["derive"] }
 serde_repr = { version = "0.1.19" }
 sha1 = { version = "0.10.6", features = ["oid"] }
@@ -36,7 +41,7 @@ thiserror = { version = "2.0.7" }
 
 [dev-dependencies]
 anyhow = { version = "1.0.93" }
-criterion = { version = "0.5.1" } # Used for benchmarks
+criterion = { version = "0.6.0" } # Used for benchmarks
 
 [[bench]]
 harness = false

adb_client/README.md

@@ -3,6 +3,7 @@
 [![MIT licensed](https://img.shields.io/crates/l/adb_client.svg)](./LICENSE-MIT)
 [![Documentation](https://docs.rs/adb_client/badge.svg)](https://docs.rs/adb_client)
 [![Crates.io Total Downloads](https://img.shields.io/crates/d/adb_client)](https://crates.io/crates/adb_client)
+![MSRV](https://img.shields.io/crates/msrv/adb_client)
 
 Rust library implementing ADB protocol.
 

adb_client/src/device/adb_message_device.rs

@@ -2,9 +2,9 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use rand::Rng;
 use std::io::{Cursor, Read, Seek};
 
-use crate::{constants::BUFFER_SIZE, ADBMessageTransport, AdbStatResponse, Result, RustADBError};
+use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};
 
-use super::{models::MessageSubcommand, ADBTransportMessage, MessageCommand};
+use super::{ADBTransportMessage, MessageCommand, models::MessageSubcommand};
 
 /// Generic structure representing an ADB device reachable over an [`ADBMessageTransport`].
 /// Structure is totally agnostic over which transport is truly used.
@@ -144,9 +144,8 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
                         MessageCommand::Write => return Ok(()),
                         c => {
                             return Err(RustADBError::ADBRequestFailed(format!(
-                                "Wrong command received {}",
-                                c
-                            )))
+                                "Wrong command received {c}"
+                            )));
                         }
                     }
                 }

adb_client/src/device/adb_message_device_commands.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbStatResponse, ADBDeviceExt, ADBMessageTransport, RebootType, Result};
+use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};
 use std::{
     io::{Read, Write},
     path::Path,

adb_client/src/device/adb_tcp_device.rs

@@ -2,9 +2,9 @@ use std::io::Write;
 use std::path::Path;
 use std::{io::Read, net::SocketAddr};
 
+use super::ADBTransportMessage;
 use super::adb_message_device::ADBMessageDevice;
 use super::models::MessageCommand;
-use super::ADBTransportMessage;
 use crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, TcpTransport};
 
 /// Represent a device reached and available over USB.
@@ -38,18 +38,26 @@ impl ADBTcpDevice {
 
         self.get_transport_mut().write_message(message)?;
 
-        // At this point, we should have received a STLS command indicating that the device wants to upgrade connection with TLS
-        self.get_transport_mut()
-            .read_message()
-            .and_then(|message| message.assert_command(MessageCommand::Stls))?;
+        let message = self.get_transport_mut().read_message()?;
 
-        self.get_transport_mut()
-            .write_message(ADBTransportMessage::new(MessageCommand::Stls, 1, 0, &[]))?;
-
-        // Upgrade TCP connection to TLS
-        self.get_transport_mut().upgrade_connection()?;
-
-        log::debug!("Connection successfully upgraded from TCP to TLS");
+        // Check if client is requesting a secure connection and upgrade it if necessary
+        match message.header().command() {
+            MessageCommand::Stls => {
+                self.get_transport_mut()
+                    .write_message(ADBTransportMessage::new(MessageCommand::Stls, 1, 0, &[]))?;
+                self.get_transport_mut().upgrade_connection()?;
+                log::debug!("Connection successfully upgraded from TCP to TLS");
+            }
+            MessageCommand::Cnxn => {
+                log::debug!("Unencrypted connection established");
+            }
+            _ => {
+                return Err(crate::RustADBError::WrongResponseReceived(
+                    "Expected CNXN or STLS command".to_string(),
+                    message.header().command().to_string(),
+                ));
+            }
+        }
 
         Ok(())
     }

adb_client/src/device/adb_usb_device.rs

@@ -1,7 +1,7 @@
-use rusb::constants::LIBUSB_CLASS_VENDOR_SPEC;
 use rusb::Device;
 use rusb::DeviceDescriptor;
 use rusb::UsbContext;
+use rusb::constants::LIBUSB_CLASS_VENDOR_SPEC;
 use std::fs::read_to_string;
 use std::io::Read;
 use std::io::Write;
@@ -12,26 +12,31 @@ use std::time::Duration;
 use super::adb_message_device::ADBMessageDevice;
 use super::models::MessageCommand;
 use super::{ADBRsaKey, ADBTransportMessage};
-use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
 use crate::ADBDeviceExt;
 use crate::ADBMessageTransport;
 use crate::ADBTransport;
+use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
 use crate::{Result, RustADBError, USBTransport};
 
 pub fn read_adb_private_key<P: AsRef<Path>>(private_key_path: P) -> Result<Option<ADBRsaKey>> {
-    Ok(read_to_string(private_key_path.as_ref()).map(|pk| {
-        match ADBRsaKey::new_from_pkcs8(&pk) {
-            Ok(pk) => Some(pk),
-            Err(e) => {
-                log::error!("Error while create RSA private key: {e}");
-                None
-            }
-        }
-    })?)
+    // Try to read the private key file from given path
+    // If the file is not found, return None
+    // If there is another error while reading the file, return this error
+    // Else, return the private key content
+    let pk = match read_to_string(private_key_path.as_ref()) {
+        Ok(pk) => pk,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(e) => return Err(e.into()),
+    };
+
+    match ADBRsaKey::new_from_pkcs8(&pk) {
+        Ok(pk) => Ok(Some(pk)),
+        Err(e) => Err(e),
+    }
 }
 
 /// 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 {
@@ -51,13 +56,13 @@ fn search_adb_devices() -> Result<Option<(u16, u16)>> {
         (None, _) => Ok(None),
         (Some(identifiers), None) => Ok(Some(*identifiers)),
         (Some((vid1, pid1)), Some((vid2, pid2))) => Err(RustADBError::DeviceNotFound(format!(
-            "Found two Android devices {:04x}:{:04x} and {:04x}:{:04x}",
-            vid1, pid1, vid2, pid2
+            "Found two Android devices {vid1:04x}:{pid1:04x} and {vid2:04x}:{pid2:04x}",
         ))),
     }
 }
 
-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;
 
@@ -134,9 +139,15 @@ impl ADBUSBDevice {
         transport: USBTransport,
         private_key_path: PathBuf,
     ) -> Result<Self> {
-        let private_key = match read_adb_private_key(private_key_path)? {
+        let private_key = match read_adb_private_key(&private_key_path)? {
             Some(pk) => pk,
-            None => ADBRsaKey::new_random()?,
+            None => {
+                log::warn!(
+                    "No private key found at path {}. Using a temporary random one.",
+                    private_key_path.display()
+                );
+                ADBRsaKey::new_random()?
+            }
         };
 
         let mut s = Self {
@@ -180,6 +191,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
@@ -188,7 +204,7 @@ impl ADBUSBDevice {
             v => {
                 return Err(RustADBError::ADBRequestFailed(format!(
                     "Received AUTH message with type != 1 ({v})"
-                )))
+                )));
             }
         };
 

adb_client/src/device/commands/framebuffer.rs

@@ -4,9 +4,9 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use image::{ImageBuffer, Rgba};
 
 use crate::{
-    device::{adb_message_device::ADBMessageDevice, MessageCommand},
-    models::{FrameBufferInfoV1, FrameBufferInfoV2},
     ADBMessageTransport, Result, RustADBError,
+    device::{MessageCommand, adb_message_device::ADBMessageDevice},
+    models::{FrameBufferInfoV1, FrameBufferInfoV2},
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/install.rs

@@ -1,11 +1,9 @@
 use std::{fs::File, path::Path};
 
-use rand::Rng;
-
 use crate::{
-    device::{adb_message_device::ADBMessageDevice, MessageWriter},
-    utils::check_extension_is_apk,
     ADBMessageTransport, Result,
+    device::{MessageWriter, adb_message_device::ADBMessageDevice},
+    utils::check_extension_is_apk,
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
@@ -16,15 +14,11 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         let file_size = apk_file.metadata()?.len();
 
-        let mut rng = rand::rng();
-
-        let local_id = rng.random();
-
-        self.open_session(format!("exec:cmd package 'install' -S {}\0", file_size).as_bytes())?;
+        self.open_session(format!("exec:cmd package 'install' -S {file_size}\0").as_bytes())?;
 
         let transport = self.get_transport().clone();
 
-        let mut writer = MessageWriter::new(transport, local_id, self.get_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

@@ -1,11 +1,11 @@
 use std::io::Write;
 
 use crate::{
-    device::{
-        adb_message_device::ADBMessageDevice, models::MessageSubcommand, ADBTransportMessage,
-        MessageCommand,
-    },
     ADBMessageTransport, Result, RustADBError,
+    device::{
+        ADBTransportMessage, MessageCommand, adb_message_device::ADBMessageDevice,
+        models::MessageSubcommand,
+    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/push.rs

@@ -1,11 +1,11 @@
 use std::io::Read;
 
 use crate::{
-    device::{
-        adb_message_device::ADBMessageDevice, ADBTransportMessage, MessageCommand,
-        MessageSubcommand,
-    },
     ADBMessageTransport, Result, RustADBError,
+    device::{
+        ADBTransportMessage, MessageCommand, MessageSubcommand,
+        adb_message_device::ADBMessageDevice,
+    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/reboot.rs

@@ -1,11 +1,11 @@
 use crate::{
-    device::{adb_message_device::ADBMessageDevice, MessageCommand},
     ADBMessageTransport, RebootType, Result,
+    device::{MessageCommand, adb_message_device::ADBMessageDevice},
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn reboot(&mut self, reboot_type: RebootType) -> Result<()> {
-        self.open_session(format!("reboot:{}\0", reboot_type).as_bytes())?;
+        self.open_session(format!("reboot:{reboot_type}\0").as_bytes())?;
 
         self.get_transport_mut()
             .read_message()

adb_client/src/device/commands/shell.rs

@@ -1,10 +1,10 @@
 use std::io::{ErrorKind, Read, Write};
 
-use crate::device::ShellMessageWriter;
 use crate::Result;
+use crate::device::ShellMessageWriter;
 use crate::{
-    device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
     ADBMessageTransport, RustADBError,
+    device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/stat.rs

@@ -1,5 +1,5 @@
 use crate::{
-    device::adb_message_device::ADBMessageDevice, ADBMessageTransport, AdbStatResponse, Result,
+    ADBMessageTransport, AdbStatResponse, Result, device::adb_message_device::ADBMessageDevice,
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/uninstall.rs

@@ -1,14 +1,14 @@
-use crate::{device::adb_message_device::ADBMessageDevice, ADBMessageTransport, Result};
+use crate::{ADBMessageTransport, Result, device::adb_message_device::ADBMessageDevice};
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn uninstall(&mut self, package_name: &str) -> Result<()> {
-        self.open_session(format!("exec:cmd package 'uninstall' {}\0", package_name).as_bytes())?;
+        self.open_session(format!("exec:cmd package 'uninstall' {package_name}\0").as_bytes())?;
 
         let final_status = self.get_transport_mut().read_message()?;
 
         match final_status.into_payload().as_slice() {
             b"Success\n" => {
-                log::info!("Package {} successfully uninstalled", package_name);
+                log::info!("Package {package_name} successfully uninstalled");
                 Ok(())
             }
             d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(

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::{get_default_adb_key_path, ADBUSBDevice};
+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/device/models/adb_rsa_key.rs

@@ -1,8 +1,8 @@
 use crate::{Result, RustADBError};
-use base64::{engine::general_purpose::STANDARD, Engine};
+use base64::{Engine, engine::general_purpose::STANDARD};
 use num_bigint::{BigUint, ModInverse};
-use num_traits::cast::ToPrimitive;
 use num_traits::FromPrimitive;
+use num_traits::cast::ToPrimitive;
 use rsa::pkcs8::DecodePrivateKey;
 use rsa::traits::PublicKeyParts;
 use rsa::{Pkcs1v15Sign, RsaPrivateKey};

adb_client/src/device/shell_message_writer.rs

@@ -2,7 +2,7 @@ use std::io::Write;
 
 use crate::ADBMessageTransport;
 
-use super::{models::MessageCommand, ADBTransportMessage};
+use super::{ADBTransportMessage, models::MessageCommand};
 
 /// [`Write`] trait implementation to hide underlying ADB protocol write logic for shell commands.
 pub struct ShellMessageWriter<T: ADBMessageTransport> {

adb_client/src/emulator_device/adb_emulator_device.rs

@@ -30,8 +30,7 @@ impl ADBEmulatorDevice {
         let groups = EMULATOR_REGEX
             .captures(&identifier)
             .ok_or(RustADBError::DeviceNotFound(format!(
-                "Device {} is likely not an emulator",
-                identifier
+                "Device {identifier} is likely not an emulator"
             )))?;
 
         let port = groups
@@ -65,10 +64,15 @@ impl TryFrom<ADBServerDevice> for ADBEmulatorDevice {
     type Error = RustADBError;
 
     fn try_from(value: ADBServerDevice) -> std::result::Result<Self, Self::Error> {
-        ADBEmulatorDevice::new(
-            value.identifier.clone(),
-            Some(*value.transport.get_socketaddr().ip()),
-        )
+        match &value.identifier {
+            Some(device_identifier) => ADBEmulatorDevice::new(
+                device_identifier.clone(),
+                Some(*value.transport.get_socketaddr().ip()),
+            ),
+            None => Err(RustADBError::DeviceNotFound(
+                "cannot connect to an emulator device without knowing its identifier".to_string(),
+            )),
+        }
     }
 }
 

adb_client/src/emulator_device/commands/rotate.rs

@@ -1,4 +1,4 @@
-use crate::{emulator_device::ADBEmulatorCommand, ADBEmulatorDevice, Result};
+use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
 
 impl ADBEmulatorDevice {
     /// Send a SMS to this emulator with given content with given phone number

adb_client/src/emulator_device/commands/sms.rs

@@ -1,4 +1,4 @@
-use crate::{emulator_device::ADBEmulatorCommand, ADBEmulatorDevice, Result};
+use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
 
 impl ADBEmulatorDevice {
     /// Send a SMS to this emulator with given content with given phone number

adb_client/src/error.rs

@@ -117,6 +117,9 @@ pub enum RustADBError {
     /// An error occurred while sending data to channel
     #[error(transparent)]
     SendError(#[from] std::sync::mpsc::SendError<crate::MDNSDevice>),
+    /// An unknown transport has been provided
+    #[error("unknown transport: {0}")]
+    UnknownTransport(String),
 }
 
 impl<T> From<std::sync::PoisonError<T>> for RustADBError {

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/mdns/mdns_discovery.rs

@@ -33,19 +33,21 @@ impl MDNSDiscoveryService {
     pub fn start(&mut self, sender: Sender<MDNSDevice>) -> Result<()> {
         let receiver = self.daemon.browse(ADB_SERVICE_NAME)?;
 
-        let handle: JoinHandle<Result<()>> = std::thread::spawn(move || loop {
-            while let Ok(event) = receiver.recv() {
-                match event {
-                    ServiceEvent::SearchStarted(_)
-                    | ServiceEvent::ServiceRemoved(_, _)
-                    | ServiceEvent::ServiceFound(_, _)
-                    | ServiceEvent::SearchStopped(_) => {
-                        // Ignoring these events. We are only interesting in found devices
-                        continue;
-                    }
-                    ServiceEvent::ServiceResolved(service_info) => {
-                        if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
-                            return Err(e.into());
+        let handle: JoinHandle<Result<()>> = std::thread::spawn(move || {
+            loop {
+                while let Ok(event) = receiver.recv() {
+                    match event {
+                        ServiceEvent::SearchStarted(_)
+                        | ServiceEvent::ServiceRemoved(_, _)
+                        | ServiceEvent::ServiceFound(_, _)
+                        | ServiceEvent::SearchStopped(_) => {
+                            // Ignoring these events. We are only interesting in found devices
+                            continue;
+                        }
+                        ServiceEvent::ServiceResolved(service_info) => {
+                            if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
+                                return Err(e.into());
+                            }
                         }
                     }
                 }

adb_client/src/models/adb_server_command.rs

@@ -1,5 +1,7 @@
 use std::fmt::Display;
 
+use crate::{WaitForDeviceState, WaitForDeviceTransport};
+
 use super::RebootType;
 use std::net::SocketAddrV4;
 
@@ -22,6 +24,7 @@ pub(crate) enum AdbServerCommand {
     ReconnectOffline,
     Uninstall(String),
     Install(u64),
+    WaitForDevice(WaitForDeviceState, WaitForDeviceTransport),
     // Local commands
     ShellCommand(String),
     Shell,
@@ -60,8 +63,8 @@ impl Display for AdbServerCommand {
             AdbServerCommand::Reboot(reboot_type) => {
                 write!(f, "reboot:{reboot_type}")
             }
-            AdbServerCommand::Connect(addr) => write!(f, "host:connect:{}", addr),
-            AdbServerCommand::Disconnect(addr) => write!(f, "host:disconnect:{}", addr),
+            AdbServerCommand::Connect(addr) => write!(f, "host:connect:{addr}"),
+            AdbServerCommand::Disconnect(addr) => write!(f, "host:disconnect:{addr}"),
             AdbServerCommand::Pair(addr, code) => {
                 write!(f, "host:pair:{code}:{addr}")
             }
@@ -87,6 +90,12 @@ impl Display for AdbServerCommand {
             AdbServerCommand::Uninstall(package) => {
                 write!(f, "exec:cmd package 'uninstall' {package}")
             }
+            AdbServerCommand::WaitForDevice(wait_for_device_state, wait_for_device_transport) => {
+                write!(
+                    f,
+                    "host:wait-for-{wait_for_device_transport}-{wait_for_device_state}"
+                )
+            }
         }
     }
 }

adb_client/src/models/reboot_type.rs

@@ -13,6 +13,8 @@ pub enum RebootType {
     Sideload,
     /// Same as `Sideload` but reboots after sideloading
     SideloadAutoReboot,
+    /// Reboots to fastboot
+    Fastboot,
 }
 
 impl Display for RebootType {
@@ -23,6 +25,7 @@ impl Display for RebootType {
             RebootType::Recovery => write!(f, "recovery"),
             RebootType::Sideload => write!(f, "sideload"),
             RebootType::SideloadAutoReboot => write!(f, "sideload-auto-reboot"),
+            RebootType::Fastboot => write!(f, "fastboot"),
         }
     }
 }

adb_client/src/server/adb_server.rs

@@ -15,6 +15,9 @@ pub struct ADBServer {
     pub(crate) socket_addr: Option<SocketAddrV4>,
     /// adb-server start envs
     pub(crate) envs: HashMap<String, String>,
+    /// Path to adb binary
+    /// If not set, will use adb from PATH
+    pub(crate) adb_path: Option<String>,
 }
 
 impl ADBServer {
@@ -24,6 +27,44 @@ impl ADBServer {
             transport: None,
             socket_addr: Some(address),
             envs: HashMap::new(),
+            adb_path: None,
+        }
+    }
+
+    /// Instantiates a new [ADBServer] with a custom adb path
+    pub fn new_from_path(address: SocketAddrV4, adb_path: Option<String>) -> Self {
+        Self {
+            transport: None,
+            socket_addr: Some(address),
+            envs: HashMap::new(),
+            adb_path,
+        }
+    }
+
+    /// Start an instance of `adb-server`
+    pub fn start(envs: &HashMap<String, String>, adb_path: &Option<String>) {
+        // ADB Server is local, we start it if not already running
+        let mut command = Command::new(adb_path.as_deref().unwrap_or("adb"));
+        command.arg("start-server");
+        for (env_k, env_v) in envs.iter() {
+            command.env(env_k, env_v);
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            use std::os::windows::process::CommandExt;
+            // Do not show a prompt on Windows
+            command.creation_flags(0x08000000);
+        }
+
+        let child = command.spawn();
+        match child {
+            Ok(mut child) => {
+                if let Err(e) = child.wait() {
+                    log::error!("error while starting adb server: {e}")
+                }
+            }
+            Err(e) => log::error!("error while starting adb server: {e}"),
         }
     }
 
@@ -52,22 +93,7 @@ impl ADBServer {
         };
 
         if is_local_ip {
-            // ADB Server is local, we start it if not already running
-            let mut command = Command::new("adb");
-            command.arg("start-server");
-            for (env_k, env_v) in self.envs.iter() {
-                command.env(env_k, env_v);
-            }
-
-            let child = command.spawn();
-            match child {
-                Ok(mut child) => {
-                    if let Err(e) = child.wait() {
-                        log::error!("error while starting adb server: {e}")
-                    }
-                }
-                Err(e) => log::error!("error while starting adb server: {e}"),
-            }
+            Self::start(&self.envs, &self.adb_path);
         }
 
         transport.connect()?;
@@ -79,7 +105,7 @@ impl ADBServer {
 
 impl Drop for ADBServer {
     fn drop(&mut self) {
-        if let Some(ref mut transport) = &mut self.transport {
+        if let Some(transport) = &mut self.transport {
             let _ = transport.disconnect();
         }
     }

adb_client/src/server/commands/connect.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
+use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 impl ADBServer {

adb_client/src/server/commands/devices.rs

@@ -1,8 +1,8 @@
 use std::io::Read;
 
 use crate::{
-    models::AdbServerCommand, ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong,
-    DeviceShort, Result, RustADBError,
+    ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong, DeviceShort, Result, RustADBError,
+    models::AdbServerCommand,
 };
 
 impl ADBServer {
@@ -36,7 +36,7 @@ impl ADBServer {
                 break;
             }
 
-            vec_devices.push(DeviceLong::try_from(device.to_vec())?);
+            vec_devices.push(DeviceLong::try_from(device)?);
         }
 
         Ok(vec_devices)

adb_client/src/server/commands/disconnect.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
+use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 impl ADBServer {

adb_client/src/server/commands/kill.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result};
+use crate::{ADBServer, Result, models::AdbServerCommand};
 
 impl ADBServer {
     /// Asks the ADB server to quit immediately.

adb_client/src/server/commands/mdns.rs

@@ -1,7 +1,7 @@
 use std::io::BufRead;
 
 use crate::{
-    models::AdbServerCommand, server::models::MDNSBackend, ADBServer, MDNSServices, Result,
+    ADBServer, MDNSServices, Result, models::AdbServerCommand, server::models::MDNSBackend,
 };
 
 const OPENSCREEN_MDNS_BACKEND: &str = "ADB_MDNS_OPENSCREEN";
@@ -32,7 +32,7 @@ impl ADBServer {
                 Ok(service) => {
                     vec_services.push(MDNSServices::try_from(service.as_bytes())?);
                 }
-                Err(e) => log::error!("{}", e),
+                Err(e) => log::error!("{e}"),
             }
         }
 

adb_client/src/server/commands/mod.rs

@@ -7,3 +7,4 @@ mod pair;
 mod reconnect;
 mod server_status;
 mod version;
+mod wait_for_device;

adb_client/src/server/commands/reconnect.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result};
+use crate::{ADBServer, Result, models::AdbServerCommand};
 
 impl ADBServer {
     /// Reconnect the device

adb_client/src/server/commands/server_status.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, server::models::ServerStatus, ADBServer, Result};
+use crate::{ADBServer, Result, models::AdbServerCommand, server::models::ServerStatus};
 
 impl ADBServer {
     /// Check ADB server status

adb_client/src/server/commands/version.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, AdbVersion, Result};
+use crate::{ADBServer, AdbVersion, Result, models::AdbServerCommand};
 
 impl ADBServer {
     /// Gets server's internal version number.

adb_client/src/server/commands/wait_for_device.rs

@@ -0,0 +1,20 @@
+use crate::{
+    ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport, models::AdbServerCommand,
+};
+
+impl ADBServer {
+    /// Wait for a device in a given state to be connected
+    pub fn wait_for_device(
+        &mut self,
+        state: WaitForDeviceState,
+        transport: Option<WaitForDeviceTransport>,
+    ) -> Result<()> {
+        let transport = transport.unwrap_or_default();
+
+        self.connect()?
+            .send_adb_request(AdbServerCommand::WaitForDevice(state, transport))?;
+
+        // Server should respond with an "OKAY" response
+        self.get_transport()?.read_adb_response()
+    }
+}

adb_client/src/server/models/device_long.rs

@@ -6,7 +6,7 @@ use crate::{DeviceState, RustADBError};
 use regex::bytes::Regex;
 
 static DEVICES_LONG_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new("^(?P<identifier>\\S+)\\s+(?P<state>\\w+) ((usb:(?P<usb1>.*)|(?P<usb2>\\d-\\d)) )?(product:(?P<product>\\w+) model:(?P<model>\\w+) device:(?P<device>\\w+) )?transport_id:(?P<transport_id>\\d+)$").expect("cannot build devices long regex")
+    Regex::new(r"^(?P<identifier>\S+)\s+(?P<state>\w+)\s+(usb:(?P<usb1>\S+)|(?P<usb2>\S+))?\s*(product:(?P<product>\S+)\s+model:(?P<model>\w+)\s+device:(?P<device>\S+)\s+)?transport_id:(?P<transport_id>\d+)$").expect("cannot build devices long regex")
 });
 
 /// Represents a new device with more informations.
@@ -44,12 +44,12 @@ impl Display for DeviceLong {
     }
 }
 
-impl TryFrom<Vec<u8>> for DeviceLong {
+impl TryFrom<&[u8]> for DeviceLong {
     type Error = RustADBError;
 
-    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         let groups = DEVICES_LONG_REGEX
-            .captures(&value)
+            .captures(value)
             .ok_or(RustADBError::RegexParsingError)?;
 
         Ok(DeviceLong {
@@ -93,8 +93,22 @@ impl TryFrom<Vec<u8>> for DeviceLong {
                         .ok_or(RustADBError::RegexParsingError)?
                         .as_bytes(),
                 )?,
-                16,
+                10,
             )?,
         })
     }
 }
+
+#[test]
+fn test_static_devices_long() {
+    let inputs = [
+        "7a5158f05122195aa       device 1-5 product:gts210vewifixx model:SM_T813 device:gts210vewifi transport_id:4",
+        "n311r05e               device usb:0-1.5 product:alioth model:M2012K11AC device:alioth transport_id:58",
+        "192.168.100.192:5555   device product:alioth model:M2012K11AC device:alioth transport_id:97",
+        "emulator-5554          device product:sdk_gphone64_arm64 model:sdk_gphone64_arm64 device:emu64a transport_id:101",
+        "QQ20131020250511       device 20-4 product:NOH-AN00 model:NOH_AN00 device:HWNOH transport_id:3",
+    ];
+    for input in inputs {
+        DeviceLong::try_from(input.as_bytes()).expect(&format!("cannot parse input: '{input}'"));
+    }
+}

adb_client/src/server/models/mod.rs

@@ -4,6 +4,7 @@ mod device_short;
 mod device_state;
 mod mdns_services;
 mod server_status;
+mod wait_for_device;
 
 pub use adb_version::AdbVersion;
 pub use device_long::DeviceLong;
@@ -11,3 +12,4 @@ pub use device_short::DeviceShort;
 pub use device_state::DeviceState;
 pub use mdns_services::MDNSServices;
 pub use server_status::{MDNSBackend, ServerStatus};
+pub use wait_for_device::{WaitForDeviceState, WaitForDeviceTransport};

adb_client/src/server/models/wait_for_device.rs

@@ -0,0 +1,67 @@
+use std::fmt::Display;
+
+use crate::RustADBError;
+
+#[derive(Clone, Debug)]
+/// List of available transports to wait for.
+pub enum WaitForDeviceTransport {
+    /// USB transport
+    Usb,
+    /// Local transport
+    Local,
+    /// Any transport (default value)
+    Any,
+}
+
+impl Default for WaitForDeviceTransport {
+    fn default() -> Self {
+        Self::Any
+    }
+}
+
+impl Display for WaitForDeviceTransport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WaitForDeviceTransport::Usb => write!(f, "usb"),
+            WaitForDeviceTransport::Local => write!(f, "local"),
+            WaitForDeviceTransport::Any => write!(f, "any"),
+        }
+    }
+}
+
+impl TryFrom<&str> for WaitForDeviceTransport {
+    type Error = RustADBError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "usb" => Ok(Self::Usb),
+            "local" => Ok(Self::Local),
+            "any" => Ok(Self::Any),
+            t => Err(RustADBError::UnknownTransport(t.to_string())),
+        }
+    }
+}
+
+#[derive(Debug)]
+/// List of available states to wait for.
+pub enum WaitForDeviceState {
+    /// Device in "device" state
+    Device,
+    /// Device in "recovery" state
+    Recovery,
+    /// Device in "sideload" state
+    Sideload,
+    /// Device in "bootloader" state
+    Bootloader,
+}
+
+impl Display for WaitForDeviceState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WaitForDeviceState::Device => write!(f, "device"),
+            WaitForDeviceState::Recovery => write!(f, "recovery"),
+            WaitForDeviceState::Sideload => write!(f, "sideload"),
+            WaitForDeviceState::Bootloader => write!(f, "bootloader"),
+        }
+    }
+}

adb_client/src/server_device/adb_server_device.rs

@@ -1,26 +1,32 @@
-use crate::{ADBTransport, Result, TCPServerTransport};
+use crate::{ADBTransport, Result, TCPServerTransport, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 /// Represents a device connected to the ADB server.
 #[derive(Debug)]
 pub struct ADBServerDevice {
     /// Unique device identifier.
-    pub identifier: String,
+    pub identifier: Option<String>,
     /// Internal [TCPServerTransport]
     pub(crate) transport: TCPServerTransport,
 }
 
 impl ADBServerDevice {
-    /// Instantiates a new [ADBServerDevice]
-    pub fn new(identifier: String, socket_addr: Option<SocketAddrV4>) -> Self {
-        let transport = if let Some(addr) = socket_addr {
-            TCPServerTransport::new(addr)
-        } else {
-            TCPServerTransport::default()
-        };
+    /// Instantiates a new [ADBServerDevice], knowing its ADB identifier (as returned by `adb devices` command).
+    pub fn new(identifier: String, server_addr: Option<SocketAddrV4>) -> Self {
+        let transport = TCPServerTransport::new_or_default(server_addr);
 
         Self {
-            identifier,
+            identifier: Some(identifier),
+            transport,
+        }
+    }
+
+    /// Instantiates a new [ADBServerDevice], assuming only one is currently connected.
+    pub fn autodetect(server_addr: Option<SocketAddrV4>) -> Self {
+        let transport = TCPServerTransport::new_or_default(server_addr);
+
+        Self {
+            identifier: None,
             transport,
         }
     }
@@ -31,6 +37,19 @@ impl ADBServerDevice {
 
         Ok(&mut self.transport)
     }
+
+    /// Set device connection to use serial transport
+    pub(crate) fn set_serial_transport(&mut self) -> Result<()> {
+        let identifier = self.identifier.clone();
+        let transport = self.connect()?;
+        if let Some(serial) = identifier {
+            transport.send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        } else {
+            transport.send_adb_request(AdbServerCommand::TransportAny)?;
+        }
+
+        Ok(())
+    }
 }
 
 impl Drop for ADBServerDevice {

adb_client/src/server_device/adb_server_device_commands.rs

@@ -4,9 +4,9 @@ use std::{
 };
 
 use crate::{
+    ADBDeviceExt, Result, RustADBError,
     constants::BUFFER_SIZE,
     models::{AdbServerCommand, AdbStatResponse, HostFeatures},
-    ADBDeviceExt, Result, RustADBError,
 };
 
 use super::ADBServerDevice;
@@ -20,9 +20,8 @@ impl ADBDeviceExt for ADBServerDevice {
             return Err(RustADBError::ADBShellNotSupported);
         }
 
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
+
         self.transport
             .send_adb_request(AdbServerCommand::ShellCommand(command.join(" ")))?;
 
@@ -59,9 +58,7 @@ impl ADBDeviceExt for ADBServerDevice {
             return Err(RustADBError::ADBShellNotSupported);
         }
 
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
         self.transport.send_adb_request(AdbServerCommand::Shell)?;
 
         let mut read_stream = self.transport.get_raw_connection()?.try_clone()?;

adb_client/src/server_device/commands/forward.rs

@@ -1,11 +1,9 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Forward socket connection
     pub fn forward(&mut self, remote: String, local: String) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial.clone()))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::Forward(remote, local), false)
@@ -14,9 +12,7 @@ impl ADBServerDevice {
 
     /// Remove all previously applied forward rules
     pub fn forward_remove_all(&mut self) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial.clone()))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::ForwardRemoveAll, false)

adb_client/src/server_device/commands/framebuffer.rs

@@ -4,16 +4,14 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use image::{ImageBuffer, Rgba};
 
 use crate::{
-    models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
     ADBServerDevice, Result, RustADBError,
+    models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
 };
 
 impl ADBServerDevice {
     /// Inner method requesting framebuffer from Android device
     pub(crate) fn framebuffer_inner(&mut self) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>> {
-        let serial: String = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .send_adb_request(AdbServerCommand::FrameBuffer)?;

adb_client/src/server_device/commands/host_features.rs

@@ -1,14 +1,12 @@
 use crate::{
-    models::{AdbServerCommand, HostFeatures},
     ADBServerDevice, Result,
+    models::{AdbServerCommand, HostFeatures},
 };
 
 impl ADBServerDevice {
     /// Lists available ADB server features.
     pub fn host_features(&mut self) -> Result<Vec<HostFeatures>> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         let features = self
             .transport

adb_client/src/server_device/commands/install.rs

@@ -1,7 +1,7 @@
 use std::{fs::File, io::Read, path::Path};
 
 use crate::{
-    models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk, Result,
+    Result, models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
 };
 
 impl ADBServerDevice {
@@ -13,9 +13,7 @@ impl ADBServerDevice {
 
         let file_size = apk_file.metadata()?.len();
 
-        let serial: String = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .send_adb_request(AdbServerCommand::Install(file_size))?;

adb_client/src/server_device/commands/list.rs

@@ -1,6 +1,6 @@
 use crate::{
-    models::{AdbServerCommand, SyncCommand},
     ADBServerDevice, Result,
+    models::{AdbServerCommand, SyncCommand},
 };
 use byteorder::{ByteOrder, LittleEndian};
 use std::{
@@ -11,9 +11,7 @@ use std::{
 impl ADBServerDevice {
     /// Lists files in path on the device.
     pub fn list<A: AsRef<str>>(&mut self, path: A) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         // Set device in SYNC mode
         self.transport.send_adb_request(AdbServerCommand::Sync)?;
@@ -66,7 +64,7 @@ impl ADBServerDevice {
                 "DONE" => {
                     return Ok(());
                 }
-                x => log::error!("Got an unknown response {}", x),
+                x => log::error!("Got an unknown response {x}"),
             }
         }
     }

adb_client/src/server_device/commands/logcat.rs

@@ -23,21 +23,26 @@ impl<W: Write> LogFilter<W> {
 
 impl<W: Write> Write for LogFilter<W> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        // Add newly received bytes to the internal buffer
         self.buffer.extend_from_slice(buf);
 
-        let buf_clone = self.buffer.clone();
-        let mut lines = buf_clone.split_inclusive(|&byte| byte == b'\n').peekable();
+        let mut processed = 0;
+        while let Some(pos) = self.buffer[processed..].iter().position(|&b| b == b'\n') {
+            // Found a newline, need to process it
+            let end = processed + pos + 1; // +1 to include the '\n'
+            let line = &self.buffer[processed..end];
 
-        while let Some(line) = lines.next() {
-            if lines.peek().is_some() {
-                if self.should_write(line) {
-                    self.writer.write_all(line)?;
-                }
-            } else {
-                // This is the last (unfinished) element, we keep it for next round
-                self.buffer = line.to_vec();
-                break;
+            if self.should_write(line) {
+                self.writer.write_all(line)?;
             }
+
+            processed = end;
+        }
+
+        // Keep only remaining bytes after the last complete line
+        if processed > 0 {
+            self.buffer.copy_within(processed.., 0);
+            self.buffer.truncate(self.buffer.len() - processed);
         }
 
         Ok(buf.len())

adb_client/src/server_device/commands/reboot.rs

@@ -1,14 +1,12 @@
 use crate::{
-    models::{AdbServerCommand, RebootType},
     ADBServerDevice, Result,
+    models::{AdbServerCommand, RebootType},
 };
 
 impl ADBServerDevice {
     /// Reboots the device
     pub fn reboot(&mut self, reboot_type: RebootType) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::Reboot(reboot_type), false)

adb_client/src/server_device/commands/reconnect.rs

@@ -1,11 +1,9 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Reconnect device
     pub fn reconnect(&mut self) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::Reconnect, false)

adb_client/src/server_device/commands/recv.rs

@@ -1,7 +1,6 @@
 use crate::{
-    constants,
+    ADBServerDevice, Result, constants,
     models::{AdbServerCommand, SyncCommand},
-    ADBServerDevice, Result,
 };
 use byteorder::{LittleEndian, ReadBytesExt};
 use std::io::{BufReader, BufWriter, Read, Write};
@@ -43,18 +42,14 @@ 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(
-                        std::io::ErrorKind::Other,
-                        format!(
-                            "ADB request failed: {}",
-                            String::from_utf8_lossy(&error_msg)
-                        ),
-                    ))
+                    Err(std::io::Error::other(format!(
+                        "ADB request failed: {}",
+                        String::from_utf8_lossy(&error_msg)
+                    )))
                 }
-                _ => Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    format!("Unknown response from device {:#?}", header),
-                )),
+                _ => Err(std::io::Error::other(format!(
+                    "Unknown response from device {header:#?}"
+                ))),
             }
         } else {
             // Computing minimum to ensure to stop reading before next header...
@@ -71,9 +66,7 @@ impl<R: Read> Read for ADBRecvCommandReader<R> {
 impl ADBServerDevice {
     /// Receives path to stream from the device.
     pub fn pull(&mut self, path: &dyn AsRef<str>, stream: &mut dyn Write) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         // Set device in SYNC mode
         self.transport.send_adb_request(AdbServerCommand::Sync)?;

adb_client/src/server_device/commands/reverse.rs

@@ -1,11 +1,9 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Reverse socket connection
     pub fn reverse(&mut self, remote: String, local: String) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::Reverse(remote, local), false)
@@ -14,9 +12,7 @@ impl ADBServerDevice {
 
     /// Remove all reverse rules
     pub fn reverse_remove_all(&mut self) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial.clone()))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::ReverseRemoveAll, false)

adb_client/src/server_device/commands/send.rs

@@ -1,7 +1,6 @@
 use crate::{
-    constants,
+    ADBServerDevice, Result, RustADBError, constants,
     models::{AdbRequestStatus, AdbServerCommand, SyncCommand},
-    ADBServerDevice, Result, RustADBError,
 };
 use std::{
     convert::TryInto,
@@ -45,9 +44,7 @@ impl ADBServerDevice {
     /// Send stream to path on the device.
     pub fn push<R: Read, A: AsRef<str>>(&mut self, stream: R, path: A) -> Result<()> {
         log::info!("Sending data to {}", path.as_ref());
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         // Set device in SYNC mode
         self.transport.send_adb_request(AdbServerCommand::Sync)?;

adb_client/src/server_device/commands/stat.rs

@@ -3,8 +3,8 @@ use std::io::{Read, Write};
 use byteorder::{ByteOrder, LittleEndian};
 
 use crate::{
-    models::{AdbServerCommand, AdbStatResponse, SyncCommand},
     ADBServerDevice, Result, RustADBError,
+    models::{AdbServerCommand, AdbStatResponse, SyncCommand},
 };
 
 impl ADBServerDevice {
@@ -31,17 +31,14 @@ impl ADBServerDevice {
                 Ok(data.into())
             }
             x => Err(RustADBError::UnknownResponseType(format!(
-                "Unknown response {}",
-                x
+                "Unknown response {x}"
             ))),
         }
     }
 
     /// Stat file given as path on the device.
     pub fn stat<A: AsRef<str>>(&mut self, path: A) -> Result<AdbStatResponse> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         // Set device in SYNC mode
         self.transport.send_adb_request(AdbServerCommand::Sync)?;

adb_client/src/server_device/commands/tcpip.rs

@@ -1,11 +1,9 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Set adb daemon to tcp/ip mode
     pub fn tcpip(&mut self, port: u16) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .proxy_connection(AdbServerCommand::TcpIp(port), false)

adb_client/src/server_device/commands/transport.rs

@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Asks ADB server to switch the connection to either the device or emulator connect to/running on the host. Will fail if there is more than one such device/emulator available.

adb_client/src/server_device/commands/uninstall.rs

@@ -1,13 +1,11 @@
 use std::io::Read;
 
-use crate::{models::AdbServerCommand, server_device::ADBServerDevice, Result};
+use crate::{Result, models::AdbServerCommand, server_device::ADBServerDevice};
 
 impl ADBServerDevice {
     /// Uninstall a package from device
     pub fn uninstall(&mut self, package_name: &str) -> Result<()> {
-        let serial: String = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
+        self.set_serial_transport()?;
 
         self.transport
             .send_adb_request(AdbServerCommand::Uninstall(package_name.to_string()))?;
@@ -17,7 +15,7 @@ impl ADBServerDevice {
 
         match &data[0..read_amount] {
             b"Success\n" => {
-                log::info!("Package {} successfully uninstalled", package_name);
+                log::info!("Package {package_name} successfully uninstalled");
                 Ok(())
             }
             d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(

adb_client/src/server_device/commands/usb.rs

@@ -1,12 +1,9 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Set adb daemon to usb mode
     pub fn usb(&mut self) -> Result<()> {
-        let serial = self.identifier.clone();
-        self.connect()?
-            .send_adb_request(AdbServerCommand::TransportSerial(serial))?;
-
+        self.set_serial_transport()?;
         self.transport
             .proxy_connection(AdbServerCommand::Usb, false)
             .map(|_| ())

adb_client/src/transports/tcp_emulator_transport.rs

@@ -7,7 +7,7 @@ use std::{
 use homedir::my_home;
 
 use super::ADBTransport;
-use crate::{emulator_device::ADBEmulatorCommand, Result, RustADBError};
+use crate::{Result, RustADBError, emulator_device::ADBEmulatorCommand};
 
 /// Emulator transport running on top on TCP.
 #[derive(Debug)]

adb_client/src/transports/tcp_server_transport.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use byteorder::{ByteOrder, LittleEndian};
 
 use crate::models::{AdbRequestStatus, SyncCommand};
-use crate::{models::AdbServerCommand, ADBTransport};
+use crate::{ADBTransport, models::AdbServerCommand};
 use crate::{Result, RustADBError};
 
 const DEFAULT_SERVER_IP: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
@@ -33,6 +33,14 @@ impl TCPServerTransport {
         }
     }
 
+    /// Instantiate a new instance of [TCPServerTransport] using given address, or default if not specified.
+    pub fn new_or_default(socket_addr: Option<SocketAddrV4>) -> Self {
+        match socket_addr {
+            Some(s) => Self::new(s),
+            None => Self::default(),
+        }
+    }
+
     /// Get underlying [SocketAddrV4]
     pub fn get_socketaddr(&self) -> SocketAddrV4 {
         self.socket_addr
@@ -91,13 +99,13 @@ impl TCPServerTransport {
     }
 
     /// Gets the body length from a LittleEndian value
-    pub(crate) fn get_body_length(&mut self) -> Result<u32> {
+    pub(crate) fn get_body_length(&self) -> Result<u32> {
         let length_buffer = self.read_body_length()?;
         Ok(LittleEndian::read_u32(&length_buffer))
     }
 
     /// Read 4 bytes representing body length
-    fn read_body_length(&mut self) -> Result<[u8; 4]> {
+    fn read_body_length(&self) -> Result<[u8; 4]> {
         let mut length_buffer = [0; 4];
         self.get_raw_connection()?.read_exact(&mut length_buffer)?;
 
@@ -113,6 +121,11 @@ impl TCPServerTransport {
         self.get_raw_connection()?
             .write_all(adb_request.as_bytes())?;
 
+        self.read_adb_response()
+    }
+
+    /// Read a response from ADB server
+    pub(crate) fn read_adb_response(&mut self) -> Result<()> {
         // Reads returned status code from ADB server
         let mut request_status = [0; 4];
         self.get_raw_connection()?.read_exact(&mut request_status)?;

adb_client/src/transports/tcp_transport.rs

@@ -1,16 +1,16 @@
 use rcgen::{CertificateParams, KeyPair, PKCS_RSA_SHA256};
 use rustls::{
-    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
-    pki_types::{pem::PemObject, CertificateDer, PrivatePkcs8KeyDer},
     ClientConfig, ClientConnection, KeyLogFile, SignatureScheme, StreamOwned,
+    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
+    pki_types::{CertificateDer, PrivatePkcs8KeyDer, pem::PemObject},
 };
 
 use super::{ADBMessageTransport, ADBTransport};
 use crate::{
-    device::{
-        get_default_adb_key_path, ADBTransportMessage, ADBTransportMessageHeader, MessageCommand,
-    },
     Result, RustADBError,
+    device::{
+        ADBTransportMessage, ADBTransportMessageHeader, MessageCommand, get_default_adb_key_path,
+    },
 };
 use std::{
     fs::read_to_string,
@@ -109,7 +109,7 @@ impl TcpTransport {
         })
     }
 
-    fn get_current_connection(&mut self) -> Result<Arc<Mutex<CurrentConnection>>> {
+    fn get_current_connection(&self) -> Result<Arc<Mutex<CurrentConnection>>> {
         self.current_connection
             .as_ref()
             .ok_or(RustADBError::IOError(std::io::Error::new(
@@ -125,7 +125,7 @@ impl TcpTransport {
             None => {
                 return Err(RustADBError::UpgradeError(
                     "cannot upgrade a non-existing connection...".into(),
-                ))
+                ));
             }
         };
 
@@ -162,7 +162,7 @@ impl TcpTransport {
                 CurrentConnection::Tls(_) => {
                     return Err(RustADBError::UpgradeError(
                         "cannot upgrade a TLS connection...".into(),
-                    ))
+                    ));
                 }
             }
         }
@@ -175,8 +175,7 @@ impl TcpTransport {
                 Ok(())
             }
             c => Err(RustADBError::ADBRequestFailed(format!(
-                "Wrong command received {}",
-                c
+                "Wrong command received {c}"
             ))),
         }
     }

adb_client/src/transports/traits/adb_message_transport.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use super::ADBTransport;
-use crate::{device::ADBTransportMessage, Result};
+use crate::{Result, device::ADBTransportMessage};
 
 const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(u64::MAX);
 const DEFAULT_WRITE_TIMEOUT: Duration = Duration::from_secs(2);

adb_client/src/transports/usb_transport.rs

@@ -1,20 +1,21 @@
 use std::{sync::Arc, time::Duration};
 
 use rusb::{
-    constants::LIBUSB_CLASS_VENDOR_SPEC, Device, DeviceHandle, Direction, GlobalContext,
-    TransferType,
+    Device, DeviceHandle, Direction, GlobalContext, TransferType,
+    constants::LIBUSB_CLASS_VENDOR_SPEC,
 };
 
 use super::{ADBMessageTransport, ADBTransport};
 use crate::{
-    device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
     Result, RustADBError,
+    device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
 };
 
 #[derive(Clone, Debug)]
 struct Endpoint {
     iface: u8,
     address: u8,
+    max_packet_size: usize,
 }
 
 /// Transport running on USB
@@ -39,8 +40,7 @@ impl USBTransport {
         }
 
         Err(RustADBError::DeviceNotFound(format!(
-            "cannot find USB device with vendor_id={} and product_id={}",
-            vendor_id, product_id
+            "cannot find USB device with vendor_id={vendor_id} and product_id={product_id}",
         )))
     }
 
@@ -111,6 +111,7 @@ impl USBTransport {
                             let endpoint = Endpoint {
                                 iface: interface_desc.interface_number(),
                                 address: endpoint_desc.address(),
+                                max_packet_size: endpoint_desc.max_packet_size() as usize,
                             };
                             match endpoint_desc.direction() {
                                 Direction::In => {
@@ -136,6 +137,29 @@ impl USBTransport {
 
         Err(RustADBError::USBNoDescriptorFound)
     }
+
+    fn write_bulk_data(&self, data: &[u8], timeout: Duration) -> Result<()> {
+        let endpoint = self.get_write_endpoint()?;
+        let handle = self.get_raw_connection()?;
+        let max_packet_size = endpoint.max_packet_size;
+
+        let mut offset = 0;
+        let data_len = data.len();
+        while offset < data_len {
+            let end = (offset + max_packet_size).min(data_len);
+            let write_amount = handle.write_bulk(endpoint.address, &data[offset..end], timeout)?;
+            offset += write_amount;
+
+            log::trace!("wrote chunk of size {write_amount} - {offset}/{data_len}",)
+        }
+
+        if offset % max_packet_size == 0 {
+            log::trace!("must send final zero-length packet");
+            handle.write_bulk(endpoint.address, &[], timeout)?;
+        }
+
+        Ok(())
+    }
 }
 
 impl ADBTransport for USBTransport {
@@ -145,9 +169,11 @@ impl ADBTransport for USBTransport {
         let (read_endpoint, write_endpoint) = self.find_endpoints(&device)?;
 
         Self::configure_endpoint(&device, &read_endpoint)?;
+        log::debug!("got read endpoint: {read_endpoint:?}");
         self.read_endpoint = Some(read_endpoint);
 
         Self::configure_endpoint(&device, &write_endpoint)?;
+        log::debug!("got write endpoint: {write_endpoint:?}");
         self.write_endpoint = Some(write_endpoint);
 
         self.handle = Some(Arc::new(device));
@@ -157,7 +183,21 @@ impl ADBTransport for USBTransport {
 
     fn disconnect(&mut self) -> crate::Result<()> {
         let message = ADBTransportMessage::new(MessageCommand::Clse, 0, 0, &[]);
-        self.write_message(message)
+        if let Err(e) = self.write_message(message) {
+            log::error!("error while sending CLSE message: {e}");
+        }
+
+        if let Some(handle) = &self.handle {
+            let endpoint = self.read_endpoint.as_ref().or(self.write_endpoint.as_ref());
+            if let Some(endpoint) = &endpoint {
+                match handle.release_interface(endpoint.iface) {
+                    Ok(()) => log::debug!("succesfully released interface"),
+                    Err(e) => log::error!("error while release interface: {e}"),
+                }
+            }
+        }
+
+        Ok(())
     }
 }
 
@@ -167,29 +207,15 @@ impl ADBMessageTransport for USBTransport {
         message: ADBTransportMessage,
         timeout: Duration,
     ) -> Result<()> {
-        let endpoint = self.get_write_endpoint()?;
-        let handle = self.get_raw_connection()?;
-
         let message_bytes = message.header().as_bytes()?;
-        let mut total_written = 0;
-        loop {
-            total_written +=
-                handle.write_bulk(endpoint.address, &message_bytes[total_written..], timeout)?;
-            if total_written == message_bytes.len() {
-                break;
-            }
-        }
+        self.write_bulk_data(&message_bytes, timeout)?;
+
+        log::trace!("successfully write header: {} bytes", message_bytes.len());
 
         let payload = message.into_payload();
         if !payload.is_empty() {
-            let mut total_written = 0;
-            loop {
-                total_written +=
-                    handle.write_bulk(endpoint.address, &payload[total_written..], timeout)?;
-                if total_written == payload.len() {
-                    break;
-                }
-            }
+            self.write_bulk_data(&payload, timeout)?;
+            log::trace!("successfully write payload: {} bytes", payload.len());
         }
 
         Ok(())
@@ -198,29 +224,26 @@ impl ADBMessageTransport for USBTransport {
     fn read_message_with_timeout(&mut self, timeout: Duration) -> Result<ADBTransportMessage> {
         let endpoint = self.get_read_endpoint()?;
         let handle = self.get_raw_connection()?;
+        let max_packet_size = endpoint.max_packet_size;
 
-        let mut data = [0; 24];
-        let mut total_read = 0;
-        loop {
-            total_read += handle.read_bulk(endpoint.address, &mut data[total_read..], timeout)?;
-            if total_read == data.len() {
-                break;
-            }
+        let mut data = [0u8; 24];
+        let mut offset = 0;
+        while offset < data.len() {
+            let end = (offset + max_packet_size).min(data.len());
+            let chunk = &mut data[offset..end];
+            offset += handle.read_bulk(endpoint.address, chunk, timeout)?;
         }
 
         let header = ADBTransportMessageHeader::try_from(data)?;
-
         log::trace!("received header {header:?}");
 
         if header.data_length() != 0 {
             let mut msg_data = vec![0_u8; header.data_length() as usize];
-            let mut total_read = 0;
-            loop {
-                total_read +=
-                    handle.read_bulk(endpoint.address, &mut msg_data[total_read..], timeout)?;
-                if total_read == msg_data.capacity() {
-                    break;
-                }
+            let mut offset = 0;
+            while offset < msg_data.len() {
+                let end = (offset + max_packet_size).min(msg_data.len());
+                let chunk = &mut msg_data[offset..end];
+                offset += handle.read_bulk(endpoint.address, chunk, timeout)?;
             }
 
             let message = ADBTransportMessage::from_header_and_payload(header, msg_data);

adb_client/src/utils.rs

@@ -12,5 +12,7 @@ pub fn check_extension_is_apk<P: AsRef<Path>>(path: P) -> Result<()> {
         }
     }
 
+    log::debug!("Given file is an APK");
+
     Ok(())
 }

benches/benchmark_adb_push.rs

@@ -1,7 +1,7 @@
 use adb_client::ADBServer;
 use anyhow::Result;
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use rand::{rng, Rng};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use rand::{Rng, rng};
 use std::fs::File;
 use std::io::Write;
 use std::process::Command;

pyadb_client/Cargo.toml

@@ -1,26 +1,27 @@
 [package]
-name = "pyadb_client"
-description = "Python wrapper for adb_client library"
 authors.workspace = true
+description = "Python wrapper for adb_client library"
 edition.workspace = true
 homepage.workspace = true
 keywords.workspace = true
 license.workspace = true
+name = "pyadb_client"
+readme = "README.md"
 repository.workspace = true
 version.workspace = true
-readme = "README.md"
+rust-version.workspace = true
 
 [lib]
-name = "pyadb_client"
 crate-type = ["cdylib", "rlib"]
+name = "pyadb_client"
 
 [[bin]]
-name = "stub_gen"
 doc = false
+name = "stub_gen"
 
 [dependencies]
+adb_client = { path = "../adb_client" }
 anyhow = { version = "1.0.95" }
-adb_client = { version = "2.1.5" }
-pyo3 = { version = "0.23.4", features = ["extension-module", "anyhow", "abi3-py37"] }
+pyo3 = { version = "0.25.0", features = ["abi3-py37", "anyhow"] }
 pyo3-stub-gen = "0.7.0"
-pyo3-stub-gen-derive = "0.7.0"
+pyo3-stub-gen-derive = "0.7.0"

pyadb_client/README.md

@@ -1,6 +1,16 @@
 # pyadb_client
 
-Python library to communicate with ADB devices. Built on top of Rust `adb_client` library.
+<p align="center">
+    <p align="center">Python library to communicate with ADB devices. Built on top of Rust adb_client library.</p>
+    <p align="center">
+        <a href="https://pypi.org/project/pyadb_client">
+            <img alt="pypi.org" src="https://img.shields.io/pypi/v/pyadb_client.svg" />
+        </a>
+        <a href="https://pypi.org/project/pyadb_client">
+            <img alt="downloads" src="https://static.pepy.tech/badge/pyadb_client" />
+        </a>
+    </p>
+</p>
 
 ## Installation
 
@@ -37,7 +47,6 @@ usb_device.push("file.txt", "/data/local/tmp/file.txt")
 
 ```bash
 # Create Python virtual environment
-cd pyadb_client
 python3 -m venv .venv
 source .venv/bin/activate
 

pyadb_client/src/adb_server.rs

@@ -2,7 +2,7 @@ use std::net::SocketAddrV4;
 
 use adb_client::ADBServer;
 use anyhow::Result;
-use pyo3::{pyclass, pymethods, PyResult};
+use pyo3::{PyResult, pyclass, pymethods};
 use pyo3_stub_gen_derive::{gen_stub_pyclass, gen_stub_pymethods};
 
 use crate::{PyADBServerDevice, PyDeviceShort};

pyadb_client/src/adb_server_device.rs

@@ -14,7 +14,7 @@ pub struct PyADBServerDevice(pub ADBServerDevice);
 impl PyADBServerDevice {
     #[getter]
     /// Device identifier
-    pub fn identifier(&self) -> String {
+    pub fn identifier(&self) -> Option<String> {
         self.0.identifier.clone()
     }
 

tests/tests.rs

@@ -1,98 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use std::io::Cursor;
-
-    use adb_client::{ADBServer, ADBServerDevice, DeviceLong};
-    use rand::Rng;
-
-    fn new_client() -> ADBServer {
-        ADBServer::default()
-    }
-
-    fn new_device() -> ADBServerDevice {
-        let mut client = new_client();
-        return client.get_device().expect("cannot get device");
-    }
-
-    #[test]
-    fn test_version() {
-        let mut adb = new_client();
-        adb.version().expect("cannot get adb version");
-    }
-
-    #[test]
-    fn test_shell_commands() {
-        let mut device = new_device();
-
-        device.shell_command(["ls"]).expect("error while executing `ls` command");
-        device.shell_command(["pwd"]).expect("error while executing `pwd` command");
-    }
-
-    #[test]
-    fn test_devices() {
-        let mut adb = new_client();
-        adb.devices().expect("cannot list devices");
-    }
-
-    #[test]
-    fn test_devices_long() {
-        let mut adb = new_client();
-        adb.devices_long().expect("cannot list devices long");
-    }
-
-    #[test]
-    fn test_static_devices_long() {
-        let inputs = ["7a5158f05122195aa       device 1-5 product:gts210vewifixx model:SM_T813 device:gts210vewifi transport_id:4"];
-        for input in inputs {
-            DeviceLong::try_from(input.as_bytes().to_vec())
-                .expect(&format!("cannot parse input: '{input}'"));
-        }
-    }
-
-    #[test]
-    fn test_send_recv() {
-        // Create random "Reader" in memory
-        let mut key = [0u8; 1000];
-        rand::thread_rng().fill(&mut key[..]);
-        let mut c: Cursor<Vec<u8>> = Cursor::new(key.to_vec());
-
-        let mut device = new_device();
-
-        const TEST_FILENAME: &'static str = "/data/local/tmp/test_file";
-        // Send it
-        device
-            .send(&mut c, TEST_FILENAME)
-            .expect("cannot send file");
-
-        // Pull it to memory
-        let mut res = vec![];
-        device
-            .recv(TEST_FILENAME, &mut res)
-            .expect("cannot recv file");
-
-        // diff
-        assert_eq!(c.get_ref(), &res);
-
-        device
-            .shell_command::<&str>([format!("rm {TEST_FILENAME}").as_str()])
-            .expect("cannot remove test file");
-    }
-
-    #[test]
-    fn multiple_connexions() {
-        let mut connection = new_client();
-
-        for _ in 0..2 {
-            let _ = connection.devices().expect("cannot get version");
-        }
-    }
-
-    #[test]
-    fn command_emulator() {
-        let mut connection = new_client();
-        let mut emulator = connection
-            .get_emulator_device()
-            .expect("no emulator running");
-        emulator.hello().expect("cannot hello");
-    }
-}