adb_client

https://docs.rs/adb_client/latest
Admin
A Rust library implementing the ADB (Android Debug Bridge) protocol for communicating with Android...
Tokens:147,208
Snippets:1,162
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Available ADB Devices

Source: https://docs.rs/adb_client/latest/adb_client/server/index.html

Example demonstrating how to initialize an ADBServer and retrieve a list of available devices.

```APIDOC
## Get Available ADB Devices

### Description
This example shows how to create an instance of `ADBServer` and call the `devices()` method to get a list of connected ADB devices.

### Method Signature
```rust
fn devices(&mut self) -> Result<Vec<DeviceShort>, ADBError>
```

### Usage
```rust
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));
let devices = server.devices();

match devices {
    Ok(device_list) => {
        println!("Found devices: {:?}", device_list);
    }
    Err(e) => {
        eprintln!("Error getting devices: {}", e);
    }
}
```
```

--------------------------------

### install

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Install an APK pointed to by `apk_path` on the device.

```APIDOC
## install

### Description
Install an APK pointed to by `apk_path` on device.

### Signature
`fn install( &mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>, ) -> Result<()>`
```

--------------------------------

### ADBServer::start

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Starts an instance of the `adb-server` process.

```APIDOC
## ADBServer::start

### Description
Starts an instance of `adb-server`. This method is intended for internal use or when explicit control over server startup is needed. It configures and spawns the `adb start-server` command, applying environment variables and platform-specific flags.

### Signature
```rust
pub fn start(envs: &HashMap<String, String>, adb_path: &Option<String>)
```

### Parameters
* `envs` (&HashMap<String, String>) - A hash map of environment variables to set for the `adb-server` process.
* `adb_path` (&Option<String>) - An optional path to the ADB executable. If `None`, `adb` will be used from the system's PATH.
```

--------------------------------

### Install Application

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/adb_server_device_commands.rs.html

Installs an APK file onto the device. Optionally, a specific user can be targeted for the installation.

```APIDOC
## install

### Description
Installs an APK file onto the device. Optionally, a specific user can be targeted for the installation.

### Method
`install(&mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>) -> Result<()>`

### Parameters
- `apk_path` (&dyn AsRef<Path>): The path to the APK file on the host.
- `user` (Option<&str>): An optional identifier for the user to install the app for.

### Returns
- `Result<()>`: Ok(()) on success, or an error if the operation fails.
```

--------------------------------

### Start ADB Server Process

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Starts an ADB server process using the provided environment variables and ADB path. It handles potential errors during command execution and waiting for the process to complete. On Windows, it uses specific creation flags to prevent a console window from appearing.

```rust
pub fn start(envs: &HashMap<String, String>, adb_path: &Option<String>) {
    // ADB Server is local, we start it if not already running
    let mut command = Command::new(adb_path.as_deref().unwrap_or("adb"));
    command.arg("start-server");
    for (env_k, env_v) in envs {
        command.env(env_k, env_v);
    }

    #[cfg(target_os = "windows")]
    {
        use std::os::windows::process::CommandExt;
        // Do not show a prompt on Windows
        command.creation_flags(0x08000000);
    }

    let child = command.spawn();
    match child {
        Ok(mut child) => {
            if let Err(e) = child.wait() {
                log::error!("error while starting adb server: {e}");
            }
        }
        Err(e) => log::error!("error while starting adb server: {e}"),
    }
}
```

--------------------------------

### Install APK File

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/commands/install.rs.html

Installs an APK file onto the connected Android device. It opens the APK file, checks its extension, and streams its content to the device. The function returns an error if the installation fails.

```rust
use std::{fs::File, path::Path};

use crate::{
    Result,
    message_devices::{
        adb_message_device::ADBMessageDevice,
        adb_message_transport::ADBMessageTransport,
        commands::utils::MessageWriter,
        message_commands::MessageCommand,
    },
    models::ADBLocalCommand,
    utils::check_extension_is_apk,
};

impl<T: ADBMessageTransport> ADBMessageDevice<T> {
    pub(crate) fn install(&mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>) -> Result<()> {
        let mut apk_file = File::open(apk_path)?;

        check_extension_is_apk(apk_path)?;

        let file_size = apk_file.metadata()?.len();

        let mut session = self.open_session(&ADBLocalCommand::Install(
            file_size,
            user.map(ToString::to_string),
        ))?;

        {
            // Read data from apk_file and write it to the underlying session
            let mut writer = MessageWriter::new(&mut session);
            std::io::copy(&mut apk_file, &mut writer)?;
        }

        let final_status = session.get_transport_mut().read_message()?;

        match final_status.into_payload().as_slice() {
            b"Success\n" => {
                log::info!(
                    "APK file {} successfully installed",
                    apk_path.as_ref().display()
                );
                self.get_transport_mut()
                    .read_message()? 
                    .assert_command(MessageCommand::Clse)?;
                Ok(())
            }
            d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(
                d.to_vec(),
            )?)),
        }
    }
}
```

--------------------------------

### ADBServerDevice::install

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Installs an APK on the device.

```APIDOC
## ADBServerDevice::install

### Description
Install an APK on device.

### Signature
```rust
pub fn install<P: AsRef<Path>>( &mut self, apk_path: P, user: Option<&str>, ) -> Result<()>
```
```

--------------------------------

### Install APK on Device

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Installs an APK file from the given `apk_path` onto the device. Optionally specify a user ID for multi-user devices.

```rust
fn install( &mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>, ) -> Result<()>
```

--------------------------------

### ADBTcpDevice Install

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/tcp/adb_tcp_device.rs.html

Installs an APK file onto the ADB device.

