feat: improve README.md

.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", "pyadb_client"]
+members = ["adb_cli", "adb_client", "examples/mdns", "pyadb_client"]
 resolver = "2"
 
 [workspace.package]

README.md

@@ -49,6 +49,12 @@ 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

@@ -11,7 +11,7 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-adb_client = { version = "^2.0.0" }
+adb_client = { version = "^2.0.0", features = ["mdns", "usb"] }
 anyhow = { version = "1.0.94" }
 clap = { version = "4.5.23", features = ["derive"] }
 env_logger = { version = "0.11.5" }

adb_cli/src/handlers/emulator_commands.rs

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

adb_cli/src/handlers/host_commands.rs

@@ -1,4 +1,7 @@
-use adb_client::{ADBServer, DeviceShort, MDNSBackend, Result, WaitForDeviceState};
+use adb_client::{
+    Result,
+    server::{ADBServer, DeviceShort, MDNSBackend, WaitForDeviceState},
+};
 
 use crate::models::{HostCommand, MdnsCommand, ServerCommand};
 

adb_cli/src/handlers/local_commands.rs

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

adb_cli/src/main.rs

@@ -7,9 +7,12 @@ mod handlers;
 mod models;
 mod utils;
 
-use adb_client::{
-    ADBDeviceExt, ADBServer, ADBServerDevice, ADBTcpDevice, ADBUSBDevice, MDNSDiscoveryService,
-};
+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;
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use adb_termios::ADBTermios;

adb_cli/src/models/host.rs

@@ -1,6 +1,6 @@
 use std::net::SocketAddrV4;
 
-use adb_client::{RustADBError, WaitForDeviceTransport};
+use adb_client::{RustADBError, server::WaitForDeviceTransport};
 use clap::Parser;
 
 fn parse_wait_for_device_device_transport(

adb_client/Cargo.toml

@@ -10,6 +10,15 @@ 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" }
@@ -18,9 +27,6 @@ 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" }
@@ -30,8 +36,6 @@ 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"] }
@@ -39,6 +43,18 @@ 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

@@ -16,6 +16,26 @@ 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
@@ -24,89 +44,8 @@ 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>|
-
-## 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()));
-```
+| 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> |

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::ADBServerDevice`] and [`crate::ADBUSBDevice`]
+/// Trait representing all features available on both [`crate::server_device::ADBServerDevice`] and [`crate::usb::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

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

adb_client/src/device/mod.rs

@@ -1,19 +0,0 @@
-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

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

adb_client/src/emulator/adb_emulator_device.rs

@@ -3,7 +3,10 @@ use std::{
     sync::LazyLock,
 };
 
