sim-lib-view-device 0.1.0

Device profiles, frame timing, and tier derivation for SIM Web surfaces.
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

//! Degradation from requested profile to observed route capabilities.

use crate::ladder::DeviceTier;
use crate::profile::{DeviceProfile, DeviceProfileParts, derive_tier, has_symbol, push_existing};
use sim_kernel::{Expr, Symbol};

/// Capabilities observed on a concrete route and its attached accessories.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ObservedRoute {
    /// Observed display capability tokens.
    pub display: Vec<Symbol>,
    /// Observed input capability tokens.
    pub input: Vec<Symbol>,
    /// Observed output capability tokens.
    pub output: Vec<Symbol>,
    /// Observed link tokens.
    pub links: Vec<Symbol>,
    /// Observed stream tokens.
    pub streams: Vec<Symbol>,
}

impl ObservedRoute {
    /// Builds an observed route from an existing profile.
    pub fn from_profile(profile: &DeviceProfile) -> Self {
        Self {
            display: profile.display.clone(),
            input: profile.input.clone(),
            output: profile.output.clone(),
            links: profile.links.clone(),
            streams: profile.streams.clone(),
        }
    }
}

/// The resolved device tier and any unavailable requested capabilities.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Degradation {
    /// Highest tier supported by the observed route.
    pub tier: DeviceTier,
    /// Human-readable explanations for unavailable requested capabilities.
    pub reasons: Vec<String>,
}

/// Resolves device degradation against observed route/accessory data.
#[derive(Clone, Debug, Default)]
pub struct DegradationResolver;

impl DegradationResolver {
    /// Maps the requested profile to the highest observed tier with reasons for
    /// every unavailable requested capability.
    pub fn resolve(requested: &DeviceProfile, observed: &ObservedRoute) -> Degradation {
        let supported = DeviceProfile::new(DeviceProfileParts {
            kind: requested.kind.clone(),
            display: intersection(&requested.display, &observed.display),
            input: intersection(&requested.input, &observed.input),
            output: intersection(&requested.output, &observed.output),
            links: intersection(&requested.links, &observed.links),
            streams: intersection(&requested.streams, &observed.streams),
            rate: requested.rate,
            policy: Expr::Map(Vec::new()),
        });
        let mut reasons = Vec::new();
        missing_reasons(
            &mut reasons,
            "display",
            &requested.display,
            &observed.display,
        );
        missing_reasons(&mut reasons, "input", &requested.input, &observed.input);
        missing_reasons(&mut reasons, "output", &requested.output, &observed.output);
        missing_reasons(&mut reasons, "link", &requested.links, &observed.links);
        missing_reasons(
            &mut reasons,
            "stream",
            &requested.streams,
            &observed.streams,
        );
        Degradation {
            tier: derive_tier(&supported),
            reasons,
        }
    }

    /// Returns a display-only degradation result with a single explanation.
    pub fn unavailable(reason: impl Into<String>) -> Degradation {
        Degradation {
            tier: DeviceTier::Display,
            reasons: vec![reason.into()],
        }
    }
}

fn intersection(requested: &[Symbol], observed: &[Symbol]) -> Vec<Symbol> {
    let mut out = Vec::new();
    for symbol in requested {
        if observed.iter().any(|candidate| candidate == symbol) {
            push_existing(&mut out, symbol.clone());
        }
    }
    out
}

fn missing_reasons(
    reasons: &mut Vec<String>,
    lane: &str,
    requested: &[Symbol],
    observed: &[Symbol],
) {
    for symbol in requested {
        if !has_symbol(observed, symbol.name.as_ref()) {
            reasons.push(format!("missing {lane}: {}", symbol.as_qualified_str()));
        }
    }
}