```APIDOC
## install(&mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>) -> Result<()>

### Description
Installs an Android application package (APK) file onto the device.

### Parameters
* `apk_path` (&dyn AsRef<Path>) - The path to the APK file on the local system.
* `user` (Option<&str>) - Optional user ID to install the app for.

### Returns
* `Result<()>` - A `Result` indicating success or failure.
```

--------------------------------

### Install APK on Device

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/commands/install.rs.html

Installs an APK file on the connected Android device. It opens the APK, checks its extension, sends the file size and optional user ID to the ADB server, streams the APK data, and verifies the installation status.

```rust
use std::{fs::File, io::Read, path::Path};

use crate::{
    Result,
    models::{ADBCommand, ADBLocalCommand},
    server_device::ADBServerDevice,
    utils::check_extension_is_apk,
};

impl ADBServerDevice {
    /// Install an APK on device
    pub fn install<P: AsRef<Path>>(&mut self, apk_path: P, user: Option<&str>) -> Result<()> {
        let mut apk_file = File::open(&apk_path)?;

        check_extension_is_apk(&apk_path)?;

        let file_size = apk_file.metadata()?.len();

        self.set_serial_transport()?;

        self.transport
            .send_adb_request(&ADBCommand::Local(ADBLocalCommand::Install(
                file_size,
                user.map(ToString::to_string),
            )))?;

        let mut raw_connection = self.transport.get_raw_connection()?;

        std::io::copy(&mut apk_file, &mut raw_connection)?;

        let mut data = [0; 1024];
        let read_amount = self.transport.get_raw_connection()?.read(&mut data)?;

        match &data[0..read_amount] {
            b"Success\n" => {
                log::info!(
                    "APK file {} successfully installed",
                    apk_path.as_ref().display()
                );
                Ok(())
            }
            d => Err(crate::RustADBError::ADBRequestFailed(String::from_utf8(
                d.to_vec(),
            )?)),
        }
    }
}
```

--------------------------------

### ADBDeviceExt::install

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Installs an APK file onto the ADB device.

```APIDOC
## ADBDeviceExt::install

### Description
Installs an Android application package (APK) file onto the device. Optionally, a specific user can be targeted for installation.

### Signature
```rust
fn install(&mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>) -> Result<()>
```

### Parameters
* `apk_path` (&dyn AsRef<Path>) - The path to the APK file to install.
* `user` (Option<&str>) - An optional identifier for the user to install the app for.

### Returns
* `Result<()>` - A `Result` indicating success or failure (`RustADBError`).
```

--------------------------------

### Install APK on Device

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/commands/install.rs.html

Installs an APK file onto the connected Android device. It handles file transfer and verifies the installation status.

```APIDOC
## install

### Description
Installs an APK file onto the connected Android device. This function takes the path to the APK file and an optional user identifier.

### Method Signature
`pub fn install<P: AsRef<Path>>(&mut self, apk_path: P, user: Option<&str>) -> Result<()>`

### Parameters
- `apk_path` (P: AsRef<Path>): The path to the APK file to be installed. The path must point to a valid file with a `.apk` extension.
- `user` (Option<&str>): An optional string representing the user ID on the device to install the APK for. If `None`, it installs for the default user.

### Returns
- `Result<()>`: Returns `Ok(())` on successful installation, or an `Err` containing a `RustADBError` if any step fails (e.g., file not found, invalid extension, installation error).
```

--------------------------------

### shell

Source: https://docs.rs/adb_client/latest/adb_client/trait.ADBDeviceExt.html

Starts an interactive shell session on the device.

```APIDOC
## shell

### Description
Starts an interactive shell session on the device. Input data is read from reader and write to writer.

### Signature
```rust
fn shell(
    &mut self,
    reader: &mut dyn Read,
    writer: Box<dyn Write + Send>,
) -> Result<()>
```
```

--------------------------------

### Start MDNS Discovery Thread

Source: https://docs.rs/adb_client/latest/src/adb_client/mdns/mdns_discovery.rs.html

Starts the mDNS discovery process in a background thread. It listens for ADB service announcements and sends discovered devices to the provided sender. Ensure `ServiceDaemon::browse` is called with the correct service name.

```rust
pub fn start(&mut self, sender: Sender<MDNSDevice>) -> Result<()> {
        let receiver = self.daemon.browse(ADB_SERVICE_NAME)?;

        let handle: JoinHandle<Result<()>> = std::thread::spawn(move || {
            loop {
                while let Ok(event) = receiver.recv() {
                    if let ServiceEvent::ServiceResolved(service_info) = event {
                        match MDNSDevice::try_from(service_info) {
                            Ok(device) => {
                                sender.send(device).map_err(|_| RustADBError::SendError)?;
                            }
                            Err(e) => log::error!("got error with device: {e}")
                        }
                    }
                }
            }
        });

        self.thread_handle = Some(handle);

        Ok(())
    }
```

--------------------------------

### ADBServer Management

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.ADBServer.html

Methods for starting, stopping, and managing the ADB server process.

```APIDOC
## pub fn start(envs: &HashMap<String, String>, adb_path: &Option<String>)

### Description
Start an instance of `adb-server`.

### Method
`start`

### Parameters
- **envs** (&HashMap<String, String>) - Environment variables to set for the ADB server process.
- **adb_path** (&Option<String>) - An optional path to the ADB executable.
```

```APIDOC
## pub fn kill(&mut self) -> Result<()>

### Description
Asks the ADB server to quit immediately.

### Method
`kill`

### Returns
`Result<()>` indicating success or failure.
```

--------------------------------

### Get Available ADB Devices