-use crate::{ADBServerDevice, ADBTransport, Result, RustADBError, TCPEmulatorTransport};
+use crate::{
+    ADBTransport, Result, RustADBError, emulator::tcp_emulator_transport::TCPEmulatorTransport,
+    server_device::ADBServerDevice,
+};
 use regex::Regex;
 
 static EMULATOR_REGEX: LazyLock<Regex> = LazyLock::new(|| {

adb_client/src/emulator/commands/rotate.rs

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

adb_client/src/emulator/commands/sms.rs

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

adb_client/src/emulator/mod.rs

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

adb_client/src/emulator/tcp_emulator_transport.rs

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

adb_client/src/error.rs

@@ -67,6 +67,8 @@ 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
@@ -85,6 +87,8 @@ 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
@@ -94,6 +98,8 @@ 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
@@ -112,11 +118,13 @@ 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(transparent)]
-    SendError(#[from] std::sync::mpsc::SendError<crate::MDNSDevice>),
+    #[error("error sending data to channel")]
+    SendError,
     /// An unknown transport has been provided
     #[error("unknown transport: {0}")]
     UnknownTransport(String),

adb_client/src/lib.rs

@@ -3,25 +3,34 @@
 #![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 constants;
-mod device;
-mod emulator_device;
+mod adb_transport;
+/// Emulator-related definitions
+pub mod emulator;
 mod error;
-mod mdns;
+mod message_devices;
 mod models;
-mod server;
-mod server_device;
-mod transports;
+
+/// Server-related definitions
+pub mod server;
+
+/// Device reachable by the server related definitions
+pub mod server_device;
 mod utils;
 
+/// MDNS-related definitions
+#[cfg(feature = "mdns")]
+#[cfg_attr(docsrs, doc(cfg(feature = "mdns")))]
+pub mod mdns;
+
 pub use adb_device_ext::ADBDeviceExt;
-pub use device::{ADBTcpDevice, ADBUSBDevice, is_adb_device, search_adb_devices};
-pub use emulator_device::ADBEmulatorDevice;
+use adb_transport::ADBTransport;
 pub use error::{Result, RustADBError};
-pub use mdns::*;
-pub use models::{AdbStatResponse, RebootType};
-pub use server::*;
-pub use server_device::ADBServerDevice;
-pub use transports::*;
+pub use message_devices::*;
+pub use models::{AdbStatResponse, HostFeatures, RebootType};

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::{MDNSDevice, Result, RustADBError};
+use crate::{Result, RustADBError, mdns::MDNSDevice};
 
 const ADB_SERVICE_NAME: &str = "_adb-tls-connect._tcp.local.";
 
@@ -45,9 +45,9 @@ impl MDNSDiscoveryService {
                             continue;
                         }
                         ServiceEvent::ServiceResolved(service_info) => {
-                            if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
-                                return Err(e.into());
-                            }
+                            return sender
+                                .send(MDNSDevice::from(service_info))
+                                .map_err(|_| RustADBError::SendError);
                         }
                     }
                 }

adb_client/src/message_devices/adb_message_device.rs

@@ -2,9 +2,16 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use rand::Rng;
 use std::io::{Cursor, Read, Seek};
 
-use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};
+use crate::{
+    AdbStatResponse, Result, RustADBError,
+    message_devices::{
+        adb_message_transport::ADBMessageTransport,
+        adb_transport_message::ADBTransportMessage,
+        message_commands::{MessageCommand, MessageSubcommand},
+    },
+};
 
-use super::{ADBTransportMessage, MessageCommand, models::MessageSubcommand};
+const BUFFER_SIZE: usize = 65535;
 
 /// Generic structure representing an ADB device reachable over an [`ADBMessageTransport`].
 /// Structure is totally agnostic over which transport is truly used.

adb_client/src/message_devices/adb_message_device_commands.rs

