adb_client 3.2.0

Rust ADB (Android Debug Bridge) client library
Documentation 
1
2
3
4
5
6
7
8
9
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::fmt::Display;

use crate::RebootType;

/// ADB commands that relates to an actual device.
pub enum ADBLocalCommand {
    ShellCommand(String, Vec<String>),
    Shell,
    Exec(String),
    FrameBuffer,
    Sync,
    Reboot(RebootType),
    Forward(String, String),
    ForwardRemoveAll,
    Reverse(String, String),
    ReverseRemoveAll,
    Reconnect,
    Remount,
    DisableVerity,
    EnableVerity,
    Uninstall(String, Option<String>),
    Install(u64, Option<String>),
    TcpIp(u16),
    Usb,
    Root,
}

impl Display for ADBLocalCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Sync => write!(f, "sync:"),
            Self::ShellCommand(command, shell_args) => {
                if shell_args.is_empty() {
                    // Shell v1: simple format for older ADB versions
                    write!(f, "shell:{command}")
                } else {
                    // Shell v2: with arguments
                    let args_s = shell_args.join(",");
                    write!(f, "shell,{args_s},raw:{command}")
                }
            }
            Self::Shell => match std::env::var("TERM") {
                Ok(term) => write!(f, "shell,TERM={term},raw:"),
                Err(_) => write!(f, "shell,raw:"),
            },
            Self::Exec(command) => write!(f, "exec:{command}"),
            Self::Reboot(reboot_type) => {
                write!(f, "reboot:{reboot_type}")
            }
            Self::Uninstall(package, user) => {
                write!(f, "exec:cmd package 'uninstall'")?;
                if let Some(user) = user {
                    write!(f, " --user {user}")?;
                }
                write!(f, " {package}")
            }
            Self::FrameBuffer => write!(f, "framebuffer:"),
            Self::Install(size, user) => {
                write!(f, "exec:cmd package 'install'")?;
                if let Some(user) = user {
                    write!(f, " --user {user}")?;
                }
                write!(f, " -S {size}")
            }
            Self::Forward(remote, local) => {
                write!(f, "host:forward:{local};{remote}")
            }
            Self::ForwardRemoveAll => write!(f, "host:killforward-all"),
            Self::Reverse(remote, local) => {
                write!(f, "reverse:forward:{remote};{local}")
            }
            Self::ReverseRemoveAll => write!(f, "reverse:killforward-all"),
            Self::Reconnect => write!(f, "reconnect"),
            Self::Remount => write!(f, "remount:"),
            Self::DisableVerity => write!(f, "disable-verity:"),
            Self::EnableVerity => write!(f, "enable-verity:"),
            Self::TcpIp(port) => {
                write!(f, "tcpip:{port}")
            }
            Self::Usb => write!(f, "usb:"),
            Self::Root => write!(f, "root:"),
        }
    }
}