feat: make search_adb_devices and is_adb_device public

.github/workflows/python-build.yml

@@ -35,4 +35,4 @@ jobs:
         with:
           files: |
             target/wheels/pyadb_client*.whl
-            target/wheels/pyadb_client*.tar.gz
+            target/wheels/pyadb_client*.tar.gz

.github/workflows/rust-build.yml

@@ -18,6 +18,6 @@ jobs:
         os: [ubuntu-latest, windows-latest, macos-latest]
 
     steps:
-      - uses: actions/checkout@v4
-      - name: Build project
-        run: cargo build --release --all-features
+    - uses: actions/checkout@v4
+    - name: Build project
+      run: cargo build --release --all-features

.gitignore

@@ -3,4 +3,4 @@ target
 /.vscode
 venv
 /.mypy_cache
-pyadb_client/pyadb_client.pyi
+pyadb_client/pyadb_client.pyi

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["adb_cli", "adb_client", "examples/mdns", "pyadb_client"]
+members = ["adb_cli", "adb_client", "pyadb_client"]
 resolver = "2"
 
 [workspace.package]
@@ -9,8 +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.16"
-rust-version = "1.85.1"
+version = "2.1.14"
 
 # To build locally when working on a new release
 [patch.crates-io]

README.md

@@ -8,9 +8,6 @@
         <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>
@@ -49,12 +46,6 @@ Provides a "real-world" usage example of this library.
 
 Improved documentation available [here](./adb_cli/README.md).
 
-## examples
-
-Some examples are available in the `examples` directory:
-
-- `examples/mdns`: mDNS device discovery example
-
 ## pyadb_client
 
 Python wrapper using `adb_client` library to export classes usable directly from a Python environment.

adb_cli/Cargo.toml

@@ -7,11 +7,10 @@ license.workspace = true
 name = "adb_cli"
 readme = "README.md"
 repository.workspace = true
-rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-adb_client = { version = "^2.0.0", features = ["mdns", "usb"] }
+adb_client = { version = "^2.0.0" }
 anyhow = { version = "1.0.94" }
 clap = { version = "4.5.23", features = ["derive"] }
 env_logger = { version = "0.11.5" }

adb_cli/README.md