Source: https://docs.rs/adb_client/latest/adb_client/server/index.html

Instantiates an ADBServer with a custom address and retrieves a list of available devices. Ensure the ADB server is running and accessible at the specified address.

```rust
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();
```

--------------------------------

### MDNSDiscoveryService::start

Source: https://docs.rs/adb_client/latest/adb_client/mdns/struct.MDNSDiscoveryService.html

Starts the mDNS discovery process. This method spawns a background thread to handle device discovery events.

```APIDOC
## MDNSDiscoveryService::start

### Description
Start discovery by spawning a new background thread responsible of getting events.

### Method
`pub fn start(&mut self, sender: Sender<MDNSDevice>) -> Result<()>`

### Parameters
- `sender` (Sender<MDNSDevice>): A sender to send discovered `MDNSDevice` events to.
```

--------------------------------

### Get List of Connected Devices (Short)

Source: https://docs.rs/adb_client/latest/src/adb_client/server/commands/devices.rs.html

Retrieves a concise list of connected ADB devices. Use this when only the device identifier is needed.

```rust
pub fn devices(&mut self) -> Result<Vec<DeviceShort>> {
        let devices = self
            .connect()? 
            .proxy_connection(&ADBCommand::Host(ADBHostCommand::Devices), true)?;

        let mut vec_devices: Vec<DeviceShort> = vec![];
        for device in devices.split(|x| x.eq(&b'\n')) {
            if device.is_empty() {
                break;
            }

            vec_devices.push(DeviceShort::try_from(device.to_vec())?);
        }

        Ok(vec_devices)
    }
```

--------------------------------

### Install APK on ADB Device

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Installs an Android application package (APK) onto the device. Optionally specifies the user to install for.

```rust
fn install(&mut self, apk_path: &dyn AsRef<Path>, user: Option<&str>) -> Result<()> {
        self.inner.install(apk_path, user)
    }
```

--------------------------------

### Initialize MDNSDiscoveryService

Source: https://docs.rs/adb_client/latest/src/adb_client/mdns/mdns_discovery.rs.html

Instantiates a new discovery service. Requires the `mdns-sd` crate.

```rust
pub fn new() -> Result<Self> {
        Ok(Self {
            daemon: ServiceDaemon::new()?,
            thread_handle: None,
        })
    }
```

--------------------------------

### Start Interactive Shell Session

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/commands/shell.rs.html

Initiates an interactive shell session on the device. Input is read from the provided `reader` and sent to the device, while output from the device is written to the `writer`.

```rust
pub(crate) fn shell(
        &mut self,
        reader: &mut dyn Read,
        writer: Box<dyn Write + Send>,
    ) -> Result<()> {
        self.bidirectional_session(&ADBLocalCommand::Shell, reader, writer)
    }
```

--------------------------------

### ADBServer::new

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Instantiates a new ADBServer with a specified listening address.

```APIDOC
## ADBServer::new

### Description
Instantiates a new [`ADBServer`] with a specified listening address.

### Signature
```rust
pub fn new(address: SocketAddrV4) -> Self
```

### Parameters
* `address` (SocketAddrV4) - The network address for the ADB server to listen on.
```

--------------------------------

### MDNSDiscoveryService::start

Source: https://docs.rs/adb_client/latest/src/adb_client/mdns/mdns_discovery.rs.html

Starts the mDNS discovery process. This spawns a background thread that listens for ADB service advertisements and sends discovered devices to the provided sender.

```APIDOC
## MDNSDiscoveryService::start

### Description
Starts discovery by spawning a new background thread responsible for getting mDNS service events.

### Parameters
#### Arguments
- `sender` (`Sender<MDNSDevice>`): A channel sender to send discovered `MDNSDevice` instances to.

### Returns
- `Result<()>`: Ok(()) on success, or an error if browsing for the ADB service fails.
```

--------------------------------

### ADBServer::new_from_path

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Instantiates a new ADBServer with a custom path to the ADB binary.

```APIDOC
## ADBServer::new_from_path

### Description
Instantiates a new [`ADBServer`] with a custom path to the ADB binary.

### Signature
```rust
pub fn new_from_path(address: SocketAddrV4, adb_path: Option<String>) -> Self
```

### Parameters
* `address` (SocketAddrV4) - The network address for the ADB server to listen on.
* `adb_path` (Option<String>) - An optional path to the ADB executable. If `None`, the ADB binary will be sought in the system's PATH.
```

--------------------------------

### Start Interactive Shell Session

Source: https://docs.rs/adb_client/latest/src/adb_client/adb_device_ext.rs.html

Initiates an interactive shell session on the device, allowing for real-time input and output. Data is read from a provided reader and written to a boxed writer.

```rust
/// 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<()>;

```

--------------------------------

### Run Activity

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Launches a specific `activity` from a given `package` on the device. Returns the command output as bytes.

```rust
fn run_activity( &mut self, package: &dyn AsRef<str>, activity: &dyn AsRef<str>, ) -> Result<Vec<u8>>
```

--------------------------------

### Start Interactive Shell Session

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Initiates an interactive shell session on the device. Input is read from `reader` and output is written to `writer`. This is suitable for multi-turn shell interactions.

```rust
fn shell( &mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>, ) -> Result<()>
```

--------------------------------

### ADBServer Instantiation

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.ADBServer.html

Provides methods to create a new ADBServer instance, either with a default socket address or with a custom ADB path.

```APIDOC
## pub fn new(address: SocketAddrV4) -> Self

### Description
Instantiates a new `ADBServer`.

### Method
`new`

### Parameters
- **address** (SocketAddrV4) - The socket address for the ADB server.

### Returns
A new instance of `ADBServer`.
```

