radb 0.1.8

A Rust Implement Python AdbUtils
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

use crate::errors::{AdbError, AdbResult};
use crate::protocols::frame;
use async_trait::async_trait;
use log::info;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};

#[async_trait]
pub trait AdbProtocol: AsyncRead + AsyncWrite + Unpin + Send {
    async fn send_command(&mut self, command: &str) -> AdbResult<()> {
        let packet = frame::build_command_packet(command);
        self.send_all(&packet).await
    }

    async fn send(&mut self, data: &[u8]) -> AdbResult<usize> {
        self.send_all(data).await?;
        Ok(data.len())
    }

    async fn send_all(&mut self, data: &[u8]) -> AdbResult<()> {
        info!(">>>>>>> Send Size: {:#?} >>>>>>>", data.len());
        self.write_all(data).await?;
        Ok(())
    }

    async fn recv(&mut self, n: usize) -> AdbResult<Vec<u8>> {
        self.recv_exact(n).await
    }

    async fn recv_exact(&mut self, n: usize) -> AdbResult<Vec<u8>> {
        info!("<<<<<<< Try Recv Exact Size: {:#?} <<<<<<<", n);
        let mut target = vec![0; n];
        self.read_exact(&mut target).await?;
        Ok(target)
    }

    async fn read_string(&mut self, size: usize) -> AdbResult<String> {
        let data = self.recv_exact(size).await?;
        Ok(String::from_utf8_lossy(&data).to_string())
    }

    async fn read_response(&mut self) -> AdbResult<String> {
        let length_buf = self.recv_exact(4).await?;
        let length = frame::parse_length_prefix(&length_buf)?;
        let data_buf = self.recv_exact(length).await?;
        Ok(String::from_utf8_lossy(&data_buf).to_string())
    }

    async fn send_cmd_then_check_okay(&mut self, command: &str) -> AdbResult<()> {
        self.send_command(command).await?;
        let response = self.recv_exact(4).await?;

        if frame::is_okay_response(&response) {
            Ok(())
        } else if frame::is_fail_response(&response) {
            let error_msg = self.read_response().await?;
            Err(AdbError::command_failed(command, error_msg))
        } else {
            Err(AdbError::protocol_error("Unexpected response"))
        }
    }

    async fn read_until_close(&mut self) -> AdbResult<String> {
        let mut content = Vec::new();
        let mut buf = vec![0; 4096];
        loop {
            let bytes_read = self.read(&mut buf).await?;
            if bytes_read == 0 {
                break;
            }
            content.extend_from_slice(&buf[..bytes_read]);
        }
        Ok(String::from_utf8_lossy(&content).to_string())
    }
}

#[async_trait]
impl<T> AdbProtocol for T where T: AsyncRead + AsyncWrite + Unpin + Send {}