@@ -2,7 +2,6 @@
 
 [![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.
 
@@ -11,7 +10,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`:
@@ -65,4 +64,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/handlers/emulator_commands.rs

@@ -1,4 +1,4 @@
-use adb_client::emulator::ADBEmulatorDevice;
+use adb_client::ADBEmulatorDevice;
 
 use crate::models::{EmuCommand, EmulatorCommand};
 

adb_cli/src/handlers/host_commands.rs

@@ -1,7 +1,4 @@
-use adb_client::{
-    Result,
-    server::{ADBServer, DeviceShort, MDNSBackend, WaitForDeviceState},
-};
+use adb_client::{ADBServer, DeviceShort, MDNSBackend, Result, WaitForDeviceState};
 
 use crate::models::{HostCommand, MdnsCommand, ServerCommand};
 
@@ -11,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 => {
@@ -21,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");
@@ -68,7 +65,7 @@ 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);
                 }
             }
         },

adb_cli/src/handlers/local_commands.rs

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

adb_cli/src/main.rs

@@ -7,12 +7,9 @@ mod handlers;
 mod models;
 mod utils;
 
-use adb_client::ADBDeviceExt;
-use adb_client::mdns::MDNSDiscoveryService;
-use adb_client::server::ADBServer;
-use adb_client::server_device::ADBServerDevice;
-use adb_client::tcp::ADBTcpDevice;
-use adb_client::usb::ADBUSBDevice;
+use adb_client::{
+    ADBDeviceExt, ADBServer, ADBServerDevice, ADBTcpDevice, ADBUSBDevice, MDNSDiscoveryService,
+};
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use adb_termios::ADBTermios;
@@ -135,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 } => {
@@ -155,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,6 +1,6 @@
 use std::net::SocketAddrV4;
 
-use adb_client::{RustADBError, server::WaitForDeviceTransport};
+use adb_client::{RustADBError, WaitForDeviceTransport};
 use clap::Parser;
 
 fn parse_wait_for_device_device_transport(

adb_client/Cargo.toml

@@ -7,18 +7,8 @@ license.workspace = true
 name = "adb_client"
 readme = "README.md"
 repository.workspace = true
-rust-version.workspace = true
 version.workspace = true
 
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[features]
-default = []
-mdns = ["dep:mdns-sd"]
-usb = ["dep:rsa", "dep:rusb"]
-
 [dependencies]
 base64 = { version = "0.22.1" }
 bincode = { version = "1.3.3" }
@@ -27,6 +17,9 @@ 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" }
@@ -36,6 +29,8 @@ rcgen = { version = "0.13.1", default-features = false, features = [
     "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.27" }
 rustls-pki-types = { version = "1.11.0" }
 serde = { version = "1.0.216", features = ["derive"] }
@@ -43,18 +38,6 @@ serde_repr = { version = "0.1.19" }
 sha1 = { version = "0.10.6", features = ["oid"] }
 thiserror = { version = "2.0.7" }
 
-#########
-# MDNS-only dependencies
-mdns-sd = { version = "0.13.9", default-features = false, features = [
-    "logging",
-], optional = true }
-#########
-#########
-# USB-only dependencies
-rsa = { version = "0.9.7", optional = true }
-rusb = { version = "0.9.4", features = ["vendored"], optional = true }
-#########
-
 [dev-dependencies]
 anyhow = { version = "1.0.93" }
 criterion = { version = "0.6.0" } # Used for benchmarks

adb_client/README.md

@@ -3,7 +3,6 @@
 [![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.
 
@@ -16,26 +15,6 @@ Add `adb_client` crate as a dependency by simply adding it to your `Cargo.toml`:
 adb_client = "*"
 ```
 
-## Crate features
-
-| Feature |                   Description                   | Default? |
-| :-----: | :---------------------------------------------: | :------: |
-| `mdns`  | Enables mDNS device discovery on local network. |    No    |
-|  `usb`  |     Enables interactions with USB devices.      |    No    |
-
-To deactivate some features you can use the `default-features = false` option in your `Cargo.toml` file and manually specify the features you want to activate:
-
-```toml
-[dependencies]
-adb_client = { version = "*" }
-```
-
-## Examples
-
-Usage examples can be found in the `examples/` directory of this repository.
-
-Some example are also provided in the various `README.md` files of modules.
-
 ## Benchmarks
 
 Benchmarks run on `v2.0.6`, on a **Samsung S10 SM-G973F** device and an **Intel i7-1265U** CPU laptop
@@ -44,8 +23,89 @@ Benchmarks run on `v2.0.6`, on a **Samsung S10 SM-G973F** device and an **Intel
 
 `ADBServerDevice` performs all operations by using adb server as a bridge.
 
-| File size | Sample size | `ADBServerDevice` |   `adb`   |               Difference               |
-| :-------: | :---------: | :---------------: | :-------: | :------------------------------------: |
-|   10 MB   |     100     |     350,79 ms     | 356,30 ms | <div style="color:green">-1,57 %</div> |
-|  500 MB   |     50      |      15,60 s      |  15,64 s  | <div style="color:green">-0,25 %</div> |
-|   1 GB    |     20      |      31,09 s      |  31,12 s  | <div style="color:green">-0,10 %</div> |
+|File size|Sample size|`ADBServerDevice`|`adb`|Difference|
+|:-------:|:---------:|:----------:|:---:|:-----:|
+|10 MB|100|350,79 ms|356,30 ms|<div style="color:green">-1,57 %</div>|
+|500 MB|50|15,60 s|15,64 s|<div style="color:green">-0,25 %</div>|
+|1 GB|20|31,09 s|31,12 s|<div style="color:green">-0,10 %</div>|
+
+## Examples
+
+### Get available ADB devices
+
+```rust no_run
+use adb_client::ADBServer;
+use std::net::{SocketAddrV4, Ipv4Addr};
+
+// A custom server address can be provided
+let server_ip = Ipv4Addr::new(127, 0, 0, 1);
+let server_port = 5037;
+
+let mut server = ADBServer::new(SocketAddrV4::new(server_ip, server_port));
+server.devices();
+```
+
+### Using ADB server as bridge
+
+#### Launch a command on device
+
+```rust no_run
+use adb_client::{ADBServer, ADBDeviceExt};
+
+let mut server = ADBServer::default();
+let mut device = server.get_device().expect("cannot get device");
+device.shell_command(&["df", "-h"], &mut std::io::stdout());
+```
+
+#### Push a file to the device
+
+```rust no_run
+use adb_client::ADBServer;
+use std::net::Ipv4Addr;
+use std::fs::File;
+use std::path::Path;
+
+let mut server = ADBServer::default();
+let mut device = server.get_device().expect("cannot get device");
+let mut input = File::open(Path::new("/tmp/f")).expect("Cannot open file");
+device.push(&mut input, "/data/local/tmp");
+```
+
+### Interact directly with end devices
+
+#### (USB) Launch a command on device
+
+```rust no_run
+use adb_client::{ADBUSBDevice, ADBDeviceExt};
+
+let vendor_id = 0x04e8;
+let product_id = 0x6860;
+let mut device = ADBUSBDevice::new(vendor_id, product_id).expect("cannot find device");
+device.shell_command(&["df", "-h"], &mut std::io::stdout());
+```
+
+#### (USB) Push a file to the device
+
+```rust no_run
+use adb_client::{ADBUSBDevice, ADBDeviceExt};
+use std::fs::File;
+use std::path::Path;
+
+let vendor_id = 0x04e8;
+let product_id = 0x6860;
+let mut device = ADBUSBDevice::new(vendor_id, product_id).expect("cannot find device");
+let mut input = File::open(Path::new("/tmp/f")).expect("Cannot open file");
+device.push(&mut input, &"/data/local/tmp");
+```
+
+#### (TCP) Get a shell from device
+
+```rust no_run
+use std::net::{SocketAddr, IpAddr, Ipv4Addr};
+use adb_client::{ADBTcpDevice, ADBDeviceExt};
+
+let device_ip = IpAddr::V4(Ipv4Addr::new(192, 168, 0, 10));
+let device_port = 43210;
+let mut device = ADBTcpDevice::new(SocketAddr::new(device_ip, device_port)).expect("cannot find device");
+device.shell(&mut std::io::stdin(), Box::new(std::io::stdout()));
+```

adb_client/src/adb_device_ext.rs

@@ -6,14 +6,14 @@ use image::{ImageBuffer, ImageFormat, Rgba};
 use crate::models::AdbStatResponse;
 use crate::{RebootType, Result};
 
-/// Trait representing all features available on both [`crate::server_device::ADBServerDevice`] and [`crate::usb::ADBUSBDevice`]
+/// Trait representing all features available on both [`crate::ADBServerDevice`] and [`crate::ADBUSBDevice`]
 pub trait ADBDeviceExt {
     /// Runs command in a shell on the device, and write its output and error streams into output.
     fn shell_command(&mut self, command: &[&str], output: &mut dyn Write) -> Result<()>;
 
     /// Starts an interactive shell session on the device.
     /// Input data is read from reader and write to writer.
-    fn shell(&mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>) -> Result<()>;
+    fn shell(&mut self, reader: &mut dyn Read, writer: Box<(dyn Write + Send)>) -> Result<()>;
 
     /// Display the stat information for a remote file
     fn stat(&mut self, remote_path: &str) -> Result<AdbStatResponse>;

adb_client/src/constants.rs

@@ -0,0 +1 @@
+pub const BUFFER_SIZE: usize = 65536;

adb_client/src/device/adb_message_device.rs

@@ -2,16 +2,9 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use rand::Rng;
 use std::io::{Cursor, Read, Seek};
 
-use crate::{
-    AdbStatResponse, Result, RustADBError,
-    message_devices::{
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage,
-        message_commands::{MessageCommand, MessageSubcommand},
-    },
-};
+use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};
 
-const BUFFER_SIZE: usize = 65535;
+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.
@@ -151,7 +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,21 +1,17 @@
-use crate::{
-    ADBDeviceExt, RebootType, Result,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-    },
-    models::AdbStatResponse,
-};
+use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};
 use std::{
     io::{Read, Write},
     path::Path,
 };
 