```APIDOC
## pub fn new_from_path(address: SocketAddrV4, adb_path: Option<String>) -> Self

### Description
Instantiates a new `ADBServer` with a custom adb path.

### Method
`new_from_path`

### Parameters
- **address** (SocketAddrV4) - The socket address for the ADB server.
- **adb_path** (Option<String>) - An optional path to the ADB executable.

### Returns
A new instance of `ADBServer`.
```

--------------------------------

### Start Interactive Shell Session

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.ADBUSBDevice.html

Initiates an interactive shell session on the ADB device. Input is read from a provided `Read` trait object, and output is written to a `Write` trait object.

```rust
fn shell<'a>( &mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>, ) -> Result<()>
```

--------------------------------

### ADBTcpDevice Instantiation

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Methods for creating a new ADBTcpDevice instance.

```APIDOC
## pub fn new<A: Into<SocketAddr>>(address: A) -> Result<Self>

Instantiate a new `ADBTcpDevice`.

### Parameters
* `address`: The socket address of the device.

### Returns
A `Result` containing a new `ADBTcpDevice` instance or an error.
```

```APIDOC
## pub fn new_with_custom_private_key<P: AsRef<Path>, A: Into<SocketAddr>>( address: A, private_key_path: P, ) -> Result<Self>

Instantiate a new `ADBTcpDevice` using a custom private key path.

### Parameters
* `address`: The socket address of the device.
* `private_key_path`: The path to the custom private key.

### Returns
A `Result` containing a new `ADBTcpDevice` instance or an error.
```

--------------------------------

### Get Emulator Device (Single)

Source: https://docs.rs/adb_client/latest/src/adb_client/server/commands/devices.rs.html

Retrieves an ADB emulator device, assuming only one is connected. It first gets a single device and then attempts to convert it to an emulator device.

```rust
pub fn get_emulator_device(&mut self) -> Result<ADBEmulatorDevice> {
        let device = self.get_device()?;

        ADBEmulatorDevice::try_from(device)
    }
```

--------------------------------

### ADBServerDevice::new

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Instantiates a new ADBServerDevice with a given identifier and optional server address.

```APIDOC
## ADBServerDevice::new

### Description
Instantiates a new `ADBServerDevice`, knowing its ADB identifier (as returned by `adb devices` command).

### Signature
```rust
pub fn new(identifier: String, server_addr: Option<SocketAddrV4>) -> Self
```
```

--------------------------------

### Run Android Activity

Source: https://docs.rs/adb_client/latest/src/adb_client/adb_device_ext.rs.html

Starts an Android activity within a specified package on the device. Returns the command output, typically used for debugging or triggering specific app functions.

```rust
/// Run `activity` from `package` on device. Return the command output.
fn run_activity(
    &mut self,
    package: &dyn AsRef<str>,
    activity: &dyn AsRef<str>,
) -> Result<Vec<u8>> {
    let mut output = Vec::new();
    let _status = self.shell_command(
        &format!("am start {}/{}.{}", package.as_ref(), package.as_ref(), activity.as_ref()),
        Some(&mut output),
        None,
    )?;

    Ok(output)
}

```

--------------------------------

### Instantiate ADBTcpDevice with Default Key

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/tcp/adb_tcp_device.rs.html

Creates a new ADBTcpDevice using the default ADB private key path. Ensure the default key path is correctly configured.

```rust
pub fn new<A: Into<SocketAddr>>(address: A) -> Result<Self> {
        Self::new_with_custom_private_key(address, get_default_adb_key_path()?)
    }
```

--------------------------------

### AdbVersion::new

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.AdbVersion.html

A constructor function to create a new AdbVersion instance.

```APIDOC
### impl AdbVersion

#### pub const fn new(minor: u32, revision: u32) -> Self

Instantiates a new `AdbVersion`.
```

--------------------------------

### Get Socket Address

Source: https://docs.rs/adb_client/latest/src/adb_client/server/tcp_server_transport.rs.html

Retrieves the underlying SocketAddrV4 of the TCPServerTransport.

```rust
pub const fn get_socketaddr(&self) -> SocketAddrV4 {
    self.socket_addr
}
```

--------------------------------

### ADBUSBDevice::new

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Instantiates a new ADBUSBDevice using default private key path.

```APIDOC
## ADBUSBDevice::new

### Description
Instantiates a new [`ADBUSBDevice`] using the default ADB private key path.

### Signature
```rust
pub fn new(vendor_id: u16, product_id: u16) -> Result<Self>
```

### Parameters
* `vendor_id` (u16) - The vendor ID of the USB device.
* `product_id` (u16) - The product ID of the USB device.

### Returns
* `Result<Self>` - A `Result` containing the new `ADBUSBDevice` on success, or a `RustADBError` on failure.
```

--------------------------------

### AdbVersion::new

Source: https://docs.rs/adb_client/latest/src/adb_client/server/models/adb_version.rs.html

Instantiates a new AdbVersion with a default major version of 1.

```APIDOC
## Method: AdbVersion::new

### Description
Instantiates a new [`AdbVersion`]. The major version is hardcoded to 1.

### Signature
`pub const fn new(minor: u32, revision: u32) -> Self`

### Parameters
- **minor** (u32) - The minor version number.
- **revision** (u32) - The revision number.

### Returns
- `Self` - A new `AdbVersion` instance.
```

--------------------------------

### ADBServerDevice::stat

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Gets the stat information for a file on the device.

```APIDOC
## ADBServerDevice::stat

### Description
Stat file given as path on the device.

### Signature
```rust
pub fn stat<A: AsRef<str>>(&mut self, path: A) -> Result<AdbStatResponse>
```
```

