From 06333b7fe29f5aae8de9ca5918f49886f50dd7c1 Mon Sep 17 00:00:00 2001 From: Nickiel12 <35903114+Nickiel12@users.noreply.github.com> Date: Sat, 16 Jul 2022 21:16:56 -0700 Subject: [PATCH] ran rustfmt --- src/main.rs | 129 +++++++--- src/modules/external_interface.rs | 165 +++++++++---- src/modules/message_handler.rs | 183 ++++++++------ src/modules/mod.rs | 9 +- src/modules/socket_handler.rs | 36 +-- src/modules/tray_icon.rs | 22 +- src/tests/main_tests.rs | 6 +- src/tests/message_handler_tests.rs | 9 +- src/tests/mod.rs | 7 +- src/tests/socket_handler_tests.rs | 11 +- src/tests/state_update_tests.rs | 381 ++++++++++++++++++++++------- src/tests/stream_states_tests.rs | 125 +++++++--- 12 files changed, 753 insertions(+), 330 deletions(-) diff --git a/src/main.rs b/src/main.rs index 6099120..5d2deb4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,12 @@ -use std::{time::Duration, thread, io::Read}; use crossbeam_channel::unbounded; +use std::{io::Read, thread, time::Duration}; -use modules::{socket_handler::Socket, stream_states::stream_state::StreamState, message_handler::{MessageHandler}, external_interface::{Hotkeys, OPTIONS_PATH}}; +use modules::{ + external_interface::{Hotkeys, OPTIONS_PATH}, + message_handler::MessageHandler, + socket_handler::Socket, + stream_states::stream_state::StreamState, +}; use workctl::sync_flag; use crate::modules::stream_states::state_update::StateUpdate; @@ -9,9 +14,9 @@ use crate::modules::stream_states::state_update::StateUpdate; #[cfg(target_os = "windows")] use modules::tray_icon; +mod modules; #[cfg(test)] mod tests; -mod modules; #[cfg(target_os = "windows")] const SERVER_ADDRESS: &str = "localhost:5000"; @@ -24,27 +29,27 @@ const SERVER_ADDRESS: &str = "10.0.0.209:5000"; const SERVER_ADDRESS: &str = "10.0.0.168:5000"; fn main() { - let icon = include_bytes!("icon1.ico"); let mut tray_icon = tray_icon::TrayIcon::setup(icon); let settings_json = load_json(); let hotkeys = Hotkeys::new(settings_json); - + let (from_socket_tx, from_socket_rx) = unbounded::(); let hotkey_channel_tx = from_socket_tx.clone(); - - let mut socket = Socket::handle_connections(Socket::make_listener(SERVER_ADDRESS), from_socket_tx); - + + let mut socket = + Socket::handle_connections(Socket::make_listener(SERVER_ADDRESS), from_socket_tx); + let (hotkey_close_flag_tx, hotkey_close_flag_rx) = sync_flag::new_syncflag(true); let control_c_called_flag_rx = setup_control_c(hotkey_close_flag_tx); - + let hotkey_handle = thread::spawn(move || { println!("starting hotkey thread"); modules::external_interface::create_keyboard_hooks(hotkey_channel_tx, hotkey_close_flag_rx); println!("closing hotkey thread"); }); - + let mut state = StreamState::new(); //until control_c is caught, check the queue of incoming //requests from the socket handler. @@ -55,15 +60,15 @@ fn main() { match from_socket_rx.recv_timeout(Duration::from_millis(100)) { Ok(message) => { println!("main recieved: {}", message); - let update = StateUpdate::json_to_state_update( - serde_json::from_str(&message).unwrap()); + let update = + StateUpdate::json_to_state_update(serde_json::from_str(&message).unwrap()); if update == StateUpdate::UpdateClient { update_all(&state, &socket); } else { handle_instructions(vec![update], &mut state, &socket, &hotkeys); } - }, - Err(_) => {}, + } + Err(_) => {} } let tick_update = state.tick(); @@ -76,12 +81,17 @@ fn main() { tray_icon.process_tray_messages(); //tray_icon.check_tray_messages(); } - + println!("closing main thread"); hotkey_handle.join().unwrap(); } -fn handle_instructions(mut instructions: Vec, state: &mut StreamState, socket: &Socket, hotkeys: &Hotkeys) { +fn handle_instructions( + mut instructions: Vec, + state: &mut StreamState, + socket: &Socket, + hotkeys: &Hotkeys, +) { for i in instructions.iter_mut() { let updates = state.handle_update(i.to_owned(), &hotkeys); if updates.0.is_some() { @@ -95,36 +105,85 @@ fn handle_instructions(mut instructions: Vec, state: &mut StreamSta } } -fn setup_control_c(mut hotkey_close_flag_tx: sync_flag::SyncFlagTx) -> sync_flag::SyncFlagRx{ +fn setup_control_c(mut hotkey_close_flag_tx: sync_flag::SyncFlagTx) -> sync_flag::SyncFlagRx { let (mut control_c_flag_tx, control_c_called_flag_rx) = sync_flag::new_syncflag(false); ctrlc::set_handler(move || { println!("ctrl c caught"); control_c_flag_tx.set(true); hotkey_close_flag_tx.set(false); - }).expect("control C handler failed!"); + }) + .expect("control C handler failed!"); control_c_called_flag_rx } fn load_json() -> serde_json::Value { - let mut settings_file = std::fs::File::open(OPTIONS_PATH).unwrap(); - let mut settings_str = String::new(); - settings_file.read_to_string(&mut settings_str).unwrap(); - drop(settings_file); - serde_json::from_str(settings_str.as_str()).unwrap() + let mut settings_file = std::fs::File::open(OPTIONS_PATH).unwrap(); + let mut settings_str = String::new(); + settings_file.read_to_string(&mut settings_str).unwrap(); + drop(settings_file); + serde_json::from_str(settings_str.as_str()).unwrap() } fn update_all(state: &StreamState, socket: &Socket) { println!("updating all"); - socket.send(StateUpdate::StreamRunning(state.stream_running).to_json().to_string()); - socket.send(StateUpdate::StreamSoundToggleOn(state.stream_is_muted).to_json().to_string()); - socket.send(StateUpdate::ToggleComputerSoundOn(state.computer_sound_is_on).to_json().to_string()); - socket.send(StateUpdate::ChangeSceneOnChangeSlide(state.change_scene_on_slide_hotkey).to_json().to_string()); - socket.send(StateUpdate::SceneIsAugmented(state.scene_is_augmented).to_json().to_string()); - socket.send(StateUpdate::TimerCanRun(state.timer_can_run).to_json().to_string()); - socket.send(StateUpdate::TimerLength(state.timer_length).to_json().to_string()); - socket.send(StateUpdate::TimerText(state.timer_text.clone()).to_json().to_string()); - socket.send(StateUpdate::SubScene(state.camera_sub_scene).to_json().to_string()); - socket.send(StateUpdate::SubScene(state.screen_sub_scene).to_json().to_string()); - socket.send(StateUpdate::Scene(state.current_scene).to_json().to_string()); - socket.send(StateUpdate::PauseTimer(state.timer_paused_length.is_some()).to_json().to_string()); + socket.send( + StateUpdate::StreamRunning(state.stream_running) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::StreamSoundToggleOn(state.stream_is_muted) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::ToggleComputerSoundOn(state.computer_sound_is_on) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::ChangeSceneOnChangeSlide(state.change_scene_on_slide_hotkey) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::SceneIsAugmented(state.scene_is_augmented) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::TimerCanRun(state.timer_can_run) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::TimerLength(state.timer_length) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::TimerText(state.timer_text.clone()) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::SubScene(state.camera_sub_scene) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::SubScene(state.screen_sub_scene) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::Scene(state.current_scene) + .to_json() + .to_string(), + ); + socket.send( + StateUpdate::PauseTimer(state.timer_paused_length.is_some()) + .to_json() + .to_string(), + ); } diff --git a/src/modules/external_interface.rs b/src/modules/external_interface.rs index ab37c41..9319ac6 100644 --- a/src/modules/external_interface.rs +++ b/src/modules/external_interface.rs @@ -1,41 +1,58 @@ +use super::stream_states::{ + scenes::{Scenes, SlideChange, SubScenes}, + state_update::StateUpdate, +}; use std::process::Command; -use super::stream_states::{state_update::StateUpdate, scenes::{SlideChange, SubScenes, Scenes}}; #[cfg(target_os = "windows")] const AHK_FILES_FOLDER: &str = ".\\ahk_files\\"; #[cfg(target_os = "windows")] pub const OPTIONS_PATH: &str = ".\\options.json"; - #[cfg(target_os = "linux")] const AHK_FILES_FOLDER: &str = "./ahk_files/"; #[cfg(target_os = "linux")] pub const OPTIONS_PATH: &str = "./options.json"; - /* - const AHK_FILES_FOLDER: &str = "./src/ahk_files/"; - pub const OPTIONS_PATH: &str = "./options.json"; - */ +/* +const AHK_FILES_FOLDER: &str = "./src/ahk_files/"; +pub const OPTIONS_PATH: &str = "./options.json"; +*/ -pub fn create_keyboard_hooks(channel_tx: crossbeam_channel::Sender, close_flag: workctl::sync_flag::SyncFlagRx) { - +pub fn create_keyboard_hooks( + channel_tx: crossbeam_channel::Sender, + close_flag: workctl::sync_flag::SyncFlagRx, +) { let tx_1 = channel_tx.clone(); inputbot::KeybdKey::PageUpKey.bind(move || { - tx_1.send(StateUpdate::ChangeSlide(SlideChange::PreviousHotkey).to_json().to_string()).unwrap(); + tx_1.send( + StateUpdate::ChangeSlide(SlideChange::PreviousHotkey) + .to_json() + .to_string(), + ) + .unwrap(); }); let tx_2 = channel_tx.clone(); inputbot::KeybdKey::PageDownKey.bind(move || { - tx_2.send(StateUpdate::ChangeSlide(SlideChange::NextHotkey).to_json().to_string()).unwrap(); + tx_2.send( + StateUpdate::ChangeSlide(SlideChange::NextHotkey) + .to_json() + .to_string(), + ) + .unwrap(); }); - + #[cfg(feature = "default")] inputbot::handle_input_events(close_flag); } #[cfg(feature = "no_hotkeys")] -pub fn create_keyboard_hooks(channel_tx: crossbeam_channel::Sender, close_flag: workctl::sync_flag::SyncFlagRx) { - return +pub fn create_keyboard_hooks( + channel_tx: crossbeam_channel::Sender, + close_flag: workctl::sync_flag::SyncFlagRx, +) { + return; } pub struct Hotkeys { @@ -44,20 +61,35 @@ pub struct Hotkeys { impl Hotkeys { pub fn new(hotkeys: serde_json::Value) -> Self { - Hotkeys { - hotkeys - } + Hotkeys { hotkeys } } pub fn get_hotkey_from_scene(&self, scene: SubScenes) -> &str { match scene { - SubScenes::CameraDefault => {self.hotkeys["hotkeys"]["obs"]["camera_scene_hotkey"].as_str().unwrap()}, - SubScenes::CameraWithUpperRight => {self.hotkeys["hotkeys"]["obs"]["Camera_Top_Right"].as_str().unwrap()}, - SubScenes::CameraWithLargeUpperRight => {self.hotkeys["hotkeys"]["obs"]["Camera_Large_Top_Right"].as_str().unwrap()}, - SubScenes::CameraWithLowerRight => {self.hotkeys["hotkeys"]["obs"]["Camera_Bottom_Right"].as_str().unwrap()}, - SubScenes::ScreenDefault => {self.hotkeys["hotkeys"]["obs"]["screen_scene_hotkey"].as_str().unwrap()}, - SubScenes::ScreenWithUpperRight => {self.hotkeys["hotkeys"]["obs"]["Screen_Top_Right"].as_str().unwrap()}, - SubScenes::ScreenWithLowerRight => {self.hotkeys["hotkeys"]["obs"]["Screen_Bottom_Right"].as_str().unwrap()}, + SubScenes::CameraDefault => self.hotkeys["hotkeys"]["obs"]["camera_scene_hotkey"] + .as_str() + .unwrap(), + SubScenes::CameraWithUpperRight => self.hotkeys["hotkeys"]["obs"]["Camera_Top_Right"] + .as_str() + .unwrap(), + SubScenes::CameraWithLargeUpperRight => self.hotkeys["hotkeys"]["obs"] + ["Camera_Large_Top_Right"] + .as_str() + .unwrap(), + SubScenes::CameraWithLowerRight => self.hotkeys["hotkeys"]["obs"] + ["Camera_Bottom_Right"] + .as_str() + .unwrap(), + SubScenes::ScreenDefault => self.hotkeys["hotkeys"]["obs"]["screen_scene_hotkey"] + .as_str() + .unwrap(), + SubScenes::ScreenWithUpperRight => self.hotkeys["hotkeys"]["obs"]["Screen_Top_Right"] + .as_str() + .unwrap(), + SubScenes::ScreenWithLowerRight => self.hotkeys["hotkeys"]["obs"] + ["Screen_Bottom_Right"] + .as_str() + .unwrap(), } } @@ -65,9 +97,11 @@ impl Hotkeys { if cfg!(target_family = "windows") { println!("sending to obs"); Command::new(String::from(AHK_FILES_FOLDER) + "send_obs_back_to_propre.exe") - .args([self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), - self.hotkeys["windows"]["obs_re"].as_str().unwrap(), - hotkey]) + .args([ + self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), + self.hotkeys["windows"]["obs_re"].as_str().unwrap(), + hotkey, + ]) .spawn() .expect("next_slide process call failed"); std::thread::sleep(std::time::Duration::from_millis(400)); @@ -77,32 +111,58 @@ impl Hotkeys { } pub fn next_slide(&self, from_hotkey: bool) { - let from_hotkey_str = {if from_hotkey {"1"} else {"0"}}; + let from_hotkey_str = { + if from_hotkey { + "1" + } else { + "0" + } + }; if cfg!(target_family = "windows") { Command::new(String::from(AHK_FILES_FOLDER) + "propre_send.exe") - .args([self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), - self.hotkeys["general"]["clicker_forward"].as_str().unwrap(), - from_hotkey_str]) + .args([ + self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), + self.hotkeys["general"]["clicker_forward"].as_str().unwrap(), + from_hotkey_str, + ]) .spawn() .expect("next_slide process call failed"); - std::thread::sleep(std::time::Duration::from_millis(200)); + std::thread::sleep(std::time::Duration::from_millis(200)); } else { - println!("pretend linux is sending prosenter next: {}", self.hotkeys["general"]["clicker_forward"].as_str().unwrap()) + println!( + "pretend linux is sending prosenter next: {}", + self.hotkeys["general"]["clicker_forward"].as_str().unwrap() + ) }; } - + pub fn prev_slide(&self, from_hotkey: bool) { - let from_hotkey_str = {if from_hotkey {"1"} else {"0"}}; + let from_hotkey_str = { + if from_hotkey { + "1" + } else { + "0" + } + }; if cfg!(target_family = "windows") { Command::new(String::from(AHK_FILES_FOLDER) + "propre_send.exe") - .args([self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), - self.hotkeys["general"]["clicker_backward"].as_str().unwrap(), - from_hotkey_str]) + .args([ + self.hotkeys["windows"]["propresenter_re"].as_str().unwrap(), + self.hotkeys["general"]["clicker_backward"] + .as_str() + .unwrap(), + from_hotkey_str, + ]) .spawn() .expect("next_slide process call failed"); - std::thread::sleep(std::time::Duration::from_millis(200)); + std::thread::sleep(std::time::Duration::from_millis(200)); } else { - println!("pretend linux is sending prosenter next: {}", self.hotkeys["general"]["clicker_backward"].as_str().unwrap()) + println!( + "pretend linux is sending prosenter next: {}", + self.hotkeys["general"]["clicker_backward"] + .as_str() + .unwrap() + ) }; } @@ -110,28 +170,34 @@ impl Hotkeys { println!("sending: {:?} : {:?}", scene, sub_scene); let hotkey: &str; if scene == Scenes::Augmented { - hotkey = self.hotkeys["hotkeys"]["obs"]["camera_scene_augmented"].as_str().unwrap() + hotkey = self.hotkeys["hotkeys"]["obs"]["camera_scene_augmented"] + .as_str() + .unwrap() } else { hotkey = self.get_hotkey_from_scene(sub_scene.unwrap()) }; self.send_obs(hotkey); } - + pub fn toggle_stream_sound(&self, turn_on: bool) { let hotkey: &str; if turn_on { - hotkey = self.hotkeys["hotkeys"]["obs"]["unmute_stream"].as_str().unwrap(); + hotkey = self.hotkeys["hotkeys"]["obs"]["unmute_stream"] + .as_str() + .unwrap(); } else { - hotkey = self.hotkeys["hotkeys"]["obs"]["mute_stream"].as_str().unwrap(); + hotkey = self.hotkeys["hotkeys"]["obs"]["mute_stream"] + .as_str() + .unwrap(); } self.send_obs(hotkey); } - + pub fn toggle_computer_sound(&self, value: bool) { let time_delay = self.hotkeys["general"]["music_fade_time"].as_i64().unwrap(); if cfg!(target_family = "windows") { Command::new(String::from(AHK_FILES_FOLDER) + "music_toggle.exe") - .arg((value as u8).to_string()) + .arg((value as u8).to_string()) .arg(time_delay.to_string()) .spawn() .expect("next_slide process call failed"); @@ -139,20 +205,19 @@ impl Hotkeys { println!("pretend linux is sending media: {}", value) }; } - + pub fn toggle_media_play_pause(&self) { if cfg!(target_family = "windows") { Command::new(String::from(AHK_FILES_FOLDER) + "pause_play_global.exe") - .arg(self.hotkeys["windows"]["propresenter_re"].as_str().unwrap()) + .arg(self.hotkeys["windows"]["propresenter_re"].as_str().unwrap()) .spawn() .expect("next_slide process call failed"); } else { println!("pretend linux is sending media pause") }; - } + } } - #[test] fn hotkeys() { use std::io::Read; @@ -174,4 +239,4 @@ fn hotkeys() { hk.toggle_computer_sound(true); hk.toggle_stream_sound(true); hk.toggle_media_play_pause(); -} \ No newline at end of file +} diff --git a/src/modules/message_handler.rs b/src/modules/message_handler.rs index e250e7f..ad3fff6 100644 --- a/src/modules/message_handler.rs +++ b/src/modules/message_handler.rs @@ -1,47 +1,62 @@ -use std::time::{SystemTime}; +use std::time::SystemTime; -use super::{stream_states::{state_update::StateUpdate, stream_state::StreamState, scenes::{SlideChange, Scenes}}, external_interface::{Hotkeys}}; +use super::{ + external_interface::Hotkeys, + stream_states::{ + scenes::{Scenes, SlideChange}, + state_update::StateUpdate, + stream_state::StreamState, + }, +}; -pub trait MessageHandler { //the first one goes to socket, the second propogates - fn handle_update(&mut self, update: StateUpdate, hotkey_handler: &Hotkeys) - -> (Option, Option>); +pub trait MessageHandler { + //the first one goes to socket, the second propogates + fn handle_update( + &mut self, + update: StateUpdate, + hotkey_handler: &Hotkeys, + ) -> (Option, Option>); fn get_states(&self) -> StreamState; fn pause_timer(&mut self, do_pause: bool) -> (Option, Option>); fn tick(&mut self) -> Vec; } impl MessageHandler for StreamState { - fn handle_update(&mut self, update: StateUpdate, hotkey_handler: &Hotkeys) - -> (Option, Option>) { - - if update != StateUpdate::UpdateClient && update != StateUpdate::ChangeSlide(SlideChange::NextApp) && - update != StateUpdate::ChangeSlide(SlideChange::PreviousApp) && update != StateUpdate::ChangeSlide(SlideChange::PreviousHotkey) - && update != StateUpdate::ChangeSlide(SlideChange::NextHotkey) { + fn handle_update( + &mut self, + update: StateUpdate, + hotkey_handler: &Hotkeys, + ) -> (Option, Option>) { + if update != StateUpdate::UpdateClient + && update != StateUpdate::ChangeSlide(SlideChange::NextApp) + && update != StateUpdate::ChangeSlide(SlideChange::PreviousApp) + && update != StateUpdate::ChangeSlide(SlideChange::PreviousHotkey) + && update != StateUpdate::ChangeSlide(SlideChange::NextHotkey) + { self.update(update.clone()); } if self.debug_mode { - return (None, None) + return (None, None); } match update { StateUpdate::ChangeSlide(direction) => { - match direction { SlideChange::NextHotkey => { hotkey_handler.next_slide(true); - }, + } SlideChange::NextApp => { hotkey_handler.next_slide(false); - }, + } SlideChange::PreviousHotkey => { hotkey_handler.prev_slide(true); - }, + } SlideChange::PreviousApp => { hotkey_handler.prev_slide(false); - }, + } } - + if self.change_scene_on_slide_hotkey { if self.timer_can_run { self.timer_finished = false; @@ -50,17 +65,22 @@ impl MessageHandler for StreamState { let mut instructions = Vec::new(); instructions.push(StateUpdate::Scene(Scenes::Screen)); - return (None, Some(instructions)) - } else {return (None, None)} + return (None, Some(instructions)); + } else { + return (None, None); + } + } + StateUpdate::ChangeSceneOnChangeSlide(value) => { + self.change_scene_on_slide_hotkey = value; + return (Some(update), None); } - StateUpdate::ChangeSceneOnChangeSlide(value) => {self.change_scene_on_slide_hotkey = value; return (Some(update), None)}, StateUpdate::SceneIsAugmented(value) => { if value { let mut instructions = Vec::new(); instructions.push(StateUpdate::ChangeSceneOnChangeSlide(false)); instructions.push(StateUpdate::Scene(Scenes::Augmented)); instructions.push(StateUpdate::TimerCanRun(false)); - return (Some(update), Some(instructions)) + return (Some(update), Some(instructions)); } else { let mut instructions = Vec::new(); instructions.push(StateUpdate::Scene(Scenes::Camera)); @@ -68,9 +88,9 @@ impl MessageHandler for StreamState { instructions.push(StateUpdate::TimerCanRun(true)); return (Some(update), Some(instructions)); } - }, + } StateUpdate::TimerCanRun(value) => { - if self.timer_paused_length.is_some(){ + if self.timer_paused_length.is_some() { return (None, Some(vec![StateUpdate::PauseTimer(false)])); } @@ -80,70 +100,86 @@ impl MessageHandler for StreamState { if value { let mut instruction = Vec::new(); instruction.push(StateUpdate::TimerText(String::from("0.0"))); - return (Some(update), Some(instruction)) + return (Some(update), Some(instruction)); } else { return (Some(update), None); } - }, - StateUpdate::PauseTimer(value) => {return self.pause_timer(value)}, - StateUpdate::TimerLength(value) => {self.timer_length = value; return (Some(update), None)}, - StateUpdate::TimerText(value) => {self.timer_text = value.clone(); return (Some(StateUpdate::TimerText(value)), None)}, + } + StateUpdate::PauseTimer(value) => return self.pause_timer(value), + StateUpdate::TimerLength(value) => { + self.timer_length = value; + return (Some(update), None); + } + StateUpdate::TimerText(value) => { + self.timer_text = value.clone(); + return (Some(StateUpdate::TimerText(value)), None); + } StateUpdate::SubScene(value) => { if value.get_type().is_camera() { if self.current_scene.is_camera() { hotkey_handler.change_scene(Scenes::Camera, Some(value)); } self.camera_sub_scene = value; - return (Some(update), None) + return (Some(update), None); } else if value.get_type().is_screen() { if self.current_scene.is_screen() { hotkey_handler.change_scene(Scenes::Screen, Some(value)); } self.screen_sub_scene = value; - return (Some(update), None) + return (Some(update), None); } - }, + } StateUpdate::Scene(value) => { println!("handling scene: {:?}", value); - + let mut instruction = None; if self.current_scene != value { match value { Scenes::Camera => { - hotkey_handler.change_scene(Scenes::Camera, Some(self.camera_sub_scene)); + hotkey_handler + .change_scene(Scenes::Camera, Some(self.camera_sub_scene)); if self.timer_paused_length.is_none() { instruction = Some(vec![StateUpdate::TimerText("0.0".to_string())]); } self.timer_finished = true; - }, + } Scenes::Screen => { - hotkey_handler.change_scene(Scenes::Screen, Some(self.screen_sub_scene)); + hotkey_handler + .change_scene(Scenes::Screen, Some(self.screen_sub_scene)); self.timer_start = SystemTime::now(); self.timer_finished = false; - - }, + } Scenes::Augmented => { hotkey_handler.change_scene(Scenes::Augmented, None); self.timer_finished = true; } } } - // if the current scene was tapped again + // if the current scene was tapped again else { // current scene can only be the same as value, and timer is paused if value.is_screen() && self.timer_paused_length.is_some() { instruction = Some(vec![StateUpdate::PauseTimer(false)]); } } - + self.current_scene = value; return (Some(update), instruction); - }, - StateUpdate::StreamSoundToggleOn(value) => {hotkey_handler.toggle_stream_sound(value); return (Some(update), None)}, - StateUpdate::ToggleComputerSoundOn(value) => {hotkey_handler.toggle_computer_sound(!value); return (Some(StateUpdate::ToggleComputerSoundOn(!value)), None)}, - StateUpdate::ComputerMediaDoPause => {hotkey_handler.toggle_media_play_pause(); return (Some(update), None)}, - StateUpdate::UpdateClient => {}, - StateUpdate::StreamRunning(_) => {}, + } + StateUpdate::StreamSoundToggleOn(value) => { + hotkey_handler.toggle_stream_sound(value); + return (Some(update), None); + } + StateUpdate::ToggleComputerSoundOn(value) => { + hotkey_handler.toggle_computer_sound(!value); + return (Some(StateUpdate::ToggleComputerSoundOn(!value)), None); + } + StateUpdate::ComputerMediaDoPause => { + hotkey_handler.toggle_media_play_pause(); + return (Some(update), None); + } + StateUpdate::UpdateClient => {} + StateUpdate::StreamRunning(_) => {} //_ => {} } (None, None) @@ -152,22 +188,21 @@ impl MessageHandler for StreamState { fn pause_timer(&mut self, do_pause: bool) -> (Option, Option>) { let output: StateUpdate; let mut instruction: Option> = None; - - // if do pause, - if do_pause { + // if do pause, + if do_pause { // if camera scene, don't allow it! if self.current_scene.is_camera() { - return (None, None) + return (None, None); } // stop tick from running, self.timer_can_run = false; - + // get the amount of time left on the clock let time_left: u16; match self.timer_start.elapsed() { - Err(_) => {time_left = 0}, + Err(_) => time_left = 0, Ok(change) => { // take the duration left, multiply it by 10 to save the last decimal, // then drop the rest of the digits with .round() @@ -175,52 +210,63 @@ impl MessageHandler for StreamState { } } self.timer_paused_length = Some(time_left); - + // (Send to socket, process another instruction) // send the pause singal to the socket, and update the timer text (dividing by 10 to return the last digit) - return (Some(StateUpdate::PauseTimer(true)), Some(vec![StateUpdate::TimerText(format!("{:.1}", time_left as f32/10.0))])); + return ( + Some(StateUpdate::PauseTimer(true)), + Some(vec![StateUpdate::TimerText(format!( + "{:.1}", + time_left as f32 / 10.0 + ))]), + ); } else { // if start timer from pause // enable tick() self.timer_can_run = true; // Some fancy check to not have to use a match statement. The 'expect' should never be called, worry if it does - let timer_paused_length: u16 = self.timer_paused_length.or(Some(0)).expect("timer_paused 'Some' unwrap somehow failed"); - + let timer_paused_length: u16 = self + .timer_paused_length + .or(Some(0)) + .expect("timer_paused 'Some' unwrap somehow failed"); + // if camera scene, don't reset the time_start if self.current_scene.is_camera() { instruction = Some(vec![StateUpdate::TimerText("0.0".to_string())]); self.timer_start += std::time::Duration::from_secs(self.timer_length as u64); } else { // update timer_start, taking into account the amount of time already run - self.timer_start = SystemTime::now() - - std::time::Duration::from_millis( - // first get the decimal back from timer_paused_length, get the amount of time already run - // then convert that to milliseconds, then from f32 to u64 - ((self.timer_length - (timer_paused_length as f32 / 10.0)) * 1000.0) as u64); + self.timer_start = SystemTime::now() + - std::time::Duration::from_millis( + // first get the decimal back from timer_paused_length, get the amount of time already run + // then convert that to milliseconds, then from f32 to u64 + ((self.timer_length - (timer_paused_length as f32 / 10.0)) * 1000.0) as u64, + ); } // Clear the paused time self.timer_paused_length = None; output = StateUpdate::PauseTimer(false); } - return (Some(output), instruction) + return (Some(output), instruction); } fn tick(&mut self) -> Vec { let mut instructions = Vec::new(); if self.timer_finished == false && self.timer_can_run == true { match self.timer_start.elapsed() { - Err(_) => {}, + Err(_) => {} Ok(change) => { if change.as_secs_f32() >= self.timer_length { self.timer_finished = true; instructions.push(StateUpdate::TimerText(String::from("0.0"))); instructions.push(StateUpdate::Scene(Scenes::Camera)); } else { - instructions.push(StateUpdate::TimerText( - format!("{:.1}", self.timer_length - ((change.as_secs_f32() * 10.0).round() / 10.0)) - )); + instructions.push(StateUpdate::TimerText(format!( + "{:.1}", + self.timer_length - ((change.as_secs_f32() * 10.0).round() / 10.0) + ))); } } } @@ -228,10 +274,9 @@ impl MessageHandler for StreamState { instructions } - fn get_states(&self) -> StreamState{ + fn get_states(&self) -> StreamState { self.clone() } - } #[test] @@ -266,4 +311,4 @@ fn test_tick_10() { let mut update = state.tick(); state.update(update.pop().unwrap()); assert_eq!(state.timer_text, "5.0"); -} \ No newline at end of file +} diff --git a/src/modules/mod.rs b/src/modules/mod.rs index fda7886..bcb12d6 100644 --- a/src/modules/mod.rs +++ b/src/modules/mod.rs @@ -1,11 +1,10 @@ - +pub mod external_interface; pub mod message_handler; pub mod socket_handler; -pub mod external_interface; pub mod tray_icon; pub mod stream_states { - pub mod stream_state; - pub mod state_update; pub mod scenes; -} \ No newline at end of file + pub mod state_update; + pub mod stream_state; +} diff --git a/src/modules/socket_handler.rs b/src/modules/socket_handler.rs index 1a01b64..c267b59 100644 --- a/src/modules/socket_handler.rs +++ b/src/modules/socket_handler.rs @@ -1,19 +1,18 @@ -use workctl::sync_flag; -use std::net::{TcpListener, TcpStream, Shutdown}; +use crossbeam_channel::Sender; use std::io::{Read, Write}; -use std::sync::{Mutex, Arc}; -use crossbeam_channel::{Sender}; +use std::net::{Shutdown, TcpListener, TcpStream}; +use std::sync::{Arc, Mutex}; use std::thread::{self, JoinHandle}; use std::time::Duration; +use workctl::sync_flag; -pub struct Socket{ +pub struct Socket { socket_txs: Arc>>>, stop_listener_flag: sync_flag::SyncFlagTx, handle_connections_join_handle: Option>, } impl Socket { - pub fn make_listener(address: &str) -> TcpListener { TcpListener::bind(address).unwrap() } @@ -61,7 +60,9 @@ impl Socket { if msg_len == 0 { remove.push(i); } else { - update_tx.send(String::from_utf8_lossy(&buffer[0..msg_len]).into_owned()).unwrap(); + update_tx + .send(String::from_utf8_lossy(&buffer[0..msg_len]).into_owned()) + .unwrap(); } } } @@ -69,31 +70,32 @@ impl Socket { streams.get(*i).unwrap().shutdown(Shutdown::Both).unwrap(); streams.remove(*i); } - } pub fn close(&mut self) { self.stop_listener_flag.set(false); self.handle_connections_join_handle - .take().expect("Called on not running thread") - .join().expect("Could not join thread"); + .take() + .expect("Called on not running thread") + .join() + .expect("Could not join thread"); } pub fn send(&self, message: String) { let mut streams = self.socket_txs.lock().unwrap(); let mut removes = Vec::::new(); - if streams.len() == 0 {return} - for i in 0..streams.len(){ + if streams.len() == 0 { + return; + } + for i in 0..streams.len() { match streams.get(i) { None => { removes.push(i); - }, + } Some(strm) => { let mut tx = strm.as_ref(); match tx.write(message.clone().as_bytes()) { - Err(_) => { - removes.push(i) - }, + Err(_) => removes.push(i), Ok(_) => { tx.write(b"\n").unwrap(); tx.flush().unwrap(); @@ -106,4 +108,4 @@ impl Socket { streams.remove(*i); } } -} \ No newline at end of file +} diff --git a/src/modules/tray_icon.rs b/src/modules/tray_icon.rs index fdfb15c..5f25565 100644 --- a/src/modules/tray_icon.rs +++ b/src/modules/tray_icon.rs @@ -24,9 +24,7 @@ pub struct TrayIcon { } impl TrayIcon { - pub fn setup(icon: &[u8]) -> TrayIcon { - let (s, r) = crossbeam_channel::unbounded(); let icon1 = include_bytes!("./../icon1.ico"); let icon2 = include_bytes!("./../icon2.ico"); @@ -66,7 +64,7 @@ impl TrayIcon { ) .build() .unwrap(); - + TrayIcon { tray_icon, message_channel: r, @@ -87,8 +85,7 @@ impl TrayIcon { } } - pub fn check_tray_messages(&self){ - + pub fn check_tray_messages(&self) { let message = self.message_channel.recv_timeout(Duration::from_millis(10)); match message { Err(_) => return, @@ -115,12 +112,12 @@ impl TrayIcon { Events::Item3 => { println!("item3"); /*tray_icon - .set_menu( - &MenuBuilder::new() - .item("New menu item", Events::Item1) - .item("Exit", Events::Exit), - ) - .unwrap();*/ + .set_menu( + &MenuBuilder::new() + .item("New menu item", Events::Item1) + .item("Exit", Events::Exit), + ) + .unwrap();*/ } e => { println!("{:?}", e); @@ -129,5 +126,4 @@ impl TrayIcon { } } } - -} \ No newline at end of file +} diff --git a/src/tests/main_tests.rs b/src/tests/main_tests.rs index 7663800..999f674 100644 --- a/src/tests/main_tests.rs +++ b/src/tests/main_tests.rs @@ -1,7 +1,8 @@ use workctl::sync_flag; -use crate::modules::{stream_states::{ stream_state::StreamState, scenes::Scenes, state_update::StateUpdate}}; - +use crate::modules::stream_states::{ + scenes::Scenes, state_update::StateUpdate, stream_state::StreamState, +}; #[test] fn it_works() { @@ -16,7 +17,6 @@ fn can_make_ctrl_c_handler() { drop(_control_c_called_flag_rx); } - #[test] fn test_updating_state_from_state_update() { let mut state = StreamState::new(); diff --git a/src/tests/message_handler_tests.rs b/src/tests/message_handler_tests.rs index aedb013..065a16b 100644 --- a/src/tests/message_handler_tests.rs +++ b/src/tests/message_handler_tests.rs @@ -1,10 +1,13 @@ -use crate::modules::{message_handler::{MessageHandler}, stream_states::{state_update::StateUpdate, stream_state::StreamState}, external_interface::Hotkeys}; - +use crate::modules::{ + external_interface::Hotkeys, + message_handler::MessageHandler, + stream_states::{state_update::StateUpdate, stream_state::StreamState}, +}; #[test] fn does_stream_state_implement_message_handler() { let hotkeys = Hotkeys { - hotkeys: serde_json::Value::Null + hotkeys: serde_json::Value::Null, }; let mut state = StreamState::new(); state.debug_mode = true; diff --git a/src/tests/mod.rs b/src/tests/mod.rs index a09f044..ded3f66 100644 --- a/src/tests/mod.rs +++ b/src/tests/mod.rs @@ -1,12 +1,11 @@ - #[cfg(test)] pub mod main_tests; -#[cfg(test)] -pub mod stream_states_tests; #[cfg(test)] pub mod message_handler_tests; #[cfg(test)] pub mod socket_handler_tests; #[cfg(test)] -pub mod state_update_tests; \ No newline at end of file +pub mod state_update_tests; +#[cfg(test)] +pub mod stream_states_tests; diff --git a/src/tests/socket_handler_tests.rs b/src/tests/socket_handler_tests.rs index 3ecba35..e39d559 100644 --- a/src/tests/socket_handler_tests.rs +++ b/src/tests/socket_handler_tests.rs @@ -1,12 +1,12 @@ use crossbeam_channel::unbounded; -use std::io::{Write}; +use std::io::Write; use std::thread; use std::time::Duration; use crate::modules::socket_handler::Socket; #[test] -fn can_make_socket_listener(){ +fn can_make_socket_listener() { let listener = Socket::make_listener("localhost:5001"); drop(listener); } @@ -45,7 +45,7 @@ fn can_handle_messages() { let message = rx_1.recv().unwrap(); assert_eq!(message, String::from("this is a test")); - + socket.close(); } @@ -66,11 +66,10 @@ fn can_handle_delayed_messages() { let message = rx_1.recv().unwrap(); println!("{}", message); assert_eq!(message, String::from("this is a test1\n")); - + let message = rx_1.recv().unwrap(); println!("{}", message); assert_eq!(message, String::from("this is a test3\n")); - + socket.close(); } - diff --git a/src/tests/state_update_tests.rs b/src/tests/state_update_tests.rs index 7799f95..8435ab2 100644 --- a/src/tests/state_update_tests.rs +++ b/src/tests/state_update_tests.rs @@ -1,36 +1,79 @@ -use crate::modules::stream_states::{state_update::StateUpdate, scenes::{Scenes, SubScenes, SlideChange}}; - - +use crate::modules::stream_states::{ + scenes::{Scenes, SlideChange, SubScenes}, + state_update::StateUpdate, +}; #[test] fn test_json_to_state_update() { - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Scene\", \"data\": \"Scene_Camera\"}" - ).unwrap()), StateUpdate::Scene(Scenes::Camera)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Scene\", \"data\": \"Scene_Camera\"}" + ) + .unwrap() + ), + StateUpdate::Scene(Scenes::Camera) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Scene\", \"data\": \"Scene_Screen\"}" - ).unwrap()), StateUpdate::Scene(Scenes::Screen)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Scene\", \"data\": \"Scene_Screen\"}" + ) + .unwrap() + ), + StateUpdate::Scene(Scenes::Screen) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Scene_Is_Augmented\", \"data\": \"true\"}" - ).unwrap()), StateUpdate::SceneIsAugmented(true)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Scene_Is_Augmented\", \"data\": \"true\"}" + ) + .unwrap() + ), + StateUpdate::SceneIsAugmented(true) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Timer_Can_Run\", \"data\": \"true\"}" - ).unwrap()), StateUpdate::TimerCanRun(true)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Timer_Can_Run\", \"data\": \"true\"}" + ) + .unwrap() + ), + StateUpdate::TimerCanRun(true) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Timer_Can_Run\", \"data\": \"false\"}" - ).unwrap()), StateUpdate::TimerCanRun(false)); - - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Change_With_Clicker\", \"data\": \"true\"}" - ).unwrap()), StateUpdate::ChangeSceneOnChangeSlide(true)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Timer_Can_Run\", \"data\": \"false\"}" + ) + .unwrap() + ), + StateUpdate::TimerCanRun(false) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Change_With_Clicker\", \"data\": \"false\"}" - ).unwrap()), StateUpdate::ChangeSceneOnChangeSlide(false)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Change_With_Clicker\", \"data\": \"true\"}" + ) + .unwrap() + ), + StateUpdate::ChangeSceneOnChangeSlide(true) + ); + + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Change_With_Clicker\", \"data\": \"false\"}" + ) + .unwrap() + ), + StateUpdate::ChangeSceneOnChangeSlide(false) + ); assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( "{\"type\": \"update\", \"update\": \"Toggle_Computer_Volume\", \"data\": \"true\"}" @@ -39,100 +82,252 @@ fn test_json_to_state_update() { assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( "{\"type\": \"update\", \"update\": \"Toggle_Computer_Volume\", \"data\": \"false\"}" ).unwrap()), StateUpdate::ToggleComputerSoundOn(false)); - - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Toggle_Stream_Volume\", \"data\": \"true\"}" - ).unwrap()), StateUpdate::StreamSoundToggleOn(true)); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Toggle_Stream_Volume\", \"data\": \"false\"}" - ).unwrap()), StateUpdate::StreamSoundToggleOn(false)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Toggle_Stream_Volume\", \"data\": \"true\"}" + ) + .unwrap() + ), + StateUpdate::StreamSoundToggleOn(true) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Media_Pause_Play\", \"data\": \"true\"}" - ).unwrap()), StateUpdate::ComputerMediaDoPause); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Toggle_Stream_Volume\", \"data\": \"false\"}" + ) + .unwrap() + ), + StateUpdate::StreamSoundToggleOn(false) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_None\"}" - ).unwrap()), StateUpdate::SubScene(SubScenes::CameraDefault)); - - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_Top_Right\"}" - ).unwrap()), StateUpdate::SubScene(SubScenes::CameraWithUpperRight)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Media_Pause_Play\", \"data\": \"true\"}" + ) + .unwrap() + ), + StateUpdate::ComputerMediaDoPause + ); + + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_None\"}" + ) + .unwrap() + ), + StateUpdate::SubScene(SubScenes::CameraDefault) + ); + + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_Top_Right\"}" + ) + .unwrap() + ), + StateUpdate::SubScene(SubScenes::CameraWithUpperRight) + ); assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_Bottom_Right\"}" ).unwrap()), StateUpdate::SubScene(SubScenes::CameraWithLowerRight)); - + assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Camera_Bottom_Left\"}" ).unwrap()), StateUpdate::SubScene(SubScenes::CameraWithLargeUpperRight)); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Screen_None\"}" - ).unwrap()), StateUpdate::SubScene(SubScenes::ScreenDefault)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Screen_None\"}" + ) + .unwrap() + ), + StateUpdate::SubScene(SubScenes::ScreenDefault) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Screen_Top_Right\"}" - ).unwrap()), StateUpdate::SubScene(SubScenes::ScreenWithUpperRight)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"SubScene\", \"data\": \"Screen_Top_Right\"}" + ) + .unwrap() + ), + StateUpdate::SubScene(SubScenes::ScreenWithUpperRight) + ); assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( "{\"type\": \"update\", \"update\": \"SubScene\", \"data\":\"Screen_Bottom_Right\"}" ).unwrap()), StateUpdate::SubScene(SubScenes::ScreenWithLowerRight)); - - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Timer_Length\", \"data\": \"5.5\"}" - ).unwrap()), StateUpdate::TimerLength(5.5)); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Next_Slide\"}" - ).unwrap()), StateUpdate::ChangeSlide(SlideChange::NextHotkey)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str( + "{\"type\": \"update\", \"update\": \"Timer_Length\", \"data\": \"5.5\"}" + ) + .unwrap() + ), + StateUpdate::TimerLength(5.5) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\": \"Prev_Slide\"}" - ).unwrap()), StateUpdate::ChangeSlide(SlideChange::PreviousHotkey)); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str("{\"type\": \"update\", \"update\": \"Next_Slide\"}").unwrap() + ), + StateUpdate::ChangeSlide(SlideChange::NextHotkey) + ); - assert_eq!(StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"update\", \"update\":\"all\"}" - ).unwrap()), StateUpdate::UpdateClient); + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str("{\"type\": \"update\", \"update\": \"Prev_Slide\"}").unwrap() + ), + StateUpdate::ChangeSlide(SlideChange::PreviousHotkey) + ); + + assert_eq!( + StateUpdate::json_to_state_update( + serde_json::from_str("{\"type\": \"update\", \"update\":\"all\"}").unwrap() + ), + StateUpdate::UpdateClient + ); } #[test] #[should_panic] fn test_json_to_state_update_fails() { - StateUpdate::json_to_state_update(serde_json::from_str( - "{\"type\": \"AnUnknownType\"}" - ).unwrap()); + StateUpdate::json_to_state_update( + serde_json::from_str("{\"type\": \"AnUnknownType\"}").unwrap(), + ); } #[test] fn test_state_update_to_json() { //Note, this one needs to is dependant on test_json_to_update for correctedness - assert_eq!(StateUpdate::StreamRunning(true), (StateUpdate::json_to_state_update(StateUpdate::StreamRunning(true).to_json()))); - assert_eq!(StateUpdate::StreamRunning(false), StateUpdate::json_to_state_update(StateUpdate::StreamRunning(false).to_json())); - assert_eq!(StateUpdate::StreamSoundToggleOn(true), StateUpdate::json_to_state_update(StateUpdate::StreamSoundToggleOn(true).to_json())); - assert_eq!(StateUpdate::StreamSoundToggleOn(false), StateUpdate::json_to_state_update(StateUpdate::StreamSoundToggleOn(false).to_json())); - assert_eq!(StateUpdate::ToggleComputerSoundOn(true), StateUpdate::json_to_state_update(StateUpdate::ToggleComputerSoundOn(true).to_json())); - assert_eq!(StateUpdate::ToggleComputerSoundOn(false), StateUpdate::json_to_state_update(StateUpdate::ToggleComputerSoundOn(false).to_json())); - assert_eq!(StateUpdate::ChangeSceneOnChangeSlide(true), StateUpdate::json_to_state_update(StateUpdate::ChangeSceneOnChangeSlide(true).to_json())); - assert_eq!(StateUpdate::ChangeSceneOnChangeSlide(false), StateUpdate::json_to_state_update(StateUpdate::ChangeSceneOnChangeSlide(false).to_json())); - assert_eq!(StateUpdate::SceneIsAugmented(true), StateUpdate::json_to_state_update(StateUpdate::SceneIsAugmented(true).to_json())); - assert_eq!(StateUpdate::SceneIsAugmented(false), StateUpdate::json_to_state_update(StateUpdate::SceneIsAugmented(false).to_json())); - assert_eq!(StateUpdate::TimerCanRun(true), StateUpdate::json_to_state_update(StateUpdate::TimerCanRun(true).to_json())); - assert_eq!(StateUpdate::TimerCanRun(false), StateUpdate::json_to_state_update(StateUpdate::TimerCanRun(false).to_json())); - assert_eq!(StateUpdate::TimerLength(17.5), StateUpdate::json_to_state_update(StateUpdate::TimerLength(17.5).to_json())); - assert_eq!(StateUpdate::TimerText(String::from("15.6")), StateUpdate::json_to_state_update(StateUpdate::TimerText(String::from("15.6")).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::CameraDefault), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::CameraDefault).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::CameraWithUpperRight), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::CameraWithUpperRight).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::CameraWithLowerRight), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::CameraWithLowerRight).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::CameraWithLargeUpperRight), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::CameraWithLargeUpperRight).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::ScreenDefault), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::ScreenDefault).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::ScreenWithUpperRight), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::ScreenWithUpperRight).to_json())); - assert_eq!(StateUpdate::SubScene(SubScenes::ScreenWithLowerRight), StateUpdate::json_to_state_update(StateUpdate::SubScene(SubScenes::ScreenWithLowerRight).to_json())); - assert_eq!(StateUpdate::Scene(Scenes::Camera), StateUpdate::json_to_state_update(StateUpdate::Scene(Scenes::Camera).to_json())); - assert_eq!(StateUpdate::Scene(Scenes::Screen), StateUpdate::json_to_state_update(StateUpdate::Scene(Scenes::Screen).to_json())); - assert_eq!(StateUpdate::ChangeSlide(SlideChange::NextHotkey), StateUpdate::json_to_state_update(StateUpdate::ChangeSlide(SlideChange::NextHotkey).to_json())); - assert_eq!(StateUpdate::ChangeSlide(SlideChange::PreviousHotkey), StateUpdate::json_to_state_update(StateUpdate::ChangeSlide(SlideChange::PreviousHotkey).to_json())); - assert_eq!(StateUpdate::UpdateClient, StateUpdate::json_to_state_update(StateUpdate::UpdateClient.to_json())); - -} \ No newline at end of file + assert_eq!( + StateUpdate::StreamRunning(true), + (StateUpdate::json_to_state_update(StateUpdate::StreamRunning(true).to_json())) + ); + assert_eq!( + StateUpdate::StreamRunning(false), + StateUpdate::json_to_state_update(StateUpdate::StreamRunning(false).to_json()) + ); + assert_eq!( + StateUpdate::StreamSoundToggleOn(true), + StateUpdate::json_to_state_update(StateUpdate::StreamSoundToggleOn(true).to_json()) + ); + assert_eq!( + StateUpdate::StreamSoundToggleOn(false), + StateUpdate::json_to_state_update(StateUpdate::StreamSoundToggleOn(false).to_json()) + ); + assert_eq!( + StateUpdate::ToggleComputerSoundOn(true), + StateUpdate::json_to_state_update(StateUpdate::ToggleComputerSoundOn(true).to_json()) + ); + assert_eq!( + StateUpdate::ToggleComputerSoundOn(false), + StateUpdate::json_to_state_update(StateUpdate::ToggleComputerSoundOn(false).to_json()) + ); + assert_eq!( + StateUpdate::ChangeSceneOnChangeSlide(true), + StateUpdate::json_to_state_update(StateUpdate::ChangeSceneOnChangeSlide(true).to_json()) + ); + assert_eq!( + StateUpdate::ChangeSceneOnChangeSlide(false), + StateUpdate::json_to_state_update(StateUpdate::ChangeSceneOnChangeSlide(false).to_json()) + ); + assert_eq!( + StateUpdate::SceneIsAugmented(true), + StateUpdate::json_to_state_update(StateUpdate::SceneIsAugmented(true).to_json()) + ); + assert_eq!( + StateUpdate::SceneIsAugmented(false), + StateUpdate::json_to_state_update(StateUpdate::SceneIsAugmented(false).to_json()) + ); + assert_eq!( + StateUpdate::TimerCanRun(true), + StateUpdate::json_to_state_update(StateUpdate::TimerCanRun(true).to_json()) + ); + assert_eq!( + StateUpdate::TimerCanRun(false), + StateUpdate::json_to_state_update(StateUpdate::TimerCanRun(false).to_json()) + ); + assert_eq!( + StateUpdate::TimerLength(17.5), + StateUpdate::json_to_state_update(StateUpdate::TimerLength(17.5).to_json()) + ); + assert_eq!( + StateUpdate::TimerText(String::from("15.6")), + StateUpdate::json_to_state_update(StateUpdate::TimerText(String::from("15.6")).to_json()) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::CameraDefault), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::CameraDefault).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::CameraWithUpperRight), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::CameraWithUpperRight).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::CameraWithLowerRight), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::CameraWithLowerRight).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::CameraWithLargeUpperRight), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::CameraWithLargeUpperRight).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::ScreenDefault), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::ScreenDefault).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::ScreenWithUpperRight), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::ScreenWithUpperRight).to_json() + ) + ); + assert_eq!( + StateUpdate::SubScene(SubScenes::ScreenWithLowerRight), + StateUpdate::json_to_state_update( + StateUpdate::SubScene(SubScenes::ScreenWithLowerRight).to_json() + ) + ); + assert_eq!( + StateUpdate::Scene(Scenes::Camera), + StateUpdate::json_to_state_update(StateUpdate::Scene(Scenes::Camera).to_json()) + ); + assert_eq!( + StateUpdate::Scene(Scenes::Screen), + StateUpdate::json_to_state_update(StateUpdate::Scene(Scenes::Screen).to_json()) + ); + assert_eq!( + StateUpdate::ChangeSlide(SlideChange::NextHotkey), + StateUpdate::json_to_state_update( + StateUpdate::ChangeSlide(SlideChange::NextHotkey).to_json() + ) + ); + assert_eq!( + StateUpdate::ChangeSlide(SlideChange::PreviousHotkey), + StateUpdate::json_to_state_update( + StateUpdate::ChangeSlide(SlideChange::PreviousHotkey).to_json() + ) + ); + assert_eq!( + StateUpdate::UpdateClient, + StateUpdate::json_to_state_update(StateUpdate::UpdateClient.to_json()) + ); +} diff --git a/src/tests/stream_states_tests.rs b/src/tests/stream_states_tests.rs index d587509..980eea9 100644 --- a/src/tests/stream_states_tests.rs +++ b/src/tests/stream_states_tests.rs @@ -39,62 +39,124 @@ fn create_stream_states_class() { assert_eq!(stream_state.timer_can_run, true); assert_eq!(stream_state.current_scene, s_s::scenes::Scenes::Camera); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraDefault); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); - + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraDefault + ); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); } #[test] -fn scene_correctness(){ +fn scene_correctness() { let mut stream_state = s_s::stream_state::StreamState::new(); assert_eq!(stream_state.current_scene, s_s::scenes::Scenes::Camera); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraDefault); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraDefault + ); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); - stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::CameraWithUpperRight)); + stream_state.update(StateUpdate::SubScene( + s_s::scenes::SubScenes::CameraWithUpperRight, + )); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithUpperRight); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithUpperRight + ); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); - stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::CameraWithLargeUpperRight)); + stream_state.update(StateUpdate::SubScene( + s_s::scenes::SubScenes::CameraWithLargeUpperRight, + )); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLargeUpperRight); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLargeUpperRight + ); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); - stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::CameraWithLowerRight)); + stream_state.update(StateUpdate::SubScene( + s_s::scenes::SubScenes::CameraWithLowerRight, + )); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLowerRight); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLowerRight + ); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::ScreenDefault)); stream_state.update(StateUpdate::Scene(s_s::scenes::Scenes::Screen)); - + assert_eq!(stream_state.current_scene, s_s::scenes::Scenes::Screen); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenDefault); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLowerRight); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenDefault + ); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLowerRight + ); - stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::ScreenWithLowerRight)); - - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenWithLowerRight); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLowerRight); + stream_state.update(StateUpdate::SubScene( + s_s::scenes::SubScenes::ScreenWithLowerRight, + )); - stream_state.update(StateUpdate::SubScene(s_s::scenes::SubScenes::ScreenWithUpperRight)); - - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenWithUpperRight); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLowerRight); + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenWithLowerRight + ); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLowerRight + ); + + stream_state.update(StateUpdate::SubScene( + s_s::scenes::SubScenes::ScreenWithUpperRight, + )); + + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenWithUpperRight + ); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLowerRight + ); stream_state.update(StateUpdate::Scene(s_s::scenes::Scenes::Augmented)); assert_eq!(stream_state.current_scene, s_s::scenes::Scenes::Augmented); - assert_eq!(stream_state.screen_sub_scene, s_s::scenes::SubScenes::ScreenWithUpperRight); - assert_eq!(stream_state.camera_sub_scene, s_s::scenes::SubScenes::CameraWithLowerRight); - + assert_eq!( + stream_state.screen_sub_scene, + s_s::scenes::SubScenes::ScreenWithUpperRight + ); + assert_eq!( + stream_state.camera_sub_scene, + s_s::scenes::SubScenes::CameraWithLowerRight + ); } #[test] fn test_updating() { let mut stream_state = s_s::stream_state::StreamState::new(); - + assert_eq!(stream_state.timer_can_run, true); stream_state.update(StateUpdate::TimerCanRun(false)); assert_eq!(stream_state.timer_can_run, false); @@ -128,7 +190,6 @@ fn test_updating() { assert_eq!(stream_state.scene_is_augmented, true); } - #[test] fn can_run_in_thread() { let (tx, rx) = mpsc::channel(); @@ -149,4 +210,4 @@ fn can_run_in_thread() { Ok(_) => return, Err(_) => panic!(), } -} \ No newline at end of file +}