+use super::ADBMessageDevice;
+
 impl<T: ADBMessageTransport> ADBDeviceExt for ADBMessageDevice<T> {
     fn shell_command(&mut self, command: &[&str], output: &mut dyn Write) -> Result<()> {
         self.shell_command(command, output)
     }
 
-    fn shell(&mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>) -> Result<()> {
+    fn shell(&mut self, reader: &mut dyn Read, writer: Box<(dyn Write + Send)>) -> Result<()> {
         self.shell(reader, writer)
     }
 

adb_client/src/device/adb_tcp_device.rs

@@ -2,12 +2,10 @@ use std::io::Write;
 use std::path::Path;
 use std::{io::Read, net::SocketAddr};
 
-use crate::message_devices::adb_message_device::ADBMessageDevice;
-use crate::message_devices::adb_message_transport::ADBMessageTransport;
-use crate::message_devices::adb_transport_message::ADBTransportMessage;
-use crate::message_devices::message_commands::MessageCommand;
-use crate::tcp::tcp_transport::TcpTransport;
-use crate::{ADBDeviceExt, ADBTransport, Result};
+use super::ADBTransportMessage;
+use super::adb_message_device::ADBMessageDevice;
+use super::models::MessageCommand;
+use crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, TcpTransport};
 
 /// Represent a device reached and available over USB.
 #[derive(Debug)]
@@ -77,7 +75,7 @@ impl ADBDeviceExt for ADBTcpDevice {
     }
 
     #[inline]
-    fn shell(&mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>) -> Result<()> {
+    fn shell(&mut self, reader: &mut dyn Read, writer: Box<(dyn Write + Send)>) -> Result<()> {
         self.inner.shell(reader, writer)
     }
 

adb_client/src/device/adb_transport_message.rs

@@ -1,6 +1,12 @@
 use serde::{Deserialize, Serialize};
 
-use crate::{Result, RustADBError, message_devices::message_commands::MessageCommand};
+use crate::{Result, RustADBError};
+
+use super::models::MessageCommand;
+
+pub const AUTH_TOKEN: u32 = 1;
+pub const AUTH_SIGNATURE: u32 = 2;
+pub const AUTH_RSAPUBLICKEY: u32 = 3;
 
 #[derive(Debug)]
 pub struct ADBTransportMessage {

adb_client/src/device/adb_usb_device.rs

@@ -9,37 +9,25 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
 
+use super::adb_message_device::ADBMessageDevice;
+use super::models::MessageCommand;
+use super::{ADBRsaKey, ADBTransportMessage};
 use crate::ADBDeviceExt;
-use crate::Result;
-use crate::RustADBError;
-use crate::adb_transport::ADBTransport;
-use crate::message_devices::adb_message_device::ADBMessageDevice;
-use crate::message_devices::adb_message_transport::ADBMessageTransport;
-use crate::message_devices::adb_transport_message::ADBTransportMessage;
-use crate::message_devices::message_commands::MessageCommand;
-use crate::usb::adb_rsa_key::ADBRsaKey;
-use crate::usb::usb_transport::USBTransport;
-use crate::utils::get_default_adb_key_path;
-
-const AUTH_TOKEN: u32 = 1;
-const AUTH_SIGNATURE: u32 = 2;
-const AUTH_RSAPUBLICKEY: u32 = 3;
+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>> {
-    // 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),
-    }
+    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
+            }
+        }
+    })?)
 }
 
 /// Search for adb devices with known interface class and subclass values
@@ -63,7 +51,8 @@ pub 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 {vid1:04x}:{pid1:04x} and {vid2:04x}:{pid2:04x}",
+            "Found two Android devices {:04x}:{:04x} and {:04x}:{:04x}",
+            vid1, pid1, vid2, pid2
         ))),
     }
 }
@@ -99,6 +88,14 @@ pub fn is_adb_device<T: UsbContext>(device: &Device<T>, des: &DeviceDescriptor)
     false
 }
 
+pub fn get_default_adb_key_path() -> Result<PathBuf> {
+    homedir::my_home()
+        .ok()
+        .flatten()
+        .map(|home| home.join(".android").join("adbkey"))
+        .ok_or(RustADBError::NoHomeDirectory)
+}
+
 /// Represent a device reached and available over USB.
 #[derive(Debug)]
 pub struct ADBUSBDevice {
@@ -138,15 +135,9 @@ 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 => {
-                log::warn!(
-                    "No private key found at path {}. Using a temporary random one.",
-                    private_key_path.display()
-                );
-                ADBRsaKey::new_random()?
-            }
+            None => ADBRsaKey::new_random()?,
         };
 
         let mut s = Self {
@@ -259,7 +250,7 @@ impl ADBDeviceExt for ADBUSBDevice {
     }
 
     #[inline]
-    fn shell<'a>(&mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>) -> Result<()> {
+    fn shell<'a>(&mut self, reader: &mut dyn Read, writer: Box<(dyn Write + Send)>) -> Result<()> {
         self.inner.shell(reader, writer)
     }
 

adb_client/src/device/commands/framebuffer.rs

@@ -4,11 +4,8 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use image::{ImageBuffer, Rgba};
 
 use crate::{
-    Result, RustADBError,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        message_commands::MessageCommand,
-    },
+    ADBMessageTransport, Result, RustADBError,
+    device::{MessageCommand, adb_message_device::ADBMessageDevice},
     models::{FrameBufferInfoV1, FrameBufferInfoV2},
 };
 

adb_client/src/device/commands/install.rs

@@ -1,11 +1,8 @@
 use std::{fs::File, path::Path};
 
 use crate::{
-    Result,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        commands::utils::MessageWriter,
-    },
+    ADBMessageTransport, Result,
+    device::{MessageWriter, adb_message_device::ADBMessageDevice},
     utils::check_extension_is_apk,
 };
 
@@ -17,7 +14,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
 
         let file_size = apk_file.metadata()?.len();
 
-        self.open_session(format!("exec:cmd package 'install' -S {file_size}\0").as_bytes())?;
+        self.open_session(format!("exec:cmd package 'install' -S {}\0", file_size).as_bytes())?;
 
         let transport = self.get_transport().clone();
 

adb_client/src/device/commands/mod.rs

@@ -6,4 +6,3 @@ mod reboot;
 mod shell;
 mod stat;
 mod uninstall;
-mod utils;

adb_client/src/device/commands/pull.rs

