hap-model 1.1.0

HomeKit Accessory Protocol attribute database: accessory/service/characteristic model and HAP-defined types.
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

//! The `/accessories` response parser.

use crate::error::Result;
use crate::generated::{CharacteristicType, ServiceType};
use crate::tree::{
    Accessory, Characteristic, Service, WireAccessories, WireCharacteristic, WireService,
};

/// Parse the body of a `GET /accessories` response into the typed tree.
///
/// # Errors
/// - [`crate::ModelError::Json`] if the bytes are not the expected JSON shape.
/// - [`crate::ModelError::MalformedUuid`] for an unparseable `type`.
/// - [`crate::ModelError::ValueType`] / [`crate::ModelError::ValueRange`] /
///   [`crate::ModelError::Base64`] if a present `value` does not match its
///   declared `format`.
pub fn parse_accessories(json: &[u8]) -> Result<Vec<Accessory>> {
    let wire: WireAccessories = serde_json::from_slice(json)?;
    wire.accessories
        .into_iter()
        .map(|a| {
            Ok(Accessory {
                aid: a.aid,
                services: a
                    .services
                    .into_iter()
                    .map(convert_service)
                    .collect::<Result<Vec<_>>>()?,
            })
        })
        .collect()
}

fn convert_service(s: WireService) -> Result<Service> {
    Ok(Service {
        iid: s.iid,
        service_type: ServiceType::from_uuid(&s.type_),
        characteristics: s
            .characteristics
            .into_iter()
            .map(convert_characteristic)
            .collect::<Result<Vec<_>>>()?,
    })
}

fn convert_characteristic(c: WireCharacteristic) -> Result<Characteristic> {
    let value = match c.value {
        Some(ref v) => Some(c.format.value_from_json(v)?),
        None => None,
    };
    Ok(Characteristic {
        iid: c.iid,
        char_type: CharacteristicType::from_uuid(&c.type_),
        format: c.format,
        perms: c.perms,
        value,
        unit: c.unit,
        min_value: c.min_value,
        max_value: c.max_value,
        min_step: c.min_step,
        max_len: c.max_len,
    })
}