wip: feature-based

.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
+    - uses: actions/checkout@v4
-      - name: Build project
+    - name: Build project
-        run: cargo build --release --all-features
+      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]

README.md

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

@@ -11,7 +11,7 @@ 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/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::{
+use adb_client::{ADBServer, DeviceShort, MDNSBackend, Result, WaitForDeviceState};
-    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::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::{
-use adb_client::mdns::MDNSDiscoveryService;
+    ADBDeviceExt, ADBServer, ADBServerDevice, ADBTcpDevice, ADBUSBDevice, 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, server::WaitForDeviceTransport};
+use adb_client::{RustADBError, WaitForDeviceTransport};
 use clap::Parser;
 
 fn parse_wait_for_device_device_transport(

adb_client/Cargo.toml

@@ -10,14 +10,9 @@ repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
 
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
 [features]
-default = []
+default = ["mdns"]
 mdns = ["dep:mdns-sd"]
-usb = ["dep:rsa", "dep:rusb"]
 
 [dependencies]
 base64 = { version = "0.22.1" }
@@ -36,6 +31,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,17 +40,10 @@ serde_repr = { version = "0.1.19" }
 sha1 = { version = "0.10.6", features = ["oid"] }
 thiserror = { version = "2.0.7" }
 
-#########
+# MDNS
-# MDNS-only dependencies
+mdns-sd = { version = "0.13.9", default-features = false, optional = true, features = [
-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" }

adb_client/README.md

@@ -16,26 +16,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 +24,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               |
+|File size|Sample size|`ADBServerDevice`|`adb`|Difference|
-| :-------: | :---------: | :---------------: | :-------: | :------------------------------------: |
+|:-------:|:---------:|:----------:|:---:|:-----:|
-|   10 MB   |     100     |     350,79 ms     | 356,30 ms | <div style="color:green">-1,57 %</div> |
+|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> |
+|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> |
+|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::{
+use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};
-    AdbStatResponse, Result, RustADBError,
-    message_devices::{
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage,
-        message_commands::{MessageCommand, MessageSubcommand},
-    },
-};
 
-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.

adb_client/src/device/adb_message_device_commands.rs

@@ -1,21 +1,17 @@
-use crate::{
+use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};
-    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/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 super::ADBTransportMessage;
-use crate::message_devices::adb_message_transport::ADBMessageTransport;
+use super::adb_message_device::ADBMessageDevice;
-use crate::message_devices::adb_transport_message::ADBTransportMessage;
+use super::models::MessageCommand;
-use crate::message_devices::message_commands::MessageCommand;
+use crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, TcpTransport};
-use crate::tcp::tcp_transport::TcpTransport;
-use crate::{ADBDeviceExt, ADBTransport, Result};
 
 /// 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,21 +9,14 @@ 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::ADBMessageTransport;
-use crate::RustADBError;
+use crate::ADBTransport;
-use crate::adb_transport::ADBTransport;
+use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
-use crate::message_devices::adb_message_device::ADBMessageDevice;
+use crate::{Result, RustADBError, USBTransport};
-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
@@ -99,6 +92,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 {
@@ -259,7 +260,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,
+    ADBMessageTransport, Result, RustADBError,
-    message_devices::{
+    device::{MessageCommand, adb_message_device::ADBMessageDevice},
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        message_commands::MessageCommand,
-    },
     models::{FrameBufferInfoV1, FrameBufferInfoV2},
 };
 

adb_client/src/device/commands/install.rs

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

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,
+    ADBMessageTransport, Result, RustADBError,
-    message_devices::{
+    device::{
-        adb_message_device::ADBMessageDevice,
+        ADBTransportMessage, MessageCommand, adb_message_device::ADBMessageDevice,
-        adb_message_transport::ADBMessageTransport,
+        models::MessageSubcommand,
-        adb_transport_message::ADBTransportMessage,
-        message_commands::{MessageCommand, MessageSubcommand},
     },
 };
 

adb_client/src/device/commands/push.rs

@@ -1,12 +1,10 @@
 use std::io::Read;
 
 use crate::{
-    Result, RustADBError,
+    ADBMessageTransport, Result, RustADBError,
-    message_devices::{
+    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,9 +1,6 @@
 use crate::{
-    RebootType, Result,
+    ADBMessageTransport, RebootType, Result,
-    message_devices::{
+    device::{MessageCommand, adb_message_device::ADBMessageDevice},
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        message_commands::MessageCommand,
-    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

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,
+    ADBMessageTransport, RustADBError,
-    message_devices::{
+    device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-        adb_transport_message::ADBTransportMessage, commands::utils::ShellMessageWriter,
-        message_commands::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,
+    ADBMessageTransport, AdbStatResponse, Result, device::adb_message_device::ADBMessageDevice,
-    message_devices::{
-        adb_message_device::ADBMessageDevice, adb_message_transport::ADBMessageTransport,
-    },
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {

adb_client/src/device/commands/uninstall.rs

@@ -1,9 +1,4 @@
-use crate::{
+use crate::{ADBMessageTransport, Result, device::adb_message_device::ADBMessageDevice};
-    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/device/message_writer.rs

@@ -1,9 +1,8 @@
 use std::io::{Error, ErrorKind, Result, Write};
 
-use crate::message_devices::{
+use crate::ADBMessageTransport;
-    adb_message_transport::ADBMessageTransport, adb_transport_message::ADBTransportMessage,
+
-    message_commands::MessageCommand,
+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::{
+use crate::ADBMessageTransport;
-    adb_message_transport::ADBMessageTransport, adb_transport_message::ADBTransportMessage,
+
-    message_commands::MessageCommand,
+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::{
+use crate::{ADBServerDevice, ADBTransport, Result, RustADBError, TCPEmulatorTransport};
-    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_device/commands/rotate.rs

@@ -1,7 +1,4 @@
-use crate::{
+use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
-    Result,
-    emulator::{ADBEmulatorCommand, ADBEmulatorDevice},
-};
 
 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::{
+use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
-    Result,
-    emulator::{ADBEmulatorCommand, ADBEmulatorDevice},
-};
 
 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
@@ -119,12 +113,11 @@ pub enum RustADBError {
     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")]
+    #[error(transparent)]
-    SendError,
+    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,27 @@
 #![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;
+mod constants;
-/// Emulator-related definitions
+mod device;
-pub mod emulator;
+mod emulator_device;
 mod error;
-mod message_devices;
+#[cfg(feature = "mdns")]
+mod mdns;
 mod models;
-
+mod server;
-/// Server-related definitions
+mod server_device;
-pub mod server;
+mod transports;
-
-/// 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;
-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::*;
+#[cfg(feature = "mdns")]
-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
+                            if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
-                                .send(MDNSDevice::from(service_info))
+                                return Err(e.into());
-                                .map_err(|_| RustADBError::SendError);
+                            }
                         }
                     }
                 }

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::{
+use crate::{WaitForDeviceState, WaitForDeviceTransport};
-    RebootType,
-    server::{WaitForDeviceState, WaitForDeviceTransport},
-};
 
+use super::RebootType;
 use std::net::SocketAddrV4;
 
 pub(crate) enum AdbServerCommand {
@@ -20,7 +18,9 @@ pub(crate) enum AdbServerCommand {
     Pair(SocketAddrV4, String),
     TransportAny,
     TransportSerial(String),
+    #[cfg(feature = "mdns")]
     MDNSCheck,
+    #[cfg(feature = "mdns")]
     MDNSServices,
     ServerStatus,
     ReconnectOffline,
@@ -79,7 +79,9 @@ impl Display for AdbServerCommand {
                 write!(f, "reverse:forward:{remote};{local}")
             }
             AdbServerCommand::ReverseRemoveAll => write!(f, "reverse:killforward-all"),
+            #[cfg(feature = "mdns")]
             AdbServerCommand::MDNSCheck => write!(f, "host:mdns:check"),
+            #[cfg(feature = "mdns")]
             AdbServerCommand::MDNSServices => write!(f, "host:mdns:services"),
             AdbServerCommand::ServerStatus => write!(f, "host:server-status"),
             AdbServerCommand::Reconnect => write!(f, "reconnect"),

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::{
+use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
-    Result, RustADBError,
-    server::{ADBServer, 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,
+    ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong, DeviceShort, Result, RustADBError,
-    emulator::ADBEmulatorDevice,
+    models::AdbServerCommand,
-    server::{ADBServer, AdbServerCommand, DeviceLong, DeviceShort},
-    server_device::ADBServerDevice,
 };
 
 impl ADBServer {

adb_client/src/server/commands/disconnect.rs

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

adb_client/src/server/commands/kill.rs

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

adb_client/src/server/commands/mdns.rs

@@ -1,12 +1,12 @@
 use std::io::BufRead;
 
 use crate::{
-    Result,
+    ADBServer, MDNSServices, Result, models::AdbServerCommand, server::models::MDNSBackend,
-    server::{ADBServer, AdbServerCommand, MDNSServices, models::MDNSBackend},
 };
 
 const OPENSCREEN_MDNS_BACKEND: &str = "ADB_MDNS_OPENSCREEN";
 
+#[cfg(feature = "mdns")]
 impl ADBServer {
     /// Check if mdns discovery is available
     pub fn mdns_check(&mut self) -> Result<bool> {

adb_client/src/server/commands/mod.rs

@@ -2,6 +2,7 @@ mod connect;
 mod devices;
 mod disconnect;
 mod kill;
+#[cfg(feature = "mdns")]
 mod mdns;
 mod pair;
 mod reconnect;

adb_client/src/server/commands/pair.rs

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

adb_client/src/server/commands/reconnect.rs

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

adb_client/src/server/commands/server_status.rs

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

adb_client/src/server/commands/version.rs

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

adb_client/src/server/commands/wait_for_device.rs

@@ -1,6 +1,5 @@
 use crate::{
-    Result,
+    ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport, models::AdbServerCommand,
-    server::{ADBServer, AdbServerCommand, WaitForDeviceState, WaitForDeviceTransport},
 };
 
 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::{DeviceState, 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::{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/models/mod.rs

@@ -2,6 +2,7 @@ mod adb_version;
 mod device_long;
 mod device_short;
 mod device_state;
+#[cfg(feature = "mdns")]
 mod mdns_services;
 mod server_status;
 mod wait_for_device;
@@ -10,6 +11,7 @@ pub use adb_version::AdbVersion;
 pub use device_long::DeviceLong;
 pub use device_short::DeviceShort;
 pub use device_state::DeviceState;
+#[cfg(feature = "mdns")]
 pub use mdns_services::MDNSServices;
 pub use server_status::{MDNSBackend, ServerStatus};
 pub use wait_for_device::{WaitForDeviceState, WaitForDeviceTransport};

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::{
+use crate::{ADBTransport, Result, TCPServerTransport, models::AdbServerCommand};
-    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,14 +5,12 @@ use std::{
 
 use crate::{
     ADBDeviceExt, Result, RustADBError,
-    models::{AdbStatResponse, HostFeatures},
+    constants::BUFFER_SIZE,
-    server::AdbServerCommand,
+    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,
+    ADBServerDevice, Result, RustADBError,
-    models::{FrameBufferInfoV1, FrameBufferInfoV2},
+    models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
-    server::AdbServerCommand,
-    server_device::ADBServerDevice,
 };
 
 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::{

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};
@@ -62,8 +63,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 +92,8 @@ impl ADBServerDevice {
 
         let reader = ADBRecvCommandReader::new(raw_connection);
         std::io::copy(
-            &mut BufReader::with_capacity(BUFFER_SIZE, reader),
+            &mut BufReader::with_capacity(constants::BUFFER_SIZE, reader),
-            &mut BufWriter::with_capacity(BUFFER_SIZE, output),
+            &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,
+    ADBServerDevice, Result, RustADBError, constants,
-    models::{AdbRequestStatus, SyncCommand},
+    models::{AdbRequestStatus, AdbServerCommand, SyncCommand},
-    server::AdbServerCommand,
-    server_device::ADBServerDevice,
 };
 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 BufReader::with_capacity(constants::BUFFER_SIZE, input),
-            &mut BufWriter::with_capacity(BUFFER_SIZE, writer),
+            &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,
+    ADBServerDevice, Result, RustADBError,
-    server_device::ADBServerDevice,
+    models::{AdbServerCommand, AdbStatResponse, SyncCommand},
 };
 
 impl ADBServerDevice {

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

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::{
+use super::ADBTransport;
-    Result, RustADBError, adb_transport::ADBTransport, emulator::models::ADBEmulatorCommand,
+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);

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,
+    device::{
-    message_devices::{
+        ADBTransportMessage, ADBTransportMessageHeader, MessageCommand, get_default_adb_key_path,
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
-        message_commands::MessageCommand,
     },
-    utils::get_default_adb_key_path,
 };
 use std::{
     fs::read_to_string,
@@ -214,7 +211,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::{
+use super::ADBTransport;
-    Result, adb_transport::ADBTransport,
+use crate::{Result, device::ADBTransportMessage};
-    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/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,
+    device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
-    message_devices::{
-        adb_message_transport::ADBMessageTransport,
-        adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader},
-        message_commands::MessageCommand,
-    },
 };
 
 #[derive(Clone, Debug)]

adb_client/src/utils.rs

@@ -1,7 +1,4 @@
-use std::{
+use std::{ffi::OsStr, path::Path};
-    ffi::OsStr,
-    path::{Path, PathBuf},
-};
 
 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)
-}