framesmith 0.1.0

A Rust library for controlling Samsung Frame TVs over the local network
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

use std::collections::VecDeque;
use std::sync::Mutex;

use crate::Error;
use crate::frame_tv_transport::FrameTvTransport;
use crate::protocol::art_response::ArtResponse;

pub(crate) struct MockTransport {
    art_responses: Mutex<VecDeque<Result<ArtResponse, Error>>>,
    remote_key_log: Mutex<Vec<String>>,
    upload_responses: Mutex<VecDeque<Result<ArtResponse, Error>>>,
    thumbnail_responses: Mutex<VecDeque<Result<Vec<u8>, Error>>>,
    display_size: (u32, u32),
}

impl MockTransport {
    pub fn new() -> Self {
        Self {
            art_responses: Mutex::new(VecDeque::new()),
            remote_key_log: Mutex::new(Vec::new()),
            upload_responses: Mutex::new(VecDeque::new()),
            thumbnail_responses: Mutex::new(VecDeque::new()),
            display_size: (3840, 2160),
        }
    }

    pub fn enqueue_art_response(&self, resp: ArtResponse) {
        self.art_responses.lock().unwrap().push_back(Ok(resp));
    }

    pub fn enqueue_art_error(&self, err: Error) {
        self.art_responses.lock().unwrap().push_back(Err(err));
    }

    pub fn enqueue_upload_response(&self, resp: ArtResponse) {
        self.upload_responses.lock().unwrap().push_back(Ok(resp));
    }

    pub fn enqueue_thumbnail_response(&self, data: Vec<u8>) {
        self.thumbnail_responses.lock().unwrap().push_back(Ok(data));
    }

    pub fn get_remote_key_log(&self) -> Vec<String> {
        self.remote_key_log.lock().unwrap().clone()
    }
}

impl FrameTvTransport for MockTransport {
    async fn send_art_request(
        &self,
        _request_json: &str,
        _wait_for_event: Option<&str>,
    ) -> Result<ArtResponse, Error> {
        self.art_responses
            .lock()
            .unwrap()
            .pop_front()
            .unwrap_or(Err(Error::ConnectionFailed(
                "no mock response queued".into(),
            )))
    }

    async fn send_remote_key(&self, key_code: &str) -> Result<(), Error> {
        self.remote_key_log
            .lock()
            .unwrap()
            .push(key_code.to_string());
        Ok(())
    }

    async fn upload_image(
        &self,
        _image_data: &[u8],
        _file_type: &str,
        _matte_id: Option<&str>,
    ) -> Result<ArtResponse, Error> {
        self.upload_responses
            .lock()
            .unwrap()
            .pop_front()
            .unwrap_or(Err(Error::ConnectionFailed(
                "no mock upload response queued".into(),
            )))
    }

    async fn download_thumbnail(&self, _content_id: &str) -> Result<Vec<u8>, Error> {
        self.thumbnail_responses
            .lock()
            .unwrap()
            .pop_front()
            .unwrap_or(Err(Error::ConnectionFailed(
                "no mock thumbnail response queued".into(),
            )))
    }

    async fn tv_display_size(&self) -> Result<(u32, u32), Error> {
        Ok(self.display_size)
    }
}