pidcat 0.2.1

An adb logcat wrapper and filters
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use anyhow::Result;
use clap::builder::PossibleValue;
use clap::ValueEnum;
use futures::Stream;
use std::error::Error;
use std::fmt::{Display, Formatter};
use std::pin::Pin;
use std::str::FromStr;

///
/// Wrapping of Adb logs.
///
#[derive(Debug, Clone)]
pub struct Log {
    /// Log date
    pub date: String,
    /// Log time
    pub time: String,
    /// Log pid
    pub pid: String,
    /// Log tid
    pub tid: String,
    /// Log level
    pub level: String,
    /// Log tag
    pub tag: String,
    /// Log message, stored in branches, split with '\n'
    pub message: String,
    /// Log buffer, contains  'main', 'system', 'radio', 'events', 'crash'
    pub buffer: String,
}

///
/// Log out Stream
///
/// #Examples
/// ```no_run
/// let source: = ADBSource::new(None);
/// let mut logs = source.source().await;
/// while let Some(r) = logs.next().await {
///     match r {
///         Ok(log) => {
///             println!("{}", log);
///         }
///         Err(_) => {}
///     }
/// }
/// ```
///
pub type LogStream = Pin<Box<dyn Stream<Item = Result<Log, Box<dyn Error + Send>>> + Send>>;

#[allow(dead_code)]
impl Log {
    /// log is main buffer
    pub fn is_main(&self) -> bool {
        return self.buffer == "main";
    }

    /// log is system buffer
    pub fn is_system(&self) -> bool {
        return self.buffer == "system";
    }

    /// log is crash buffer
    pub fn is_crash(&self) -> bool {
        return self.buffer == "crash";
    }

    /// log is events buffer
    pub fn is_events(&self) -> bool {
        return self.buffer == "events";
    }

    /// log is radio buffer
    pub fn is_radio(&self) -> bool {
        return self.buffer == "radio";
    }
}

impl Display for Log {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} {} {} {} {} {} {}",
            self.date, self.time, self.pid, self.tid, self.level, self.tag, self.message
        )
    }
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub(crate) enum Level {
    V,
    D,
    I,
    W,
    E,
    F,
    S,
}

impl FromStr for Level {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "V" => Ok(Level::V),
            "D" => Ok(Level::D),
            "I" => Ok(Level::I),
            "W" => Ok(Level::W),
            "E" => Ok(Level::E),
            "F" => Ok(Level::F),
            _ => Ok(Level::S),
        }
    }
}

impl From<Level> for u8 {
    fn from(value: Level) -> Self {
        match value {
            Level::V => 1,
            Level::D => 2,
            Level::I => 3,
            Level::W => 4,
            Level::E => 5,
            Level::F => 6,
            Level::S => 7,
        }
    }
}

impl ValueEnum for Level {
    fn value_variants<'a>() -> &'a [Self] {
        &[Level::V, Level::D, Level::I, Level::W, Level::E, Level::F]
    }

    fn to_possible_value(&self) -> Option<PossibleValue> {
        Some(match self {
            Level::V => PossibleValue::new("V").help("Verbose"),
            Level::D => PossibleValue::new("D").help("Debug"),
            Level::I => PossibleValue::new("I").help("Info"),
            Level::W => PossibleValue::new("W").help("Warning"),
            Level::E => PossibleValue::new("E").help("Error"),
            Level::F => PossibleValue::new("F").help("Fatal"),
            Level::S => PossibleValue::new("S").help("Silent"),
        })
    }
}