--------------------------------

### Instantiate ADBMessageDevice

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/adb_message_device.rs.html

Creates a new ADBMessageDevice. It attempts to read a private key from the provided path; if none exists, it generates a new random one. The device then attempts to connect and authenticate.

```rust
pub fn new<P: AsRef<Path>>(transport: T, adb_private_key_path: P) -> Result<Self> {
        let private_key = if let Some(private_key) = read_adb_private_key(&adb_private_key_path)? {
            private_key
        } else {
            log::warn!(
                "No private key found at path {}. Generating a new random.",
                adb_private_key_path.as_ref().display()
            );
            ADBRsaKey::new_random()?
        };

        let mut message_device = Self { transport };
        message_device.connect(&private_key)?;

        Ok(message_device)
    }
```

--------------------------------

### Get Product ID of ADBUSBDevice

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.ADBUSBDevice.html

Returns the 16-bit product ID of the ADBUSBDevice.

```rust
pub const fn product_id(&self) -> u16
```

--------------------------------

### Get Vendor ID of ADBUSBDevice

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.ADBUSBDevice.html

Returns the 16-bit vendor ID of the ADBUSBDevice.

```rust
pub const fn vendor_id(&self) -> u16
```

--------------------------------

### Connect and Authenticate with Emulator

Source: https://docs.rs/adb_client/latest/src/adb_client/emulator/tcp_emulator_transport.rs.html

Establishes a TCP connection to the emulator, performs initial handshake by reading expected console messages, and then authenticates the connection.

```rust
fn connect(&mut self) -> Result<()> {
    if self.tcp_stream.is_none() {
        let stream = TcpStream::connect(self.socket_addr)?;

        log::trace!("Successfully connected to {}", self.socket_addr);

        self.tcp_stream = Some(stream.try_clone()?);

        let mut reader = BufReader::new(stream);

        // Android Console: Authentication required
        // Android Console: type 'auth <auth_token>' to authenticate
        // Android Console: you can find your <auth_token> in
        // '/home/xxx/.emulator_console_auth_token'
        for _ in 0..=4 {
            let mut line = String::new();
            reader.read_line(&mut line)?;
        }

        self.authenticate()?;

        log::trace!("Authentication successful");
    }

    Ok(())
}
```

--------------------------------

### Instantiate MDNSDiscoveryService

Source: https://docs.rs/adb_client/latest/adb_client/mdns/struct.MDNSDiscoveryService.html

Creates a new instance of the discovery service for finding devices over mDNS. This method returns a Result, indicating potential errors during instantiation.

```rust
pub fn new() -> Result<Self>
```

--------------------------------

### Get Framebuffer

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/adb_server_device_commands.rs.html

Retrieves the framebuffer content of the device, typically used for screen capturing.

```APIDOC
## framebuffer_inner

### Description
Retrieves the framebuffer content of the device, typically used for screen capturing.

### Method
`framebuffer_inner(&mut self) -> Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>>`

### Returns
- `Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>>`: An image buffer representing the framebuffer on success, or an error if the operation fails.
```

--------------------------------

### Connect to USB Device

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/usb_transport.rs.html

Establishes a connection to a USB device, finds and configures the necessary read and write endpoints, and stores the device handle.

```rust
fn connect(&mut self) -> crate::Result<()> {
        let device = self.device.open()?;

        let (read_endpoint, write_endpoint) = Self::find_endpoints(&device)?;

        Self::configure_endpoint(&device, &read_endpoint)?;
        log::debug!("got read endpoint: {read_endpoint:?}");
        self.read_endpoint = Some(read_endpoint);

        Self::configure_endpoint(&device, &write_endpoint)?;
        log::debug!("got write endpoint: {write_endpoint:?}");
        self.write_endpoint = Some(write_endpoint);

        self.handle = Some(Arc::new(device));

        Ok(())
    }
```

--------------------------------

### Get Framebuffer

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Retrieves the framebuffer of the device as an RGBA image buffer. This operation is inline.

```rust
fn framebuffer_inner(&mut self) -> Result<image::ImageBuffer<image::Rgba<u8>, Vec<u8>>> {
        self.inner.framebuffer_inner()
    }
```

--------------------------------

### Get remote ID from ADBSession

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/adb_session.rs.html

Returns the remote session identifier. This is a const function.

```rust
pub const fn remote_id(&self) -> u32 {
        self.remote_id
    }
```

--------------------------------

### Get local ID from ADBSession

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/adb_session.rs.html

Returns the local session identifier. This is a const function.

```rust
pub const fn local_id(&self) -> u32 {
        self.local_id
    }
```

--------------------------------

### Instantiate USBTransport by Vendor and Product ID

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/usb_transport.rs.html

Creates a new USBTransport by searching for the first available USB device matching the provided vendor and product IDs. Returns an error if no such device is found.

```rust
pub fn new(vendor_id: u16, product_id: u16) -> Result<Self> {
        let context = Context::new()?;
        for device in context.devices()?.iter() {
            if let Ok(descriptor) = device.device_descriptor()
                && descriptor.vendor_id() == vendor_id
                && descriptor.product_id() == product_id
            {
                return Ok(Self::new_from_device(device));
            }
        }

        Err(RustADBError::DeviceNotFound(format!(
            "cannot find USB device with vendor_id={vendor_id} and product_id={product_id}",
        )))
    }
```

--------------------------------

### ADBUSBDevice Instantiation

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.ADBUSBDevice.html

Methods for creating a new ADBUSBDevice instance.