@@ -1,17 +1,21 @@
-use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};
+use crate::{
+    ADBDeviceExt, RebootType, Result,
+    message_devices::{
+        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
+    },
+    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/message_devices/adb_message_transport.rs

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

adb_client/src/message_devices/adb_transport_message.rs

@@ -1,12 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-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;
+use crate::{Result, RustADBError, message_devices::message_commands::MessageCommand};
 
 #[derive(Debug)]
 pub struct ADBTransportMessage {

adb_client/src/message_devices/commands/framebuffer.rs

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

adb_client/src/message_devices/commands/install.rs

@@ -1,8 +1,11 @@
 use std::{fs::File, path::Path};
 
 use crate::{
-    ADBMessageTransport, Result,
-    device::{MessageWriter, adb_message_device::ADBMessageDevice},
+    Result,
+    message_devices::{
+        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
+        commands::utils::MessageWriter,
+    },
     utils::check_extension_is_apk,
 };
 

adb_client/src/message_devices/commands/mod.rs

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

adb_client/src/message_devices/commands/pull.rs

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

adb_client/src/message_devices/commands/push.rs

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

adb_client/src/message_devices/commands/reboot.rs

@@ -1,6 +1,9 @@
 use crate::{
-    ADBMessageTransport, RebootType, Result,
-    device::{MessageCommand, adb_message_device::ADBMessageDevice},
+    RebootType, Result,
+    message_devices::{
+        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
+        message_commands::MessageCommand,
+    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/message_devices/commands/shell.rs

@@ -1,10 +1,12 @@
 use std::io::{ErrorKind, Read, Write};
 
-use crate::Result;
-use crate::device::ShellMessageWriter;
 use crate::{
-    ADBMessageTransport, RustADBError,
-    device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
+    Result, RustADBError,
+    message_devices::{
+        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
+        adb_transport_message::ADBTransportMessage, commands::utils::ShellMessageWriter,
+        message_commands::MessageCommand,
+    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
@@ -36,7 +38,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/message_devices/commands/stat.rs

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

adb_client/src/message_devices/commands/uninstall.rs

@@ -1,4 +1,9 @@
-use crate::{ADBMessageTransport, Result, device::adb_message_device::ADBMessageDevice};
+use crate::{
+    Result,
+    message_devices::{
+        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
+    },
+};
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
     pub(crate) fn uninstall(&mut self, package_name: &str) -> Result<()> {

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

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

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

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

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

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

adb_client/src/message_devices/mod.rs

@@ -0,0 +1,14 @@
+/// 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

@@ -0,0 +1,13 @@
+# 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/adb_tcp_device.rs

@@ -2,10 +2,12 @@ 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 crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, TcpTransport};
+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};
 
 /// Represent a device reached and available over USB.
 #[derive(Debug)]
@@ -75,7 +77,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/message_devices/tcp/mod.rs

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

adb_client/src/message_devices/tcp/tcp_transport.rs

@@ -5,12 +5,15 @@ use rustls::{
     pki_types::{CertificateDer, PrivatePkcs8KeyDer, pem::PemObject},
 };
 
-use super::{ADBMessageTransport, ADBTransport};
 use crate::{
     Result, RustADBError,
-    device::{
-        ADBTransportMessage, ADBTransportMessageHeader, MessageCommand, get_default_adb_key_path,
+    adb_transport::ADBTransport,
+    message_devices::{
+        adb_message_transport::ADBMessageTransport,
+        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
+        message_commands::MessageCommand,
     },
+    utils::get_default_adb_key_path,
 };
 use std::{
     fs::read_to_string,
@@ -211,7 +214,7 @@ impl ADBMessageTransport for TcpTransport {
     fn read_message_with_timeout(
         &mut self,
         read_timeout: std::time::Duration,
-    ) -> Result<crate::device::ADBTransportMessage> {
+    ) -> Result<ADBTransportMessage> {
         let raw_connection_lock = self.get_current_connection()?;
         let mut raw_connection = raw_connection_lock.lock()?;
 

adb_client/src/message_devices/usb/README.md

@@ -0,0 +1,26 @@
+# 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/adb_usb_device.rs

@@ -9,14 +9,21 @@ 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::ADBMessageTransport;
-use crate::ADBTransport;
-use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
-use crate::{Result, RustADBError, USBTransport};
+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;
 
 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
@@ -92,14 +99,6 @@ 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 {
@@ -260,7 +259,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/message_devices/usb/mod.rs

@@ -0,0 +1,8 @@
+#![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/message_devices/usb/usb_transport.rs

@@ -5,10 +5,14 @@ use rusb::{
     constants::LIBUSB_CLASS_VENDOR_SPEC,
 };
 
-use super::{ADBMessageTransport, ADBTransport};
 use crate::{
     Result, RustADBError,
-    device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
+    adb_transport::ADBTransport,
+    message_devices::{
+        adb_message_transport::ADBMessageTransport,
+        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
+        message_commands::MessageCommand,
+    },
 };
 
 #[derive(Clone, Debug)]

adb_client/src/models/host_features.rs

@@ -1,8 +1,11 @@
 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,15 +1,13 @@
 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 use adb_request_status::AdbRequestStatus;
-pub(crate) use adb_server_command::AdbServerCommand;
+pub(crate) use adb_request_status::AdbRequestStatus;
 pub use adb_stat_response::AdbStatResponse;
 pub(crate) use framebuffer_info::{FrameBufferInfoV1, FrameBufferInfoV2};
 pub use host_features::HostFeatures;
 pub use reboot_type::RebootType;
-pub use sync_command::SyncCommand;
+pub(crate) use sync_command::SyncCommand;

adb_client/src/server/README.md

@@ -0,0 +1,15 @@
+# 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::TCPServerTransport;
+use crate::server::tcp_server_transport::TCPServerTransport;
 use std::collections::HashMap;
 use std::net::SocketAddrV4;
 use std::process::Command;

adb_client/src/server/adb_server_command.rs

@@ -1,8 +1,10 @@
 use std::fmt::Display;
 
-use crate::{WaitForDeviceState, WaitForDeviceTransport};
+use crate::{
+    RebootType,
+    server::{WaitForDeviceState, WaitForDeviceTransport},
+};
 
-use super::RebootType;
 use std::net::SocketAddrV4;
 
 pub(crate) enum AdbServerCommand {

adb_client/src/server/commands/connect.rs

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

adb_client/src/server/commands/devices.rs

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

adb_client/src/server/commands/disconnect.rs

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

adb_client/src/server/commands/kill.rs

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

adb_client/src/server/commands/mdns.rs

@@ -1,7 +1,8 @@
 use std::io::BufRead;
 
 use crate::{
-    ADBServer, MDNSServices, Result, models::AdbServerCommand, server::models::MDNSBackend,
+    Result,
+    server::{ADBServer, AdbServerCommand, MDNSServices, models::MDNSBackend},
 };
 
 const OPENSCREEN_MDNS_BACKEND: &str = "ADB_MDNS_OPENSCREEN";

adb_client/src/server/commands/pair.rs

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

adb_client/src/server/commands/reconnect.rs

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

adb_client/src/server/commands/server_status.rs

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

adb_client/src/server/commands/version.rs

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

adb_client/src/server/commands/wait_for_device.rs

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

adb_client/src/server/mod.rs

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

adb_client/src/server/tcp_server_transport.rs

@@ -4,8 +4,9 @@ use std::str::FromStr;
 
 use byteorder::{ByteOrder, LittleEndian};
 
+use crate::ADBTransport;
 use crate::models::{AdbRequestStatus, SyncCommand};
-use crate::{ADBTransport, models::AdbServerCommand};
+use crate::server::AdbServerCommand;
 use crate::{Result, RustADBError};
 
 const DEFAULT_SERVER_IP: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);

adb_client/src/server_device/README.md

@@ -0,0 +1,25 @@
+# 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,4 +1,7 @@
-use crate::{ADBTransport, Result, TCPServerTransport, models::AdbServerCommand};
+use crate::{
+    ADBTransport, Result,
+    server::{AdbServerCommand, TCPServerTransport},
+};
 use std::net::SocketAddrV4;
 
 /// Represents a device connected to the ADB server.

adb_client/src/server_device/adb_server_device_commands.rs

@@ -5,12 +5,14 @@ use std::{
 
 use crate::{
     ADBDeviceExt, Result, RustADBError,
-    constants::BUFFER_SIZE,
-    models::{AdbServerCommand, AdbStatResponse, HostFeatures},
+    models::{AdbStatResponse, HostFeatures},
+    server::AdbServerCommand,
 };
 
 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()?;
@@ -49,7 +51,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::{ADBServerDevice, Result, models::AdbServerCommand};
+use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
 
 impl ADBServerDevice {
     /// Forward socket connection

adb_client/src/server_device/commands/framebuffer.rs

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

adb_client/src/server_device/commands/host_features.rs

@@ -1,6 +1,5 @@
 use crate::{
-    ADBServerDevice, Result,
-    models::{AdbServerCommand, HostFeatures},
+    Result, models::HostFeatures, server::AdbServerCommand, server_device::ADBServerDevice,
 };
 
 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, models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
+    Result, server::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
 };
 
 impl ADBServerDevice {

adb_client/src/server_device/commands/list.rs

@@ -1,6 +1,5 @@
 use crate::{
-    ADBServerDevice, Result,
-    models::{AdbServerCommand, SyncCommand},
+    Result, models::SyncCommand, server::AdbServerCommand, server_device::ADBServerDevice,
 };
 use byteorder::{ByteOrder, LittleEndian};
 use std::{

adb_client/src/server_device/commands/logcat.rs

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

adb_client/src/server_device/commands/reboot.rs

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

adb_client/src/server_device/commands/reconnect.rs

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

adb_client/src/server_device/commands/recv.rs

@@ -1,6 +1,5 @@
 use crate::{
-    ADBServerDevice, Result, constants,
-    models::{AdbServerCommand, SyncCommand},
+    Result, models::SyncCommand, server::AdbServerCommand, server_device::ADBServerDevice,
 };
 use byteorder::{LittleEndian, ReadBytesExt};
 use std::io::{BufReader, BufWriter, Read, Write};
@@ -63,6 +62,8 @@ 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<()> {
@@ -92,8 +93,8 @@ impl ADBServerDevice {
 
         let reader = ADBRecvCommandReader::new(raw_connection);
         std::io::copy(
-            &mut BufReader::with_capacity(constants::BUFFER_SIZE, reader),
-            &mut BufWriter::with_capacity(constants::BUFFER_SIZE, output),
+            &mut BufReader::with_capacity(BUFFER_SIZE, reader),
+            &mut BufWriter::with_capacity(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::{ADBServerDevice, Result, models::AdbServerCommand};
+use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
 
 impl ADBServerDevice {
     /// Reverse socket connection

adb_client/src/server_device/commands/send.rs

@@ -1,6 +1,8 @@
 use crate::{
-    ADBServerDevice, Result, RustADBError, constants,
-    models::{AdbRequestStatus, AdbServerCommand, SyncCommand},
+    Result, RustADBError,
+    models::{AdbRequestStatus, SyncCommand},
+    server::AdbServerCommand,
+    server_device::ADBServerDevice,
 };
 use std::{
     convert::TryInto,
@@ -40,6 +42,8 @@ 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<()> {
@@ -71,8 +75,8 @@ impl ADBServerDevice {
         let writer = ADBSendCommandWriter::new(raw_connection);
 
         std::io::copy(
-            &mut BufReader::with_capacity(constants::BUFFER_SIZE, input),
-            &mut BufWriter::with_capacity(constants::BUFFER_SIZE, writer),
+            &mut BufReader::with_capacity(BUFFER_SIZE, input),
+            &mut BufWriter::with_capacity(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::{
-    ADBServerDevice, Result, RustADBError,
-    models::{AdbServerCommand, AdbStatResponse, SyncCommand},
+    AdbStatResponse, Result, RustADBError, models::SyncCommand, server::AdbServerCommand,
+    server_device::ADBServerDevice,
 };
 
 impl ADBServerDevice {

adb_client/src/server_device/commands/tcpip.rs

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

adb_client/src/server_device/commands/transport.rs

@@ -1,4 +1,4 @@
-use crate::{ADBServerDevice, Result, models::AdbServerCommand};
+use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
 
 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, models::AdbServerCommand, server_device::ADBServerDevice};
+use crate::{Result, server::AdbServerCommand, server_device::ADBServerDevice};
 
 impl ADBServerDevice {
     /// Uninstall a package from device

adb_client/src/server_device/commands/usb.rs

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

adb_client/src/server_device/mod.rs

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

adb_client/src/transports/mod.rs

@@ -1,11 +0,0 @@
-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/traits/mod.rs

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

adb_client/src/utils.rs

@@ -1,4 +1,7 @@
-use std::{ffi::OsStr, path::Path};
+use std::{
+    ffi::OsStr,
+    path::{Path, PathBuf},
+};
 
 use crate::{Result, RustADBError};
 
@@ -16,3 +19,11 @@ 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

@@ -0,0 +1,15 @@
+[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",
+] }

examples/mdns/src/main.rs

@@ -0,0 +1,22 @@
+use std::sync::mpsc;
+use std::time::Duration;
+
+use adb_client::mdns::{MDNSDevice, MDNSDiscoveryService};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Starting mDNS device discovery...");
+
+    // Create a channel to receive discovered devices information
+    let (sender, receiver) = mpsc::channel::<MDNSDevice>();
+
+    // Create and start the discovery service
+    let mut discovery = MDNSDiscoveryService::new()?;
+    discovery.start(sender)?;
+
+    loop {
+        if let Ok(device) = receiver.recv_timeout(Duration::from_millis(100)) {
+            println!("Found device: {}", device.fullname);
+            println!("  Addresses: {:?}", device.addresses);
+        }
+    }
+}