adb_cli 3.2.3

Rust ADB (Android Debug Bridge) CLI
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
85
86
87
88

use adb_client::{
    Result,
    server::{ADBServer, DeviceShort, MDNSBackend, WaitForDeviceState},
};

use crate::models::{HostCommand, MdnsCommand, ServerCommand};

pub fn handle_host_commands(server_command: ServerCommand<HostCommand>) -> Result<()> {
    let mut adb_server = ADBServer::new(server_command.address);

    match server_command.command {
        HostCommand::Version => {
            let version = adb_server.version()?;
            log::info!("Android Debug Bridge version {version}");
            log::info!("Package version {}-rust", std::env!("CARGO_PKG_VERSION"));
        }
        HostCommand::Kill => {
            adb_server.kill()?;
        }
        HostCommand::Devices { long } => {
            if long {
                log::info!("List of devices attached (extended)");
                for device in adb_server.devices_long()? {
                    log::info!("{device}");
                }
            } else {
                log::info!("List of devices attached");
                for device in adb_server.devices()? {
                    log::info!("{device}");
                }
            }
        }
        HostCommand::TrackDevices => {
            let callback = |device: DeviceShort| {
                log::info!("{device}");
                Ok(())
            };
            log::info!("Live list of devices attached");
            adb_server.track_devices(callback)?;
        }
        HostCommand::Pair { address, code } => {
            adb_server.pair(address, code)?;
            log::info!("Paired device {address}");
        }
        HostCommand::Connect { address } => {
            adb_server.connect_device(address)?;
            log::info!("Connected to {address}");
        }
        HostCommand::Disconnect { address } => {
            adb_server.disconnect_device(address)?;
            log::info!("Disconnected {address}");
        }
        HostCommand::Mdns { subcommand } => match subcommand {
            MdnsCommand::Check => {
                let check = adb_server.mdns_check()?;
                let server_status = adb_server.server_status()?;
                match server_status.mdns_backend {
                    MDNSBackend::Unknown => log::info!("unknown mdns backend..."),
                    MDNSBackend::Bonjour => {
                        if check {
                            log::info!("mdns daemon version [Bonjour]");
                        } else {
                            log::info!("ERROR: mdns daemon unavailable");
                        }
                    }
                    MDNSBackend::OpenScreen => {
                        log::info!("mdns daemon version [Openscreen discovery 0.0.0]");
                    }
                }
            }
            MdnsCommand::Services => {
                log::info!("List of discovered mdns services");
                for service in adb_server.mdns_services()? {
                    log::info!("{service}");
                }
            }
        },
        HostCommand::ServerStatus => {
            log::info!("{}", adb_server.server_status()?);
        }
        HostCommand::WaitForDevice { transport } => {
            log::info!("waiting for device to be connected...");
            adb_server.wait_for_device(WaitForDeviceState::Device, transport)?;
        }
    }

    Ok(())
}