```APIDOC
## ADBUSBDevice

Represent a device reached and available over USB.

### Instantiation

#### `new(vendor_id: u16, product_id: u16) -> Result<Self>`
Instantiate a new `ADBUSBDevice`.

#### `new_with_custom_private_key<P: AsRef<Path>>(vendor_id: u16, product_id: u16, private_key_path: P) -> Result<Self>`
Instantiate a new `ADBUSBDevice` using a custom private key path.

#### `new_from_transport(transport: USBTransport, private_key_path: Option<PathBuf>) -> Result<Self>`
Instantiate a new `ADBUSBDevice` from a `USBTransport` and an optional private key path.
```

--------------------------------

### Server Address Retrieval

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.ADBServer.html

Method to get the configured socket address of the ADB server.

```APIDOC
## pub const fn socket_addr(&self) -> Option<SocketAddrV4>

### Description
Get the server address.

### Method
`socket_addr`

### Returns
`Option<SocketAddrV4>` containing the server's socket address if configured.
```

--------------------------------

### Get Server Socket Address

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Returns the configured socket address for the ADB server. This is a constant function.

```rust
pub const fn socket_addr(&self) -> Option<SocketAddrV4> {
    self.socket_addr
}
```

--------------------------------

### Instantiate ADBUSBDevice with Default Private Key

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Creates a new ADBUSBDevice using the default ADB private key path. Use this when a custom key path is not required.

```rust
pub fn new(vendor_id: u16, product_id: u16) -> Result<Self> {
        Self::new_with_custom_private_key(vendor_id, product_id, get_default_adb_key_path()?)
    }
```

--------------------------------

### Device Listing and Retrieval

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.ADBServer.html

Methods to get lists of connected devices or specific devices based on criteria.

```APIDOC
## pub fn devices(&mut self) -> Result<Vec<DeviceShort>>

### Description
Gets a list of connected devices.

### Method
`devices`

### Returns
`Result<Vec<DeviceShort>>` containing a list of short device representations.
```

```APIDOC
## pub fn devices_long(&mut self) -> Result<Vec<DeviceLong>>

### Description
Gets an extended list of connected devices including the device paths in the state.

### Method
`devices_long`

### Returns
`Result<Vec<DeviceLong>>` containing a list of long device representations.
```

```APIDOC
## pub fn get_device(&mut self) -> Result<ADBServerDevice>

### Description
Get a device, assuming that only this device is connected.

### Method
`get_device`

### Returns
`Result<ADBServerDevice>` representing the single connected device.
```

```APIDOC
## pub fn get_device_by_name(&mut self, name: &str) -> Result<ADBServerDevice>

### Description
Get a device matching the given name, if existing.
There is no device connected => Error
There is a single device connected => Ok
There are more than 1 device connected => Error

### Method
`get_device_by_name`

### Parameters
- **name** (&str) - The name of the device to retrieve.

### Returns
`Result<ADBServerDevice>` representing the matching device.
```

```APIDOC
## pub fn get_emulator_device(&mut self) -> Result<ADBEmulatorDevice>

### Description
Get an emulator, assuming that only this device is connected.

### Method
`get_emulator_device`

### Returns
`Result<ADBEmulatorDevice>` representing the single connected emulator.
```

```APIDOC
## pub fn get_emulator_device_by_name(&mut self, name: &str) -> Result<ADBEmulatorDevice>

### Description
Get an emulator by its name.

### Method
`get_emulator_device_by_name`

### Parameters
- **name** (&str) - The name of the emulator to retrieve.

### Returns
`Result<ADBEmulatorDevice>` representing the matching emulator.
```

--------------------------------

### ADBTcpDevice::new

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/tcp/adb_tcp_device.rs.html

Creates a new ADBTcpDevice instance using the default ADB private key path.

```APIDOC
## new<A: Into<SocketAddr>>(address: A) -> Result<Self>

### Description
Instantiate a new [`ADBTcpDevice`] using the default ADB key path.

### Parameters
* `address` (A: Into<SocketAddr>) - The network address of the ADB device.

### Returns
* `Result<Self>` - A `Result` containing the new `ADBTcpDevice` instance or an error.
```

--------------------------------

### shell

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Starts an interactive shell session on the device. Input data is read from reader and write to writer.

```APIDOC
## shell

### Description
Starts an interactive shell session on the device. Input data is read from reader and write to writer.

### Signature
`fn shell( &mut self, reader: &mut dyn Read, writer: Box<dyn Write + Send>, ) -> Result<()>`
```

--------------------------------

### Get mutable transport from ADBSession

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/adb_session.rs.html

Provides mutable access to the underlying ADB transport layer. This is a const function.

```rust
pub const fn get_transport_mut(&mut self) -> &mut T {
        &mut self.transport
    }
```

--------------------------------

### Get Emulator Authentication Token

Source: https://docs.rs/adb_client/latest/src/adb_client/emulator/tcp_emulator_transport.rs.html

Retrieves the authentication token from the `$HOME/.emulator_console_auth_token` file. This is necessary for authenticating with the emulator console.

```rust
fn get_authentication_token() -> Result<String> {
    let Some(home) = std::env::home_dir() else {
        return Err(RustADBError::NoHomeDirectory);
    };

    let mut f = File::open(home.join(".emulator_console_auth_token"))?;
    let mut token = String::new();
    f.read_to_string(&mut token)?;

    Ok(token)
}
```

--------------------------------

### Get Framebuffer (Inner)

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

An inner method for requesting the framebuffer from an Android device. It returns the raw image buffer.

```rust
fn framebuffer_inner(&mut self) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>>
```

--------------------------------

