macstate-core 0.0.11

Library exposing macOS system signals (network, power) as serde-serializable structs
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

use serde::Serialize;

#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub struct Network {
    /// True when the path is on a Low Data Mode network
    /// (`NWPath.isConstrained`).
    pub constrained: bool,
    /// True when the path is on an expensive interface such as cellular or
    /// a personal hotspot (`NWPath.isExpensive`).
    pub expensive: bool,
    pub interface: Interface,
}

#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "lowercase")]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "schema", schemars(rename_all = "lowercase"))]
#[cfg_attr(
    feature = "schema",
    schemars(description = "Primary interface kind reported by NWPathMonitor for the current path. `other` is reported when the path uses none of the well-known kinds (e.g. unknown VPN).")
)]
pub enum Interface {
    Wifi,
    Cellular,
    Wired,
    Loopback,
    Other,
}

#[cfg(target_os = "macos")]
impl Network {
    pub fn collect() -> Self {
        use macstate_sys::nwpath::{snapshot, InterfaceType};
        use std::time::Duration;

        // NWPathMonitor delivers its first update very quickly (<100ms typical),
        // but allow generous slack on cold starts.
        let Some(snap) = snapshot(Duration::from_secs(2)) else {
            return Self {
                constrained: false,
                expensive: false,
                interface: Interface::Other,
            };
        };

        let interface = match snap.interface {
            Some(InterfaceType::Wifi) => Interface::Wifi,
            Some(InterfaceType::Cellular) => Interface::Cellular,
            Some(InterfaceType::WiredEthernet) => Interface::Wired,
            Some(InterfaceType::Loopback) => Interface::Loopback,
            _ => Interface::Other,
        };

        Self {
            constrained: snap.constrained,
            expensive: snap.expensive,
            interface,
        }
    }
}

#[cfg(not(target_os = "macos"))]
impl Network {
    pub fn collect() -> Self {
        Self {
            constrained: false,
            expensive: false,
            interface: Interface::Other,
        }
    }
}