Struct adb_utils::manager::ADBManager

source · 
pub struct ADBManager { /* private fields */ }
Expand description

Center struct where adb commands are built, sent and parsed

Implementations§

source§

impl ADBManager

source

pub fn new() -> ADBManager

Examples found in repository?
examples/networking/pair.rs (line 10)
9
10
11
12
13
14
15
16
17
18

fn main() {
    let manager = ADBManager::new();

    let mut pair = ADBPair::new("192.168.1.132".to_owned(), 42219, 562813);
    let result = manager.execute(&mut pair);
    match result {
        Ok(ok) => println!("Connected: {ok}"),
        Err(err) => println!("Could not connect: {err}"),
    }
}
More examples
Hide additional examples
examples/file_transfer/pull.rs (line 10)
9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut pull = ADBPull::new("/storage/emulated/0/DCIM/IMG_00000001.jpg", ".");
    match manager.execute_path_based(&mut pull) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
examples/shell/list_files.rs (line 10)
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 35659) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }
    manager.cwd("/storage/emulated/0");

    let mut list = ADBList::default();
    match manager.execute_path_based(&mut list) {
        Ok(ok) => println!("{}", ok),
        Err(err) => println!("Error: {}", err),
    }
}
examples/file_transfer/push.rs (line 10)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.1.132", 40785) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    manager.cwd("C:\\Users\\Radu\\Desktop");
    let mut push = ADBPush::new("sample.txt", "/storage/emulated/0/sample.txt")
        .compression(CompressionAlgorithm::Brotli);
    match manager.execute_path_based(&mut push) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
examples/general/general_info.rs (line 11)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut list = ADBDevices::default().long();
    match manager.execute(&mut list) {
        Ok(ok) => {
            println!("{}", ok.to_string());

            let parsed = DeviceInfo::from(ok);
            println!(
                "{} {} {}",
                parsed.product, parsed.model, parsed.transport_id
            );
        }
        Err(err) => println!("Error: {}", err),
    }

    let mut help = ADBHelp::default();
    println!("{}", manager.execute(&mut help).unwrap().to_string());

    let mut version = ADBVersion::default();
    let version = Version::from(manager.execute(&mut version).unwrap());
    println!(
        "adb version: {}, version: {}, install: {}",
        version.adb_version, version.version, version.install_path
    );
}
source

pub fn connect(&mut self, ip: &str, port: u32) -> Result<(), String>

Establish a connection to a device via TCP/IP

Examples found in repository?
examples/file_transfer/pull.rs (line 11)
9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut pull = ADBPull::new("/storage/emulated/0/DCIM/IMG_00000001.jpg", ".");
    match manager.execute_path_based(&mut pull) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
More examples
Hide additional examples
examples/shell/list_files.rs (line 11)
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 35659) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }
    manager.cwd("/storage/emulated/0");

    let mut list = ADBList::default();
    match manager.execute_path_based(&mut list) {
        Ok(ok) => println!("{}", ok),
        Err(err) => println!("Error: {}", err),
    }
}
examples/file_transfer/push.rs (line 11)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.1.132", 40785) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    manager.cwd("C:\\Users\\Radu\\Desktop");
    let mut push = ADBPush::new("sample.txt", "/storage/emulated/0/sample.txt")
        .compression(CompressionAlgorithm::Brotli);
    match manager.execute_path_based(&mut push) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
examples/general/general_info.rs (line 12)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut list = ADBDevices::default().long();
    match manager.execute(&mut list) {
        Ok(ok) => {
            println!("{}", ok.to_string());

            let parsed = DeviceInfo::from(ok);
            println!(
                "{} {} {}",
                parsed.product, parsed.model, parsed.transport_id
            );
        }
        Err(err) => println!("Error: {}", err),
    }

    let mut help = ADBHelp::default();
    println!("{}", manager.execute(&mut help).unwrap().to_string());

    let mut version = ADBVersion::default();
    let version = Version::from(manager.execute(&mut version).unwrap());
    println!(
        "adb version: {}, version: {}, install: {}",
        version.adb_version, version.version, version.install_path
    );
}
source