### Instantiate USBTransport with Vendor and Product IDs

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.USBTransport.html

Creates a new USBTransport instance by searching for the first available USB device matching the provided vendor and product IDs. Requires the 'usb' feature flag.

```rust
pub fn new(vendor_id: u16, product_id: u16) -> Result<Self>
```

--------------------------------

### Get Emulator gRPC Port

Source: https://docs.rs/adb_client/latest/adb_client/emulator/struct.ADBEmulatorDevice.html

Fetches the gRPC port number for the emulator. This operation requires mutable access.

```rust
pub fn avd_grpc_port(&mut self) -> Result<u16>
```

--------------------------------

### New ADBServer Instance with Custom Path

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Creates a new ADBServer instance with a specified socket address and an optional custom path to the ADB binary.

```rust
pub fn new_from_path(address: SocketAddrV4, adb_path: Option<String>) -> Self {
    Self {
        transport: None,
        socket_addr: Some(address),
        envs: HashMap::new(),
        adb_path,
    }
}
```

--------------------------------

### Get Read Endpoint Configuration

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/usb_transport.rs.html

Retrieves the configured read endpoint details. Returns an error if no read endpoint has been set up.

```rust
fn get_read_endpoint(&self) -> Result<Endpoint> {
        self.read_endpoint
            .as_ref()
            .ok_or(RustADBError::IOError(std::io::Error::new(
                std::io::ErrorKind::NotConnected,
                "no read endpoint setup",
            )))
            .cloned()
    }
```

--------------------------------

### run_activity

Source: https://docs.rs/adb_client/latest/adb_client/server_device/struct.ADBServerDevice.html

Run `activity` from `package` on device. Return the command output.

```APIDOC
## run_activity

### Description
Run `activity` from `package` on device. Return the command output.

### Signature
`fn run_activity( &mut self, package: &dyn AsRef<str>, activity: &dyn AsRef<str>, ) -> Result<Vec<u8>>`
```

--------------------------------

### ADBServerDevice handle_recv_command method

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/commands/recv.rs.html

Handles the ADB receive command by sending the path to the file/stream and then copying data from the device to the output stream using `ADBRecvCommandReader`.

```rust
fn handle_recv_command<S: AsRef<str>>(&self, from: S, output: &mut dyn Write) -> Result<()> {
    let mut raw_connection = self.transport.get_raw_connection()?;

    let from_as_bytes = from.as_ref().as_bytes();
    let mut buffer = Vec::with_capacity(4 + from_as_bytes.len());
    buffer.extend_from_slice(&(u32::try_from(from.as_ref().len())?).to_le_bytes());
    buffer.extend_from_slice(from_as_bytes);
    raw_connection.write_all(&buffer)?;

    let reader = ADBRecvCommandReader::new(raw_connection);
    std::io::copy(
        &mut BufReader::with_capacity(BUFFER_SIZE, reader),
        &mut BufWriter::with_capacity(BUFFER_SIZE, output),
    )?;

    // Connection should've been left in SYNC mode by now
    Ok(())
}
```

--------------------------------

### Get Mutable Transport Reference

Source: https://docs.rs/adb_client/latest/src/adb_client/server/adb_server.rs.html

Retrieves a mutable reference to the internal transport layer. Returns an error if the transport has not been initialized.

```rust
pub(crate) fn get_transport(&mut self) -> Result<&mut TCPServerTransport> {
    self.transport
        .as_mut()
        .ok_or(RustADBError::IOError(std::io::Error::new(
            std::io::ErrorKind::NotConnected,
            "server connection not initialized",
        )))
}
```

--------------------------------

### MDNSDiscoveryService::new

Source: https://docs.rs/adb_client/latest/src/adb_client/mdns/mdns_discovery.rs.html

Instantiates a new MDNSDiscoveryService. This sets up the underlying mDNS daemon for browsing services.

```APIDOC
## MDNSDiscoveryService::new

### Description
Instantiates a new discovery service to find devices over mdns.

### Returns
- `Result<Self>`: A new instance of `MDNSDiscoveryService` on success, or an error if the mDNS daemon cannot be created.
```

--------------------------------

### Get Raw TCP Connection

Source: https://docs.rs/adb_client/latest/src/adb_client/emulator/tcp_emulator_transport.rs.html

Provides access to the underlying raw TCP stream. Returns an error if not currently connected.

```rust
pub(crate) fn get_raw_connection(&self) -> Result<&TcpStream> {
    self.tcp_stream
        .as_ref()
        .ok_or(RustADBError::IOError(Error::new(
            ErrorKind::NotConnected,
            "not connected",
        )))
}
```

--------------------------------

### Instantiate ADBUSBDevice with Custom Private Key

Source: https://docs.rs/adb_client/latest/adb_client/usb/struct.ADBUSBDevice.html

Creates a new ADBUSBDevice instance using the device's vendor and product IDs, along with a custom path to the private key file for authentication.

```rust
pub fn new_with_custom_private_key<P: AsRef<Path>>( vendor_id: u16, product_id: u16, private_key_path: P, ) -> Result<Self>
```

--------------------------------

### Get Framebuffer as Bytes

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Retrieves the device's framebuffer content as a byte vector. This is useful for programmatic image processing.

```rust
fn framebuffer_bytes(&mut self) -> Result<Vec<u8>>
```

--------------------------------

### Get AVD Discovery Path

Source: https://docs.rs/adb_client/latest/adb_client/emulator/struct.ADBEmulatorDevice.html

Retrieves the AVD discovery path for the emulator. This method requires mutable access to the device.

```rust
pub fn avd_discovery_path(&mut self) -> Result<PathBuf>
```

