wayk_proto 0.2.4

WaykNow packet encoder-decoder and sequencing utilities
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

use crate::message::{AccessControlCode, AccessFlags};
use num_derive::FromPrimitive;

__flags_struct! {
    AccessControlFlags: u8 => {
        failure = FAILURE = 0x80,
    }
}

#[derive(Encode, Decode, FromPrimitive, Debug, PartialEq, Clone, Copy)]
#[repr(u8)]
pub enum AccessControlMessageType {
    Req = 0x01,
    Rsp = 0x02,
    Ntf = 0x03,
}

__flags_struct! {
    AccessReason: u16 => {
        denied = DENIED = 0x0001,
        timeout = TIMEOUT = 0x0002,
        disabled = DISABLED = 0x0003,
    }
}

// NOW_ACCESS_CONTROL_REQ_MSG

#[derive(Debug, Clone, Encode, Decode)]
pub struct NowAcessControlReq {
    subtype: AccessControlMessageType,
    flags: AccessControlFlags,
    pub id: AccessControlCode,
    pub timeout: u16,
}

impl NowAcessControlReq {
    pub const SUBTYPE: AccessControlMessageType = AccessControlMessageType::Req;

    pub fn new(id: AccessControlCode, timeout: u16) -> Self {
        Self {
            subtype: Self::SUBTYPE,
            flags: AccessControlFlags::new_empty(),
            id,
            timeout,
        }
    }
}

// NOW_ACCESS_CONTROL_RSP_MSG

#[derive(Debug, Clone, Encode, Decode)]
pub struct NowAcessControlRsp {
    subtype: AccessControlMessageType,
    pub flags: AccessControlFlags,
    pub id: AccessControlCode,
    pub reason: AccessReason,
}

// NOW_ACCESS_CONTROL_NTF_MSG

#[derive(Debug, Clone, Encode, Decode)]
pub struct NowAcessControlNtf {
    subtype: AccessControlMessageType,
    pub flags: AccessControlFlags,
    pub id: AccessControlCode,
    pub status: AccessFlags,
}

// NOW_ACCESS_MSG

#[derive(Debug, Clone, Encode, Decode)]
#[meta_enum = "AccessControlMessageType"]
pub enum NowAccessMsg {
    Req(NowAcessControlReq),
    Rsp(NowAcessControlRsp),
    Ntf(NowAcessControlNtf),
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::serialization::{Decode, Encode};

    const ACCESS_CONTROL_REQ_MSG: [u8; 6] = [0x01, 0x00, 0x06, 0x00, 0x1e, 0x00];

    #[test]
    fn access_control_req_decoding() {
        let msg = NowAccessMsg::decode(&ACCESS_CONTROL_REQ_MSG).unwrap();

        if let NowAccessMsg::Req(msg) = msg {
            assert_eq!(msg.subtype, AccessControlMessageType::Req);
            assert_eq!(msg.flags, 0x00);
            assert_eq!(msg.id, AccessControlCode::Chat);
            assert_eq!(msg.timeout, 30);
        } else {
            panic!("Expected a request message, found {:?}", msg);
        }
    }

    #[test]
    fn access_control_req_encoding() {
        let req = NowAcessControlReq::new(AccessControlCode::Chat, 30);
        assert_eq!(req.encode().unwrap(), ACCESS_CONTROL_REQ_MSG.to_vec());
    }

    const ACCESS_CONTROL_RSP_MSG: [u8; 6] = [0x02, 0x80, 0x06, 0x00, 0x02, 0x00];

    #[test]
    fn access_control_rsp_decoding() {
        let msg = NowAccessMsg::decode(&ACCESS_CONTROL_RSP_MSG).unwrap();
        if let NowAccessMsg::Rsp(msg) = msg {
            assert_eq!(msg.subtype, AccessControlMessageType::Rsp);
            assert_eq!(msg.flags, AccessControlFlags::FAILURE);
            assert_eq!(msg.id, AccessControlCode::Chat);
            assert_eq!(msg.reason, AccessReason::TIMEOUT);
        } else {
            panic!("Expected a response message, found {:?}", msg);
        }
    }

    const ACCESS_CONTROL_NTF_MSG: [u8; 6] = [0x03, 0x00, 0x03, 0x00, 0x01, 0x00];

    #[test]
    fn access_control_ntf_decoding() {
        let msg = NowAccessMsg::decode(&ACCESS_CONTROL_NTF_MSG).unwrap();
        if let NowAccessMsg::Ntf(msg) = msg {
            assert_eq!(msg.subtype, AccessControlMessageType::Ntf);
            assert_eq!(msg.flags, AccessControlFlags::new_empty());
            assert_eq!(msg.id, AccessControlCode::Clipboard);
            assert_eq!(msg.status, AccessFlags::ALLOWED);
        } else {
            panic!("Expected a ntf message, found {:?}", msg);
        }
    }
}