@@ -1,12 +1,10 @@
 use std::io::Write;
 
 use crate::{
-    Result, RustADBError,
-    message_devices::{
-        adb_message_device::ADBMessageDevice,
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage,
-        message_commands::{MessageCommand, MessageSubcommand},
+    ADBMessageTransport, Result, RustADBError,
+    device::{
+        ADBTransportMessage, MessageCommand, adb_message_device::ADBMessageDevice,
+        models::MessageSubcommand,
     },
 };
 

adb_client/src/device/commands/push.rs

@@ -1,12 +1,10 @@
 use std::io::Read;
 
 use crate::{
-    Result, RustADBError,
-    message_devices::{
+    ADBMessageTransport, Result, RustADBError,
+    device::{
+        ADBTransportMessage, MessageCommand, MessageSubcommand,
         adb_message_device::ADBMessageDevice,
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage,
-        message_commands::{MessageCommand, MessageSubcommand},
     },
 };
 

adb_client/src/device/commands/reboot.rs

@@ -1,14 +1,11 @@
 use crate::{
-    RebootType, Result,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        message_commands::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:{reboot_type}\0").as_bytes())?;
+        self.open_session(format!("reboot:{}\0", reboot_type).as_bytes())?;
 
         self.get_transport_mut()
             .read_message()

adb_client/src/device/commands/shell.rs

@@ -1,12 +1,10 @@
 use std::io::{ErrorKind, Read, Write};
 
+use crate::Result;
+use crate::device::ShellMessageWriter;
 use crate::{
-    Result, RustADBError,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage, commands::utils::ShellMessageWriter,
-        message_commands::MessageCommand,
-    },
+    ADBMessageTransport, RustADBError,
+    device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
@@ -38,7 +36,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn shell(
         &mut self,
         mut reader: &mut dyn Read,
-        mut writer: Box<dyn Write + Send>,
+        mut writer: Box<(dyn Write + Send)>,
     ) -> Result<()> {
         self.open_session(b"shell:\0")?;
 

adb_client/src/device/commands/stat.rs

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

adb_client/src/device/commands/uninstall.rs

@@ -1,19 +1,14 @@
-use crate::{
-    Result,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-    },
-};
+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' {package_name}\0").as_bytes())?;
+        self.open_session(format!("exec:cmd package 'uninstall' {}\0", package_name).as_bytes())?;
 
         let final_status = self.get_transport_mut().read_message()?;
 
         match final_status.into_payload().as_slice() {
             b"Success\n" => {
-                log::info!("Package {package_name} successfully uninstalled");
+                log::info!("Package {} successfully uninstalled", package_name);
                 Ok(())
             }
             d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(

adb_client/src/device/message_writer.rs

@@ -1,9 +1,8 @@
 use std::io::{Error, ErrorKind, Result, Write};
 
-use crate::message_devices::{
-    adb_message_transport::ADBMessageTransport, adb_transport_message::ADBTransportMessage,
-    message_commands::MessageCommand,
-};
+use crate::ADBMessageTransport;
+
+use super::{ADBTransportMessage, MessageCommand};
 
 /// [`Write`] trait implementation to hide underlying ADB protocol write logic.
 ///

adb_client/src/device/mod.rs

@@ -0,0 +1,19 @@
+mod adb_message_device;
+mod adb_message_device_commands;
+mod adb_tcp_device;
+mod adb_transport_message;
+mod adb_usb_device;
+mod commands;
+mod message_writer;
+mod models;
+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, 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/mod.rs

@@ -0,0 +1,5 @@
+mod adb_rsa_key;
+mod message_commands;
+
+pub use adb_rsa_key::ADBRsaKey;
+pub use message_commands::{MessageCommand, MessageSubcommand};

adb_client/src/device/shell_message_writer.rs

@@ -1,9 +1,8 @@
 use std::io::Write;
 
-use crate::message_devices::{
-    adb_message_transport::ADBMessageTransport, adb_transport_message::ADBTransportMessage,
-    message_commands::MessageCommand,
-};
+use crate::ADBMessageTransport;
+
+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

@@ -3,10 +3,7 @@ use std::{
     sync::LazyLock,
 };
 
-use crate::{
-    ADBTransport, Result, RustADBError, emulator::tcp_emulator_transport::TCPEmulatorTransport,
-    server_device::ADBServerDevice,
-};
+use crate::{ADBServerDevice, ADBTransport, Result, RustADBError, TCPEmulatorTransport};
 use regex::Regex;
 
 static EMULATOR_REGEX: LazyLock<Regex> = LazyLock::new(|| {
@@ -33,7 +30,8 @@ impl ADBEmulatorDevice {
         let groups = EMULATOR_REGEX
             .captures(&identifier)
             .ok_or(RustADBError::DeviceNotFound(format!(
-                "Device {identifier} is likely not an emulator"
+                "Device {} is likely not an emulator",
+                identifier
             )))?;
 
         let port = groups

adb_client/src/emulator_device/commands/rotate.rs

@@ -1,7 +1,4 @@
-use crate::{
-    Result,
-    emulator::{ADBEmulatorCommand, ADBEmulatorDevice},
-};
+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,7 +1,4 @@
-use crate::{
-    Result,
-    emulator::{ADBEmulatorCommand, ADBEmulatorDevice},
-};
+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/mod.rs

@@ -1,7 +1,5 @@
 mod adb_emulator_device;
 mod commands;
 mod models;
-mod tcp_emulator_transport;
-
 pub use adb_emulator_device::ADBEmulatorDevice;
-use models::ADBEmulatorCommand;
+pub(crate) use models::ADBEmulatorCommand;

adb_client/src/error.rs

@@ -67,8 +67,6 @@ pub enum RustADBError {
     #[error("Cannot get home directory")]
     NoHomeDirectory,
     /// Generic USB error
-    #[cfg(feature = "usb")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "usb")))]
     #[error("USB Error: {0}")]
     UsbError(#[from] rusb::Error),
     /// USB device not found
@@ -87,8 +85,6 @@ pub enum RustADBError {
     #[error(transparent)]
     Base64EncodeError(#[from] base64::EncodeSliceError),
     /// An error occurred with RSA engine
-    #[cfg(feature = "usb")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "usb")))]
     #[error(transparent)]
     RSAError(#[from] rsa::errors::Error),
     /// Cannot convert given data from slice
@@ -98,8 +94,6 @@ pub enum RustADBError {
     #[error("wrong file extension: {0}")]
     WrongFileExtension(String),
     /// An error occurred with PKCS8 data
-    #[cfg(feature = "usb")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "usb")))]
     #[error("error with pkcs8: {0}")]
     RsaPkcs8Error(#[from] rsa::pkcs8::Error),
     /// Error during certificate generation
@@ -118,13 +112,11 @@ pub enum RustADBError {
     #[error("upgrade error: {0}")]
     UpgradeError(String),
     /// An error occurred while getting mdns devices
-    #[cfg(feature = "mdns")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "mdns")))]
     #[error(transparent)]
     MDNSError(#[from] mdns_sd::Error),
     /// An error occurred while sending data to channel
-    #[error("error sending data to channel")]
-    SendError,
+    #[error(transparent)]
+    SendError(#[from] std::sync::mpsc::SendError<crate::MDNSDevice>),
     /// An unknown transport has been provided
     #[error("unknown transport: {0}")]
     UnknownTransport(String),

adb_client/src/lib.rs

@@ -3,34 +3,25 @@
 #![forbid(missing_debug_implementations)]
 #![forbid(missing_docs)]
 #![doc = include_str!("../README.md")]
-// Feature `doc_cfg` is currently only available on nightly.
-// It is activated when cfg `docsrs` is enabled.
-// Documentation can be build locally using:
-// `RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --no-deps --all-features`
-#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod adb_device_ext;
-mod adb_transport;
-/// Emulator-related definitions
-pub mod emulator;
+mod constants;
+mod device;
+mod emulator_device;
 mod error;
-mod message_devices;
+mod mdns;
 mod models;
-
-/// Server-related definitions
-pub mod server;
-
-/// Device reachable by the server related definitions
-pub mod server_device;
+mod server;
+mod server_device;
+mod transports;
 mod utils;
 
-/// MDNS-related definitions
-#[cfg(feature = "mdns")]
-#[cfg_attr(docsrs, doc(cfg(feature = "mdns")))]
-pub mod mdns;
-
 pub use adb_device_ext::ADBDeviceExt;
-use adb_transport::ADBTransport;
+pub use device::{ADBTcpDevice, ADBUSBDevice, is_adb_device, search_adb_devices};
+pub use emulator_device::ADBEmulatorDevice;
 pub use error::{Result, RustADBError};
-pub use message_devices::*;
-pub use models::{AdbStatResponse, HostFeatures, RebootType};
+pub use mdns::*;
+pub use models::{AdbStatResponse, RebootType};
+pub use server::*;
+pub use server_device::ADBServerDevice;
+pub use transports::*;

adb_client/src/mdns/mdns_discovery.rs

@@ -1,7 +1,7 @@
 use mdns_sd::{ServiceDaemon, ServiceEvent};
 use std::{sync::mpsc::Sender, thread::JoinHandle};
 
-use crate::{Result, RustADBError, mdns::MDNSDevice};
+use crate::{MDNSDevice, Result, RustADBError};
 
 const ADB_SERVICE_NAME: &str = "_adb-tls-connect._tcp.local.";
 
@@ -45,9 +45,9 @@ impl MDNSDiscoveryService {
                             continue;
                         }
                         ServiceEvent::ServiceResolved(service_info) => {
-                            return sender
-                                .send(MDNSDevice::from(service_info))
-                                .map_err(|_| RustADBError::SendError);
+                            if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
+                                return Err(e.into());
+                            }
                         }
                     }
                 }

adb_client/src/message_devices/commands/utils/mod.rs

@@ -1,4 +0,0 @@
-mod message_writer;
-mod shell_message_writer;
-pub use message_writer::MessageWriter;
-pub use shell_message_writer::ShellMessageWriter;

adb_client/src/message_devices/mod.rs

@@ -1,14 +0,0 @@
-/// USB-related definitions
-#[cfg(feature = "usb")]
-#[cfg_attr(docsrs, doc(cfg(feature = "usb")))]
-pub mod usb;
-
-/// Device reachable over TCP related definition
-pub mod tcp;
-
-mod adb_message_device;
-mod adb_message_device_commands;
-mod adb_message_transport;
-mod adb_transport_message;
-mod commands;
-mod message_commands;

adb_client/src/message_devices/tcp/README.md

@@ -1,13 +0,0 @@
-# Examples
-
-## Get a shell from device
-
-```rust no_run
-use std::net::{SocketAddr, IpAddr, Ipv4Addr};
-use adb_client::{tcp::ADBTcpDevice, ADBDeviceExt};
-
-let device_ip = IpAddr::V4(Ipv4Addr::new(192, 168, 0, 10));
-let device_port = 43210;
-let mut device = ADBTcpDevice::new(SocketAddr::new(device_ip, device_port)).expect("cannot find device");
-device.shell(&mut std::io::stdin(), Box::new(std::io::stdout()));
-```

adb_client/src/message_devices/tcp/mod.rs

@@ -1,6 +0,0 @@
-#![doc = include_str!("./README.md")]
-
-mod adb_tcp_device;
-mod tcp_transport;
-
-pub use adb_tcp_device::ADBTcpDevice;

adb_client/src/message_devices/usb/README.md

@@ -1,26 +0,0 @@
-# Examples
-
-## Launch a command on device
-
-```rust no_run
-use adb_client::{usb::ADBUSBDevice, ADBDeviceExt};
-
-let vendor_id = 0x04e8;
-let product_id = 0x6860;
-let mut device = ADBUSBDevice::new(vendor_id, product_id).expect("cannot find device");
-device.shell_command(&["df", "-h"], &mut std::io::stdout());
-```
-
-## Push a file to the device
-
-```rust no_run
-use adb_client::{usb::ADBUSBDevice, ADBDeviceExt};
-use std::fs::File;
-use std::path::Path;
-
-let vendor_id = 0x04e8;
-let product_id = 0x6860;
-let mut device = ADBUSBDevice::new(vendor_id, product_id).expect("cannot find device");
-let mut input = File::open(Path::new("/tmp/file.txt")).expect("Cannot open file");
-device.push(&mut input, &"/data/local/tmp");
-```

adb_client/src/message_devices/usb/mod.rs

@@ -1,8 +0,0 @@
-#![doc = include_str!("./README.md")]
-
-mod adb_rsa_key;
-mod adb_usb_device;
-mod usb_transport;
-
-pub use adb_usb_device::ADBUSBDevice;
-pub use usb_transport::USBTransport;

adb_client/src/models/adb_server_command.rs

@@ -1,10 +1,8 @@
 use std::fmt::Display;
 
-use crate::{
-    RebootType,
-    server::{WaitForDeviceState, WaitForDeviceTransport},
-};
+use crate::{WaitForDeviceState, WaitForDeviceTransport};
 
+use super::RebootType;
 use std::net::SocketAddrV4;
 
 pub(crate) enum AdbServerCommand {
@@ -65,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}")
             }

adb_client/src/models/host_features.rs

@@ -1,11 +1,8 @@
 use std::fmt::Display;
 
-/// Available host features.
 #[derive(Debug, PartialEq)]
 pub enum HostFeatures {
-    /// Shell version 2.
     ShellV2,
-    /// Command.
     Cmd,
 }
 

adb_client/src/models/mod.rs

@@ -1,13 +1,15 @@
 mod adb_request_status;
+mod adb_server_command;
 mod adb_stat_response;
 mod framebuffer_info;
 mod host_features;
 mod reboot_type;
 mod sync_command;
 
-pub(crate) use adb_request_status::AdbRequestStatus;
+pub use adb_request_status::AdbRequestStatus;
+pub(crate) use adb_server_command::AdbServerCommand;
 pub use adb_stat_response::AdbStatResponse;
 pub(crate) use framebuffer_info::{FrameBufferInfoV1, FrameBufferInfoV2};
 pub use host_features::HostFeatures;
 pub use reboot_type::RebootType;
-pub(crate) use sync_command::SyncCommand;
+pub use sync_command::SyncCommand;

adb_client/src/server/README.md

@@ -1,15 +0,0 @@
-# Examples
-
-## Get available ADB devices
-
-```rust no_run
-use adb_client::server::ADBServer;
-use std::net::{SocketAddrV4, Ipv4Addr};
-
-// A custom server address can be provided
-let server_ip = Ipv4Addr::new(127, 0, 0, 1);
-let server_port = 5037;
-
-let mut server = ADBServer::new(SocketAddrV4::new(server_ip, server_port));
-server.devices();
-```

adb_client/src/server/adb_server.rs

@@ -1,7 +1,7 @@
 use crate::ADBTransport;
 use crate::Result;
 use crate::RustADBError;
-use crate::server::tcp_server_transport::TCPServerTransport;
+use crate::TCPServerTransport;
 use std::collections::HashMap;
 use std::net::SocketAddrV4;
 use std::process::Command;

adb_client/src/server/commands/connect.rs

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

adb_client/src/server/commands/devices.rs

@@ -1,10 +1,8 @@
 use std::io::Read;
 
 use crate::{
-    Result, RustADBError,
-    emulator::ADBEmulatorDevice,
-    server::{ADBServer, AdbServerCommand, DeviceLong, DeviceShort},
-    server_device::ADBServerDevice,
+    ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong, DeviceShort, Result, RustADBError,
+    models::AdbServerCommand,
 };
 
 impl ADBServer {

adb_client/src/server/commands/disconnect.rs

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

adb_client/src/server/commands/kill.rs

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

adb_client/src/server/commands/mdns.rs

@@ -1,8 +1,7 @@
 use std::io::BufRead;
 
 use crate::{
-    Result,
-    server::{ADBServer, AdbServerCommand, MDNSServices, models::MDNSBackend},
+    ADBServer, MDNSServices, Result, models::AdbServerCommand, server::models::MDNSBackend,
 };
 
 const OPENSCREEN_MDNS_BACKEND: &str = "ADB_MDNS_OPENSCREEN";
@@ -33,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/pair.rs

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

adb_client/src/server/commands/reconnect.rs

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

adb_client/src/server/commands/server_status.rs

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

adb_client/src/server/commands/version.rs

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

adb_client/src/server/commands/wait_for_device.rs

@@ -1,6 +1,5 @@
 use crate::{
-    Result,
-    server::{ADBServer, AdbServerCommand, WaitForDeviceState, WaitForDeviceTransport},
+    ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport, models::AdbServerCommand,
 };
 
 impl ADBServer {

adb_client/src/server/mod.rs

@@ -1,12 +1,6 @@
-#![doc = include_str!("./README.md")]
-
 mod adb_server;
-mod adb_server_command;
 mod commands;
 mod models;
-mod tcp_server_transport;
 
 pub use adb_server::ADBServer;
-pub(crate) use adb_server_command::AdbServerCommand;
 pub use models::*;
-pub use tcp_server_transport::TCPServerTransport;

adb_client/src/server/models/device_long.rs

@@ -2,8 +2,7 @@ use std::str::FromStr;
 use std::sync::LazyLock;
 use std::{fmt::Display, str};
 
-use crate::RustADBError;
-use crate::server::DeviceState;
+use crate::{DeviceState, RustADBError};
 use regex::bytes::Regex;
 
 static DEVICES_LONG_REGEX: LazyLock<Regex> = LazyLock::new(|| {

adb_client/src/server/models/device_short.rs

@@ -1,7 +1,7 @@
 use regex::bytes::Regex;
 use std::{fmt::Display, str::FromStr, sync::LazyLock};
 
-use crate::{RustADBError, server::DeviceState};
+use crate::{DeviceState, RustADBError};
 
 static DEVICES_REGEX: LazyLock<Regex> =
     LazyLock::new(|| Regex::new("^(\\S+)\t(\\w+)\n?$").expect("Cannot build devices regex"));

adb_client/src/server_device/README.md

@@ -1,25 +0,0 @@
-# Examples
-
-## Launch a command on device
-
-```rust no_run
-use adb_client::{server::ADBServer, ADBDeviceExt};
-
-let mut server = ADBServer::default();
-let mut device = server.get_device().expect("cannot get device");
-device.shell_command(&["df", "-h"], &mut std::io::stdout());
-```
-
-## Push a file to the device
-
-```rust no_run
-use adb_client::server::ADBServer;
-use std::net::Ipv4Addr;
-use std::fs::File;
-use std::path::Path;
-
-let mut server = ADBServer::default();
-let mut device = server.get_device().expect("cannot get device");
-let mut input = File::open(Path::new("/tmp/file.txt")).expect("Cannot open file");
-device.push(&mut input, "/data/local/tmp");
-```

adb_client/src/server_device/adb_server_device.rs

@@ -1,7 +1,4 @@
-use crate::{
-    ADBTransport, Result,
-    server::{AdbServerCommand, TCPServerTransport},
-};
+use crate::{ADBTransport, Result, TCPServerTransport, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 /// Represents a device connected to the ADB server.

adb_client/src/server_device/adb_server_device_commands.rs

@@ -5,14 +5,12 @@ use std::{
 
 use crate::{
     ADBDeviceExt, Result, RustADBError,
-    models::{AdbStatResponse, HostFeatures},
-    server::AdbServerCommand,
+    constants::BUFFER_SIZE,
+    models::{AdbServerCommand, AdbStatResponse, HostFeatures},
 };
 
 use super::ADBServerDevice;
 
-const BUFFER_SIZE: usize = 65535;
-
 impl ADBDeviceExt for ADBServerDevice {
     fn shell_command(&mut self, command: &[&str], output: &mut dyn Write) -> Result<()> {
         let supported_features = self.host_features()?;
@@ -51,7 +49,7 @@ impl ADBDeviceExt for ADBServerDevice {
     fn shell(
         &mut self,
         mut reader: &mut dyn Read,
-        mut writer: Box<dyn Write + Send>,
+        mut writer: Box<(dyn Write + Send)>,
     ) -> Result<()> {
         let supported_features = self.host_features()?;
         if !supported_features.contains(&HostFeatures::ShellV2)

adb_client/src/server_device/commands/forward.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Forward socket connection

adb_client/src/server_device/commands/framebuffer.rs

@@ -4,10 +4,8 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use image::{ImageBuffer, Rgba};
 
 use crate::{
-    Result, RustADBError,
-    models::{FrameBufferInfoV1, FrameBufferInfoV2},
-    server::AdbServerCommand,
-    server_device::ADBServerDevice,
+    ADBServerDevice, Result, RustADBError,
+    models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
 };
 
 impl ADBServerDevice {

adb_client/src/server_device/commands/host_features.rs

@@ -1,5 +1,6 @@
 use crate::{
-    Result, models::HostFeatures, server::AdbServerCommand, server_device::ADBServerDevice,
+    ADBServerDevice, Result,
+    models::{AdbServerCommand, HostFeatures},
 };
 
 impl ADBServerDevice {

adb_client/src/server_device/commands/install.rs

@@ -1,7 +1,7 @@
 use std::{fs::File, io::Read, path::Path};
 
 use crate::{
-    Result, server::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
+    Result, models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
 };
 
 impl ADBServerDevice {

adb_client/src/server_device/commands/list.rs

@@ -1,5 +1,6 @@
 use crate::{
-    Result, models::SyncCommand, server::AdbServerCommand, server_device::ADBServerDevice,
+    ADBServerDevice, Result,
+    models::{AdbServerCommand, SyncCommand},
 };
 use byteorder::{ByteOrder, LittleEndian};
 use std::{
@@ -63,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

@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 
-use crate::{ADBDeviceExt, Result, server_device::ADBServerDevice};
+use crate::{ADBDeviceExt, ADBServerDevice, Result};
 
 struct LogFilter<W: Write> {
     writer: W,

adb_client/src/server_device/commands/reboot.rs

@@ -1,4 +1,7 @@
-use crate::{Result, models::RebootType, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{
+    ADBServerDevice, Result,
+    models::{AdbServerCommand, RebootType},
+};
 
 impl ADBServerDevice {
     /// Reboots the device

adb_client/src/server_device/commands/reconnect.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Reconnect device

adb_client/src/server_device/commands/recv.rs

@@ -1,5 +1,6 @@
 use crate::{
-    Result, models::SyncCommand, server::AdbServerCommand, server_device::ADBServerDevice,
+    ADBServerDevice, Result, constants,
+    models::{AdbServerCommand, SyncCommand},
 };
 use byteorder::{LittleEndian, ReadBytesExt};
 use std::io::{BufReader, BufWriter, Read, Write};
@@ -47,7 +48,8 @@ impl<R: Read> Read for ADBRecvCommandReader<R> {
                     )))
                 }
                 _ => Err(std::io::Error::other(format!(
-                    "Unknown response from device {header:#?}"
+                    "Unknown response from device {:#?}",
+                    header
                 ))),
             }
         } else {
@@ -62,8 +64,6 @@ impl<R: Read> Read for ADBRecvCommandReader<R> {
     }
 }
 
-const BUFFER_SIZE: usize = 65535;
-
 impl ADBServerDevice {
     /// Receives path to stream from the device.
     pub fn pull(&mut self, path: &dyn AsRef<str>, stream: &mut dyn Write) -> Result<()> {
@@ -93,8 +93,8 @@ impl ADBServerDevice {
 
         let reader = ADBRecvCommandReader::new(raw_connection);
         std::io::copy(
-            &mut BufReader::with_capacity(BUFFER_SIZE, reader),
-            &mut BufWriter::with_capacity(BUFFER_SIZE, output),
+            &mut BufReader::with_capacity(constants::BUFFER_SIZE, reader),
+            &mut BufWriter::with_capacity(constants::BUFFER_SIZE, output),
         )?;
 
         // Connection should've been left in SYNC mode by now

adb_client/src/server_device/commands/reverse.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Reverse socket connection

adb_client/src/server_device/commands/send.rs

@@ -1,8 +1,6 @@
 use crate::{
-    Result, RustADBError,
-    models::{AdbRequestStatus, SyncCommand},
-    server::AdbServerCommand,
-    server_device::ADBServerDevice,
+    ADBServerDevice, Result, RustADBError, constants,
+    models::{AdbRequestStatus, AdbServerCommand, SyncCommand},
 };
 use std::{
     convert::TryInto,
@@ -42,8 +40,6 @@ impl<W: Write> Write for ADBSendCommandWriter<W> {
     }
 }
 
-const BUFFER_SIZE: usize = 65535;
-
 impl ADBServerDevice {
     /// Send stream to path on the device.
     pub fn push<R: Read, A: AsRef<str>>(&mut self, stream: R, path: A) -> Result<()> {
@@ -75,8 +71,8 @@ impl ADBServerDevice {
         let writer = ADBSendCommandWriter::new(raw_connection);
 
         std::io::copy(
-            &mut BufReader::with_capacity(BUFFER_SIZE, input),
-            &mut BufWriter::with_capacity(BUFFER_SIZE, writer),
+            &mut BufReader::with_capacity(constants::BUFFER_SIZE, input),
+            &mut BufWriter::with_capacity(constants::BUFFER_SIZE, writer),
         )?;
 
         // Copy is finished, we can now notify as finished

adb_client/src/server_device/commands/stat.rs

@@ -3,8 +3,8 @@ use std::io::{Read, Write};
 use byteorder::{ByteOrder, LittleEndian};
 
 use crate::{
-    AdbStatResponse, Result, RustADBError, models::SyncCommand, server::AdbServerCommand,
-    server_device::ADBServerDevice,
+    ADBServerDevice, Result, RustADBError,
+    models::{AdbServerCommand, AdbStatResponse, SyncCommand},
 };
 
 impl ADBServerDevice {
@@ -31,7 +31,8 @@ impl ADBServerDevice {
                 Ok(data.into())
             }
             x => Err(RustADBError::UnknownResponseType(format!(
-                "Unknown response {x}"
+                "Unknown response {}",
+                x
             ))),
         }
     }

adb_client/src/server_device/commands/tcpip.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Set adb daemon to tcp/ip mode

adb_client/src/server_device/commands/transport.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+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,6 +1,6 @@
 use std::io::Read;
 
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{Result, models::AdbServerCommand, server_device::ADBServerDevice};
 
 impl ADBServerDevice {
     /// Uninstall a package from device
@@ -15,7 +15,7 @@ impl ADBServerDevice {
 
         match &data[0..read_amount] {
             b"Success\n" => {
-                log::info!("Package {package_name} successfully uninstalled");
+                log::info!("Package {} successfully uninstalled", package_name);
                 Ok(())
             }
             d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(

adb_client/src/server_device/commands/usb.rs

@@ -1,4 +1,4 @@
-use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Set adb daemon to usb mode

adb_client/src/server_device/mod.rs

@@ -1,5 +1,3 @@
-#![doc = include_str!("./README.md")]
-
 mod adb_server_device;
 mod adb_server_device_commands;
 mod commands;

adb_client/src/transports/mod.rs

@@ -0,0 +1,11 @@
+mod tcp_emulator_transport;
+mod tcp_server_transport;
+mod tcp_transport;
+mod traits;
+mod usb_transport;
+
+pub use tcp_emulator_transport::TCPEmulatorTransport;
+pub use tcp_server_transport::TCPServerTransport;
+pub use tcp_transport::TcpTransport;
+pub use traits::{ADBMessageTransport, ADBTransport};
+pub use usb_transport::USBTransport;

adb_client/src/transports/tcp_emulator_transport.rs

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

adb_client/src/transports/tcp_server_transport.rs

@@ -4,9 +4,8 @@ use std::str::FromStr;
 
 use byteorder::{ByteOrder, LittleEndian};
 
-use crate::ADBTransport;
 use crate::models::{AdbRequestStatus, SyncCommand};
-use crate::server::AdbServerCommand;
+use crate::{ADBTransport, models::AdbServerCommand};
 use crate::{Result, RustADBError};
 
 const DEFAULT_SERVER_IP: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
@@ -100,13 +99,13 @@ impl TCPServerTransport {
     }
 
     /// Gets the body length from a LittleEndian value
-    pub(crate) fn get_body_length(&self) -> Result<u32> {
+    pub(crate) fn get_body_length(&mut 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(&self) -> Result<[u8; 4]> {
+    fn read_body_length(&mut self) -> Result<[u8; 4]> {
         let mut length_buffer = [0; 4];
         self.get_raw_connection()?.read_exact(&mut length_buffer)?;
 

adb_client/src/transports/tcp_transport.rs

@@ -5,15 +5,12 @@ use rustls::{
     pki_types::{CertificateDer, PrivatePkcs8KeyDer, pem::PemObject},
 };
 
+use super::{ADBMessageTransport, ADBTransport};
 use crate::{
     Result, RustADBError,
-    adb_transport::ADBTransport,
-    message_devices::{
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
-        message_commands::MessageCommand,
+    device::{
+        ADBTransportMessage, ADBTransportMessageHeader, MessageCommand, get_default_adb_key_path,
     },
-    utils::get_default_adb_key_path,
 };
 use std::{
     fs::read_to_string,
@@ -112,7 +109,7 @@ impl TcpTransport {
         })
     }
 
-    fn get_current_connection(&self) -> Result<Arc<Mutex<CurrentConnection>>> {
+    fn get_current_connection(&mut self) -> Result<Arc<Mutex<CurrentConnection>>> {
         self.current_connection
             .as_ref()
             .ok_or(RustADBError::IOError(std::io::Error::new(
@@ -178,7 +175,8 @@ impl TcpTransport {
                 Ok(())
             }
             c => Err(RustADBError::ADBRequestFailed(format!(
-                "Wrong command received {c}"
+                "Wrong command received {}",
+                c
             ))),
         }
     }
@@ -214,7 +212,7 @@ impl ADBMessageTransport for TcpTransport {
     fn read_message_with_timeout(
         &mut self,
         read_timeout: std::time::Duration,
-    ) -> Result<ADBTransportMessage> {
+    ) -> Result<crate::device::ADBTransportMessage> {
         let raw_connection_lock = self.get_current_connection()?;
         let mut raw_connection = raw_connection_lock.lock()?;
 

adb_client/src/transports/traits/adb_message_transport.rs

@@ -1,9 +1,7 @@
 use std::time::Duration;
 
-use crate::{
-    Result, adb_transport::ADBTransport,
-    message_devices::adb_transport_message::ADBTransportMessage,
-};
+use super::ADBTransport;
+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/traits/mod.rs

@@ -0,0 +1,5 @@
+mod adb_message_transport;
+mod adb_transport;
+
+pub use adb_message_transport::ADBMessageTransport;
+pub use adb_transport::ADBTransport;

adb_client/src/transports/usb_transport.rs

@@ -5,14 +5,10 @@ use rusb::{
     constants::LIBUSB_CLASS_VENDOR_SPEC,
 };
 
+use super::{ADBMessageTransport, ADBTransport};
 use crate::{
     Result, RustADBError,
-    adb_transport::ADBTransport,
-    message_devices::{
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
-        message_commands::MessageCommand,
-    },
+    device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
 };
 
 #[derive(Clone, Debug)]
@@ -44,7 +40,8 @@ impl USBTransport {
         }
 
         Err(RustADBError::DeviceNotFound(format!(
-            "cannot find USB device with vendor_id={vendor_id} and product_id={product_id}",
+            "cannot find USB device with vendor_id={} and product_id={}",
+            vendor_id, product_id
         )))
     }
 
@@ -154,7 +151,12 @@ impl USBTransport {
             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}",)
+            log::trace!(
+                "wrote chunk of size {} - {}/{}",
+                write_amount,
+                offset,
+                data_len
+            )
         }
 
         if offset % max_packet_size == 0 {
@@ -173,11 +175,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:?}");
+        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:?}");
+        log::debug!("got write endpoint: {:?}", write_endpoint);
         self.write_endpoint = Some(write_endpoint);
 
         self.handle = Some(Arc::new(device));
@@ -195,7 +197,7 @@ impl ADBTransport for USBTransport {
             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"),
+                    Ok(_) => log::debug!("succesfully released interface"),
                     Err(e) => log::error!("error while release interface: {e}"),
                 }
             }

adb_client/src/utils.rs

@@ -1,7 +1,4 @@
-use std::{
-    ffi::OsStr,
-    path::{Path, PathBuf},
-};
+use std::{ffi::OsStr, path::Path};
 
 use crate::{Result, RustADBError};
 
@@ -19,11 +16,3 @@ pub fn check_extension_is_apk<P: AsRef<Path>>(path: P) -> Result<()> {
 
     Ok(())
 }
-
-pub fn get_default_adb_key_path() -> Result<PathBuf> {
-    homedir::my_home()
-        .ok()
-        .flatten()
-        .map(|home| home.join(".android").join("adbkey"))
-        .ok_or(RustADBError::NoHomeDirectory)
-}

examples/mdns/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "mdns"
-authors.workspace = true
-edition.workspace = true
-homepage.workspace = true
-keywords.workspace = true
-license.workspace = true
-repository.workspace = true
-version.workspace = true
-rust-version.workspace = true
-
-[dependencies]
-adb_client = { path = "../../adb_client", default-features = false, features = [
-    "mdns",
-] }