--------------------------------

### Instantiate ADBTcpDevice

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Creates a new ADBTcpDevice instance. Use this when connecting to a device over TCP.

```rust
pub fn new<A: Into<SocketAddr>>(address: A) -> Result<Self>
```

--------------------------------

### Instantiate ADBServerDevice with Identifier

Source: https://docs.rs/adb_client/latest/src/adb_client/server_device/adb_server_device.rs.html

Creates a new ADBServerDevice instance with a specific device identifier and an optional server address. Use when the device identifier is known.

```rust
pub fn new(identifier: String, server_addr: Option<SocketAddrV4>) -> Self {
        let transport = TCPServerTransport::new_or_default(server_addr);

        Self {
            identifier: Some(identifier),
            transport,
        }
    }
```

--------------------------------

### Get Hex Body Length

Source: https://docs.rs/adb_client/latest/src/adb_client/server/tcp_server_transport.rs.html

Reads 4 bytes from the connection, interprets them as a hexadecimal string, and returns the body length as a u32.

```rust
pub(crate) fn get_hex_body_length(&self) -> Result<u32> {
    let length_buffer = self.read_body_length()?;
    Ok(u32::from_str_radix(
        std::str::from_utf8(&length_buffer)?,
        16,
    )?)
}
```

--------------------------------

### Get Device by Name

Source: https://docs.rs/adb_client/latest/src/adb_client/server/commands/devices.rs.html

Retrieves a specific device by its name. Returns an error if the device is not found or if multiple devices with the same name exist.

```APIDOC
## get_device_by_name

### Description
Get a device matching the given name, if existing.
- There is no device connected => Error
- There is a single device connected => Ok
- There are more than 1 device connected => Error

### Method
`pub fn get_device_by_name(&mut self, name: &str) -> Result<ADBServerDevice>`

### Parameters
* **name** (`&str`) - The identifier of the device to retrieve.

### Returns
A `Result` containing an `ADBServerDevice` if a single device matches the name, or a `RustADBError` if no device is found or multiple devices match.

### Request Example
```rust
let mut adb_server = ADBServer::new();
let device = adb_server.get_device_by_name("emulator-5554")?;
```

### Response Example
```json
{
  "identifier": "emulator-5554",
  "socket_addr": "127.0.0.1:5037"
}
```
```

--------------------------------

### Instantiate AdbVersion

Source: https://docs.rs/adb_client/latest/adb_client/server/struct.AdbVersion.html

Creates a new AdbVersion instance with specified minor and revision numbers. The major version is fixed.

```rust
pub const fn new(minor: u32, revision: u32) -> Self
```

--------------------------------

### Instantiate ADBTcpDevice with Custom Private Key

Source: https://docs.rs/adb_client/latest/adb_client/tcp/struct.ADBTcpDevice.html

Creates a new ADBTcpDevice instance using a custom private key path for authentication. This is useful for specific security configurations.

```rust
pub fn new_with_custom_private_key<P: AsRef<Path>, A: Into<SocketAddr>>( address: A, private_key_path: P, ) -> Result<Self>
```

--------------------------------

### Get Write Endpoint Configuration

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/usb_transport.rs.html

Retrieves a reference to the configured write endpoint details. Returns an error if no write endpoint has been set up.

```rust
fn get_write_endpoint(&self) -> Result<&Endpoint> {
        self.write_endpoint
            .as_ref()
            .ok_or(RustADBError::IOError(std::io::Error::new(
                std::io::ErrorKind::NotConnected,
                "no write endpoint setup",
            )))
    }
```

--------------------------------

### Get File Status (stat)

Source: https://docs.rs/adb_client/latest/src/adb_client/message_devices/usb/adb_usb_device.rs.html

Retrieves file status information (like size, modification time) for a given path on the ADB device.

```rust
fn stat(&mut self, remote_path: &dyn AsRef<str>) -> Result<crate::AdbStatResponse> {
        self.inner.stat(remote_path)
    }
```

--------------------------------

### TryFrom<ADBServerDevice> for ADBEmulatorDevice

Source: https://docs.rs/adb_client/latest/src/adb_client/emulator/adb_emulator_device.rs.html

Provides a way to convert an ADBServerDevice into an ADBEmulatorDevice.

```APIDOC
## TryFrom<ADBServerDevice> for ADBEmulatorDevice

### Description
Provides a way to convert an `ADBServerDevice` into an `ADBEmulatorDevice`. This is useful when you have a generic `ADBServerDevice` and want to treat it specifically as an emulator.

### Parameters
- `value` (ADBServerDevice) - The `ADBServerDevice` to convert.

### Returns
- `Result<Self>` - A new `ADBEmulatorDevice` instance if the conversion is successful, or a `RustADBError` if the `ADBServerDevice` identifier is missing or cannot be parsed.
```

--------------------------------

### Get Connected Devices (Long List)

Source: https://docs.rs/adb_client/latest/src/adb_client/server/commands/devices.rs.html

Retrieves an extended list of connected devices, including additional details like device paths.

```APIDOC
## devices_long

### Description
Gets an extended list of connected connected devices including the device paths in the state.

### Method
`pub fn devices_long(&mut self) -> Result<Vec<DeviceLong>>`

### Parameters
None

### Returns
A `Result` containing a `Vec<DeviceLong>` on success, or a `RustADBError` on failure.

### Request Example
```rust
let mut adb_server = ADBServer::new();
let devices_long = adb_server.devices_long()?;
```

### Response Example
```json
[
  {
    "identifier": "emulator-5554",
    "state": "device",
    "path": "/dev/pts/3"
  }
]
```
```
Tokens:
Raw