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

//! Streamdeck connection thread
//!
//! A separate thread for interacting and pooling events from streamdeck
use std::sync::Arc;
use std::sync::mpsc::{channel, Sender, TryRecvError};
use std::thread::{sleep, spawn};
use std::time::{Duration, Instant};
use image::DynamicImage;
use streamdeck::{Colour, StreamDeck};
use crate::core::SDCore;

/// Handle for contacting streamdeck thread
#[derive(Debug)]
pub struct StreamDeckHandle {
    tx: Sender<Vec<StreamDeckCommand>>,
}

impl StreamDeckHandle {
    pub fn send(&self, commands: Vec<StreamDeckCommand>) {
        self.tx.send(commands).ok();
    }
}

/// Spawns streamdeck thread from a core reference
pub fn spawn_streamdeck_thread(core: Arc<SDCore>, streamdeck: StreamDeck, key_tx: Sender<(u8, bool)>) -> StreamDeckHandle {
    let (tx, rx) = channel::<Vec<StreamDeckCommand>>();

    spawn(move || {
        let core = core.clone();
        let mut streamdeck = streamdeck;
        let mut last_iter = Instant::now();
        let mut last_buttons = Vec::new();

        streamdeck.set_blocking(false).ok();

        loop {
            if core.is_closed() {
                break;
            }

            // Pool for buttons
            match streamdeck.read_buttons(None) {
                Ok(buttons) => {
                    for (key, value) in buttons.iter().enumerate() {
                        if let Some(last_value) = last_buttons.get(key) {
                            if last_value != value {
                                key_tx.send((key as u8, *last_value == 0)).ok();
                            }
                        } else {
                            if *value > 0 {
                                key_tx.send((key as u8, true)).ok();
                            }
                        }
                    }
                    last_buttons = buttons;
                }
                Err(err) => {
                    match err {
                        streamdeck::Error::NoData => {}
                        streamdeck::Error::Hid(_) => {
                            log::trace!("hid connection failed");
                            core.close()
                        }
                        _ => {
                            panic!("Error on streamdeck thread: {:?}", err);
                        }
                    }
                }
            }

            // Check for commands
            match rx.try_recv() {
                Ok(commands) => {
                    for command in commands {
                        match command {
                            StreamDeckCommand::SetButtonImage(key, image) => {
                                streamdeck.set_button_image(key, image).ok();
                            }
                            StreamDeckCommand::ClearButtonImage(key) => {
                                streamdeck.set_button_rgb(key, &Colour {
                                    r: 0,
                                    g: 0,
                                    b: 0
                                }).ok();
                            }
                            StreamDeckCommand::SetBrightness(brightness) => {
                                streamdeck.set_brightness(brightness).ok();
                            }
                        }
                    }
                }

                Err(err) => {
                    match err {
                        TryRecvError::Empty => {}
                        TryRecvError::Disconnected => {
                            break;
                        }
                    }
                }
            }

            // Rate limiter
            let rate = 1.0 / core.pool_rate as f32;
            let time_since_last = last_iter.elapsed().as_secs_f32();

            let to_wait = rate - time_since_last;
            if to_wait > 0.0 {
                sleep(Duration::from_secs_f32(to_wait));
            }

            last_iter = Instant::now();
        }

        log::trace!("streamdeck closed");
    });

    StreamDeckHandle {
        tx,
    }
}

/// Supported streamdeck commands
#[allow(dead_code)]
pub enum StreamDeckCommand {
    /// Sets streamdeck brightness to provided value
    SetBrightness(u8),

    /// Sets button image to specified image
    SetButtonImage(u8, DynamicImage),

    /// Clears button and sets it to black color
    ClearButtonImage(u8),
}