busylib 0.0.9

BUSY Bar Rust HTTP client
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

//! System schemas

use serde::{Deserialize, Serialize};

/// Device, firmware, system and power information
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Status {
    pub device: Option<StatusDevice>,
    pub firmware: Option<StatusFirmware>,
    pub system: Option<StatusSystem>,
    pub power: Option<StatusPower>,
}

/// Device information
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StatusDevice {
    /// Device serial number
    pub serial_number: String,
    /// MAC of USB ethernet device
    pub usb_mac: String,
    /// WIFI MAC
    pub wifi_mac: Option<String>,
    /// BLE MAC
    pub ble_mac: Option<String>,
    /// Is OTP data valid
    pub otp_valid: bool,
    /// Device model code
    pub otp_model: Option<String>,
    /// Production timestamp
    pub otp_timestamp: Option<u64>,
    /// Summary of firmware signature protection derived from the wireless coprocessor (Si917)
    /// NWP and M4 signature state. "secure" - both NWP and M4 firmware signature verification
    /// active; "insecure" - neither active; "other" - mixed state (exactly one active);
    /// "unknown" - coprocessor info not ready yet.
    pub firmware_security: FirmwareSecurity,
}

/// Firmware signature protection states
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FirmwareSecurity {
    Secure,
    Insecure,
    Other,
    Unknown,
    #[serde(untagged)]
    Unrecognized(String),
}

/// Firmware information
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StatusFirmware {
    /// Firmware version
    pub version: String,
    /// Firmware target code
    pub target: i64,
    /// Git branch name
    pub branch: String,
    /// Build date
    pub build_date: String,
    /// Git commit hash (may include -dirty suffix)
    pub commit_hash: String,
    /// Intercom handshake version string (forced version, git hash, or "intercom" if check
    /// disabled)
    pub intercom_version: String,
    /// Radio firmware version
    pub nwp_version: Option<String>,
    /// Matter version
    pub matter_version: Option<String>,
}

/// System information
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StatusSystem {
    /// API SemVer
    pub api_semver: String,
    /// System uptime
    pub uptime: String,
    /// System boot timestamp
    pub boot_time: i64,
    /// Is auto-update enabled
    pub auto_update_enabled: bool,
}

/// Power and battery information
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StatusPower {
    /// Power state
    pub state: PowerState,
    /// Battery charge percent
    pub battery_charge: i32,
    /// Battery voltage in mV
    pub battery_voltage: i32,
    /// Battery current in mA
    pub battery_current: i32,
    /// USB voltage in mV
    pub usb_voltage: i32,
}

/// Power states of the battery
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PowerState {
    Discharging,
    Charging,
    Charged,
    #[serde(untagged)]
    Unknown(String),
}

/// How the device is connected
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TransportType {
    Usb,
    Wifi,
    #[serde(untagged)]
    Unknown(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub(crate) struct VersionInfo {
    /// API SemVer
    pub api_semver: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub(crate) struct NetworkInterfaceInfo {
    /// Connection type
    pub r#type: TransportType,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub(crate) struct LogDumpResponse {
    pub path: String,
}