pub fn cwd(&mut self, path: &str)

Set the current working directory for all future commands where a path on the remote is needed

Examples found in repository?
examples/shell/list_files.rs (line 15)
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 35659) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }
    manager.cwd("/storage/emulated/0");

    let mut list = ADBList::default();
    match manager.execute_path_based(&mut list) {
        Ok(ok) => println!("{}", ok),
        Err(err) => println!("Error: {}", err),
    }
}
More examples
Hide additional examples
examples/file_transfer/push.rs (line 16)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.1.132", 40785) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    manager.cwd("C:\\Users\\Radu\\Desktop");
    let mut push = ADBPush::new("sample.txt", "/storage/emulated/0/sample.txt")
        .compression(CompressionAlgorithm::Brotli);
    match manager.execute_path_based(&mut push) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
source

pub fn execute(&self, cmd: &mut impl ADBCommand) -> Result<ADBResult, String>

Execute an arbitrary command

Examples found in repository?
examples/networking/pair.rs (line 13)
9
10
11
12
13
14
15
16
17
18

fn main() {
    let manager = ADBManager::new();

    let mut pair = ADBPair::new("192.168.1.132".to_owned(), 42219, 562813);
    let result = manager.execute(&mut pair);
    match result {
        Ok(ok) => println!("Connected: {ok}"),
        Err(err) => println!("Could not connect: {err}"),
    }
}
More examples
Hide additional examples
examples/general/general_info.rs (line 18)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut list = ADBDevices::default().long();
    match manager.execute(&mut list) {
        Ok(ok) => {
            println!("{}", ok.to_string());

            let parsed = DeviceInfo::from(ok);
            println!(
                "{} {} {}",
                parsed.product, parsed.model, parsed.transport_id
            );
        }
        Err(err) => println!("Error: {}", err),
    }

    let mut help = ADBHelp::default();
    println!("{}", manager.execute(&mut help).unwrap().to_string());

    let mut version = ADBVersion::default();
    let version = Version::from(manager.execute(&mut version).unwrap());
    println!(
        "adb version: {}, version: {}, install: {}",
        version.adb_version, version.version, version.install_path
    );
}
source

pub fn execute_path_based( &self, cmd: &mut impl ADBPathCommand ) -> Result<ADBResult, String>

Execute an arbitrary path command

Examples found in repository?
examples/file_transfer/pull.rs (line 17)
9
10
11
12
13
14
15
16
17
18
19
20
21

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 33363) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    let mut pull = ADBPull::new("/storage/emulated/0/DCIM/IMG_00000001.jpg", ".");
    match manager.execute_path_based(&mut pull) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
More examples
Hide additional examples
examples/shell/list_files.rs (line 18)
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.0.105", 35659) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }
    manager.cwd("/storage/emulated/0");

    let mut list = ADBList::default();
    match manager.execute_path_based(&mut list) {
        Ok(ok) => println!("{}", ok),
        Err(err) => println!("Error: {}", err),
    }
}
examples/file_transfer/push.rs (line 19)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fn main() {
    let mut manager = ADBManager::new();
    match manager.connect("192.168.1.132", 40785) {
        Ok(()) => println!("Successfully connected"),
        Err(e) => println!("Could not connect: {}", e),
    }

    manager.cwd("C:\\Users\\Radu\\Desktop");
    let mut push = ADBPush::new("sample.txt", "/storage/emulated/0/sample.txt")
        .compression(CompressionAlgorithm::Brotli);
    match manager.execute_path_based(&mut push) {
        Ok(ok) => println!("{ok}"),
        Err(err) => println!("error {err}"),
    }
}
source

pub fn disconnect(&mut self, ip: &str, port: u32)

Disconnect from given TCP/IP device

source

pub fn disconnect_all(&mut self)

Disconnect all connected devices

Trait Implementations§

source§

impl Default for ADBManager

source§

fn default() -> ADBManager

Returns the “default value” for a type. Read more
source§

impl Drop for ADBManager

source§

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.