kos 0.6.1

The K-Scale Operating System
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

use crate::hal::LEDMatrix;
use crate::kos_proto::common::ActionResponse;
use crate::kos_proto::led_matrix::led_matrix_service_server::LedMatrixService;
use crate::kos_proto::led_matrix::*;
use std::sync::Arc;
use tonic::{Request, Response, Status};
use tracing::trace;

pub struct LEDMatrixServiceImpl {
    led_matrix: Arc<dyn LEDMatrix>,
}

impl LEDMatrixServiceImpl {
    pub fn new(led_matrix: Arc<dyn LEDMatrix>) -> Self {
        Self { led_matrix }
    }
}

#[tonic::async_trait]
impl LedMatrixService for LEDMatrixServiceImpl {
    async fn get_matrix_info(
        &self,
        _request: Request<()>,
    ) -> Result<Response<GetMatrixInfoResponse>, Status> {
        let info = self
            .led_matrix
            .get_matrix_info()
            .await
            .map_err(|e| Status::internal(format!("Failed to get matrix info, {:?}", e)))?;

        trace!("Getting matrix info, response: {:?}", info);
        Ok(Response::new(info))
    }

    async fn write_buffer(
        &self,
        request: Request<WriteBufferRequest>,
    ) -> Result<Response<ActionResponse>, Status> {
        let buffer = request.into_inner().buffer;

        let response = self
            .led_matrix
            .write_buffer(buffer.clone())
            .await
            .map_err(|e| Status::internal(format!("Failed to write buffer, {:?}", e)))?;

        trace!("Writing LED buffer, buffer length: {}", buffer.len());
        Ok(Response::new(response))
    }

    async fn write_color_buffer(
        &self,
        request: Request<WriteColorBufferRequest>,
    ) -> Result<Response<ActionResponse>, Status> {
        let request = request.into_inner();

        let response = self
            .led_matrix
            .write_color_buffer(
                request.buffer,
                request.width,
                request.height,
                request.format.clone(),
                request.brightness,
            )
            .await
            .map_err(|e| Status::internal(format!("Failed to write color buffer, {:?}", e)))?;

        trace!(
            "Writing color buffer, dimensions: {}x{}, format: {}, brightness: {}",
            request.width,
            request.height,
            request.format,
            request.brightness
        );
        Ok(Response::new(response))
    }
}