Nickiel/church_controller_rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ran rustfmt

Browse source
This commit is contained in:
Nickiel12 2022-07-16 21:16:56 -07:00
parent a3e675def6
commit 06333b7fe2
12 changed files with 753 additions and 330 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
src/main.rs
View file

@ -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::<String>();
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<StateUpdate>, state: &mut StreamState, socket: &Socket, hotkeys: &Hotkeys) {
fn handle_instructions(
mut instructions: Vec<StateUpdate>,
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<StateUpdate>, 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(),
);
}

165
src/modules/external_interface.rs
View file

@ -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<String>, close_flag: workctl::sync_flag::SyncFlagRx) {
pub fn create_keyboard_hooks(
channel_tx: crossbeam_channel::Sender<String>,
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<String>, close_flag: workctl::sync_flag::SyncFlagRx) {
return
pub fn create_keyboard_hooks(
channel_tx: crossbeam_channel::Sender<String>,
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();
}
}

183
src/modules/message_handler.rs
View file

@ -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<StateUpdate>, Option<Vec<StateUpdate>>);
pub trait MessageHandler {
//the first one goes to socket, the second propogates
fn handle_update(
&mut self,
update: StateUpdate,
hotkey_handler: &Hotkeys,
) -> (Option<StateUpdate>, Option<Vec<StateUpdate>>);
fn get_states(&self) -> StreamState;
fn pause_timer(&mut self, do_pause: bool) -> (Option<StateUpdate>, Option<Vec<StateUpdate>>);
fn tick(&mut self) -> Vec<StateUpdate>;
}
impl MessageHandler for StreamState {
fn handle_update(&mut self, update: StateUpdate, hotkey_handler: &Hotkeys)
-> (Option<StateUpdate>, Option<Vec<StateUpdate>>) {
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<StateUpdate>, Option<Vec<StateUpdate>>) {
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<StateUpdate>, Option<Vec<StateUpdate>>) {
let output: StateUpdate;
let mut instruction: Option<Vec<StateUpdate>> = 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<StateUpdate> {
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");
}
}

9
src/modules/mod.rs
View file

@ -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;
}
pub mod state_update;
pub mod stream_state;
}

36
src/modules/socket_handler.rs
View file

@ -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<Mutex<Vec<Arc<TcpStream>>>>,
stop_listener_flag: sync_flag::SyncFlagTx,
handle_connections_join_handle: Option<JoinHandle<()>>,
}
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::<usize>::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);
}
}
}
}

22
src/modules/tray_icon.rs
View file

@ -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 {
}
}
}
}
}

6
src/tests/main_tests.rs
View file

@ -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();

9
src/tests/message_handler_tests.rs
View file

@ -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;

7
src/tests/mod.rs
View file

@ -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;
pub mod state_update_tests;
#[cfg(test)]
pub mod stream_states_tests;

11
src/tests/socket_handler_tests.rs
View file

@ -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();
}

381
src/tests/state_update_tests.rs
View file

@ -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()));
}
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())
);
}

125
src/tests/stream_states_tests.rs
View file

@ -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!(),
}
}
}