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

Compare commits

base: Nickiel:master
Branches Tags
Nickiel:master
Nickiel:Pre-trayicon
Nickiel:windows
..
compare: Nickiel:Pre-trayicon
Branches Tags
Nickiel:master
Nickiel:Pre-trayicon
Nickiel:windows

1 commit
master ... Pre-trayic

Author SHA1 Message Date
Nickiel12
b57633b89a feat!: doesn't hardcode host ip 2022-11-05 14:28:48 -07:00
17 changed files with 340 additions and 944 deletions
Show stats Expand all files Collapse all files

3
Cargo.toml
View file

@ -11,9 +11,6 @@ ctrlc = "3.2.1"
serde_json = "1.0"
crossbeam-channel = "0.5"
inputbot = {path = "D:\\Inputbot"}
winit = "0.25"
winapi = { version = "0.3.9", features = ["winuser", "windef", "minwindef", "shellapi", "libloaderapi", "commctrl", "basetsd"] }
trayicon = { version="0.1.3", features = ["crossbeam-channel"] }
[features]
default = []

3
options.json
View file

@ -18,7 +18,8 @@
"windows":{
"obs_re": "OBS *",
"propresenter_re": "ProPresenter - .*",
"chrome_re": ".* - Google Chrome"
"chrome_re": ".* - Google Chrome",
"tcp_port": "8005"
},
"hotkeys":{
"obs":{

19
shell.nix
View file

@ -1,19 +0,0 @@
# <shell.nix>
{ pkgs ? import <nixpkgs> {}}:
let
rust_overlay = import (builtins.fetchTarball "https://github.com/oxalica/rust-overlay/archive/master.tar.gz");
pkgs = import <nixpkgs> { overlays = [ rust_overlay ]; };
ruststable = (pkgs.rust-bin.stable.latest.default.override {
extensions = [
"rust-src"
];
});
in
pkgs.mkShell {
buildInputs = with pkgs; [
ruststable
rust-analyzer
bacon
];
}

BIN
src/icon1.ico
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 34 KiB

BIN
src/icon2.ico
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 34 KiB

189
src/main.rs
View file

@ -1,97 +1,61 @@
use std::{time::Duration, thread, io::Read};
use crossbeam_channel::unbounded;
use tray_icon::TrayIcon;
use std::{io::Read, thread, time::Duration};
use modules::{
external_interface::{Hotkeys, OPTIONS_PATH},
message_handler::MessageHandler,
socket_handler::Socket,
stream_states::stream_state::StreamState,
};
use modules::{socket_handler::Socket, stream_states::stream_state::StreamState, message_handler::{MessageHandler}, external_interface::{Hotkeys, OPTIONS_PATH}};
use workctl::sync_flag;
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";
#[cfg(release)]
#[cfg(target_os = "windows")]
const SERVER_ADDRESS: &str = "10.0.0.209:5000";
#[cfg(target_os = "linux")]
const SERVER_ADDRESS: &str = "10.0.0.168:5000";
const SERVER_ADDRESS: &str = "0.0.0.0:";
fn main() {
let icon = include_bytes!("icon1.ico");
let tray_icon = tray_icon::TrayIcon::setup(icon);
let settings_json = load_json();
let hotkeys = Hotkeys::new(settings_json);
let hotkeys = Hotkeys::new(settings_json.clone());
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 control_c_called_flag_rx = setup_control_c();
println!("Opening on port: {}", settings_json["windows"]["tcp_port"]);
let mut socket = Socket::handle_connections(Socket::make_listener((String::from(SERVER_ADDRESS) + &settings_json["windows"]["tcp_port"].to_string()).as_str()), 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);
println!("closing hotkey thread");
modules::external_interface::create_keyboard_hooks(hotkey_channel_tx, hotkey_close_flag_rx);
});
let mut state = StreamState::new();
//until control_c is caught, check the queue of incoming
//requests from the socket handler.
let stop_flag = control_c_called_flag_rx.clone();
let messages = tray_icon.message_channel.clone();
std::thread::spawn(move || {
while !control_c_called_flag_rx.get() {
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());
if update == StateUpdate::UpdateClient {
update_all(&state, &socket);
} else {
handle_instructions(vec![update], &mut state, &socket, &hotkeys);
}
while !control_c_called_flag_rx.get() {
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());
if update == StateUpdate::UpdateClient {
update_all(&state, &socket);
} else {
handle_instructions(vec![update], &mut state, &socket, &hotkeys);
}
Err(_) => {}
}
let tick_update = state.tick();
handle_instructions(tick_update, &mut state, &socket, &hotkeys);
TrayIcon::handle_tray_messages(&messages);
},
Err(_) => {},
}
socket.close();
});
while !stop_flag.get() {
tray_icon.check_tray_icon_messages();
//tray_icon.check_tray_messages();
let tick_update = state.tick();
handle_instructions(tick_update, &mut state, &socket, &hotkeys);
}
println!("closing main thread");
socket.close();
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() {
@ -105,84 +69,37 @@ fn handle_instructions(
}
}
fn setup_control_c() -> 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);
})
.expect("control C handler failed!");
hotkey_close_flag_tx.set(false);
}).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());
}

166
src/modules/external_interface.rs
View file

@ -1,57 +1,41 @@
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>,
) {
#[cfg(feature = "default")]
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();
}
#[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 {
@ -60,35 +44,20 @@ 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()},
}
}
@ -96,11 +65,9 @@ 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));
@ -110,58 +77,32 @@ 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())
};
}
@ -169,34 +110,28 @@ 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");
@ -204,19 +139,20 @@ 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;
@ -238,4 +174,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,62 +1,47 @@
use std::time::SystemTime;
use std::time::{SystemTime};
use super::{
external_interface::Hotkeys,
stream_states::{
scenes::{Scenes, SlideChange},
state_update::StateUpdate,
stream_state::StreamState,
},
};
use super::{stream_states::{state_update::StateUpdate, stream_state::StreamState, scenes::{SlideChange, Scenes}}, external_interface::{Hotkeys}};
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;
@ -65,22 +50,17 @@ impl MessageHandler for StreamState {
let mut instructions = Vec::new();
instructions.push(StateUpdate::Scene(Scenes::Screen));
return (None, Some(instructions));
} else {
return (None, None);
}
}
StateUpdate::ChangeSceneOnChangeSlide(value) => {
self.change_scene_on_slide_hotkey = value;
return (Some(update), None);
return (None, Some(instructions))
} else {return (None, 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));
@ -88,9 +68,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)]));
}
@ -100,86 +80,70 @@ 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)
@ -188,21 +152,22 @@ 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 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()
@ -210,63 +175,52 @@ 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))
));
}
}
}
@ -274,9 +228,10 @@ impl MessageHandler for StreamState {
instructions
}
fn get_states(&self) -> StreamState {
fn get_states(&self) -> StreamState{
self.clone()
}
}
#[test]
@ -311,4 +266,4 @@ fn test_tick_10() {
let mut update = state.tick();
state.update(update.pop().unwrap());
assert_eq!(state.timer_text, "5.0");
}
}

10
src/modules/mod.rs
View file

@ -1,10 +1,10 @@
pub mod external_interface;
pub mod message_handler;
pub mod socket_handler;
pub mod tray_icon;
pub mod external_interface;
pub mod stream_states {
pub mod scenes;
pub mod state_update;
pub mod stream_state;
}
pub mod state_update;
pub mod scenes;
}

39
src/modules/socket_handler.rs
View file

@ -1,18 +1,19 @@
use crossbeam_channel::Sender;
use workctl::sync_flag;
use std::net::{TcpListener, TcpStream, Shutdown};
use std::io::{Read, Write};
use std::net::{Shutdown, TcpListener, TcpStream};
use std::sync::{Arc, Mutex};
use std::sync::{Mutex, Arc};
use crossbeam_channel::{Sender};
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()
}
@ -23,7 +24,6 @@ impl Socket {
let thread_owned_streams = Arc::clone(&socket_streams);
println!("initializing socket connection handling thread");
let handle = thread::spawn(move || {
listener.set_nonblocking(true).unwrap();
let mut service_sockets: Vec<Arc<TcpStream>> = Vec::new();
@ -39,7 +39,7 @@ impl Socket {
Socket::service_clients(&mut service_sockets, messenger_tx.clone());
thread::sleep(Duration::from_millis(100));
}
println!("closed socket connection handling thread");
println!("closed socket loop");
drop(listener);
});
@ -60,9 +60,7 @@ 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();
}
}
}
@ -70,32 +68,31 @@ 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();
@ -108,4 +105,4 @@ impl Socket {
streams.remove(*i);
}
}
}
}

131
src/modules/tray_icon.rs
View file

@ -1,131 +0,0 @@
use core::mem::MaybeUninit;
use std::time::Duration;
use crossbeam_channel::Receiver;
use trayicon::*;
use winapi::um::winuser;
use workctl::sync_flag::SyncFlagRx;
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum Events {
ClickTrayIcon,
DoubleClickTrayIcon,
Exit,
Item1,
Item2,
Item3,
Item4,
CheckItem1,
SubItem1,
SubItem2,
SubItem3,
}
pub struct TrayIcon {
tray_icon: trayicon::TrayIcon<Events>,
pub message_channel: crossbeam_channel::Receiver<Events>,
}
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");
let second_icon = Icon::from_buffer(icon2, None, None).unwrap();
let first_icon = Icon::from_buffer(icon1, None, None).unwrap();
// Needlessly complicated tray icon with all the whistles and bells
let tray_icon = TrayIconBuilder::new()
.sender_crossbeam(s)
.icon_from_buffer(icon1)
.tooltip("Cool Tray 👀 Icon")
.on_click(Events::ClickTrayIcon)
.on_double_click(Events::DoubleClickTrayIcon)
.menu(
MenuBuilder::new()
.item("Item 3 Replace Menu 👍", Events::Item3)
.item("Item 2 Change Icon Green", Events::Item2)
.item("Item 1 Change Icon Red", Events::Item1)
.separator()
.checkable("This is checkable", true, Events::CheckItem1)
.submenu(
"Sub Menu",
MenuBuilder::new()
.item("Sub item 1", Events::SubItem1)
.item("Sub Item 2", Events::SubItem2)
.item("Sub Item 3", Events::SubItem3),
)
.with(MenuItem::Item {
name: "Item Disabled".into(),
disabled: true, // Disabled entry example
id: Events::Item4,
icon: None,
})
.separator()
.item("E&xit", Events::Exit),
)
.build()
.unwrap();
TrayIcon {
tray_icon,
message_channel: r,
}
}
pub fn check_tray_icon_messages(&self) {
unsafe {
let mut msg = MaybeUninit::uninit();
let bret = winuser::PeekMessageA(msg.as_mut_ptr(), 0 as _, 0, 0, 1);
if bret > 0 {
winuser::TranslateMessage(msg.as_ptr());
winuser::DispatchMessageA(msg.as_ptr());
} else {
return;
}
}
}
pub fn handle_tray_messages(message_channel: &Receiver<Events>) {
let message = message_channel.recv_timeout(Duration::from_millis(10));
match message {
Err(_) => return,
Ok(message) => {
match message {
Events::DoubleClickTrayIcon => {
println!("Double click");
}
Events::ClickTrayIcon => {
println!("Single click");
}
Events::Exit => {
println!("Please exit");
todo!()
}
Events::Item1 => {
println!("item1");
//tray_icon.set_icon(&second_icon).unwrap();
}
Events::Item2 => {
println!("item2");
//tray_icon.set_icon(&first_icon).unwrap();
}
Events::Item3 => {
println!("item3");
/*tray_icon
.set_menu(
&MenuBuilder::new()
.item("New menu item", Events::Item1)
.item("Exit", Events::Exit),
)
.unwrap();*/
}
e => {
println!("{:?}", e);
}
}
}
}
}
}

8
src/tests/main_tests.rs
View file

@ -1,8 +1,7 @@
use workctl::sync_flag;
use crate::modules::stream_states::{
scenes::Scenes, state_update::StateUpdate, stream_state::StreamState,
};
use crate::modules::{stream_states::{ stream_state::StreamState, scenes::Scenes, state_update::StateUpdate}};
#[test]
fn it_works() {
@ -13,10 +12,11 @@ fn it_works() {
#[test]
fn can_make_ctrl_c_handler() {
let (control_c_flag_tx, _control_c_called_flag_rx) = sync_flag::new_syncflag(false);
crate::setup_control_c();
crate::setup_control_c(control_c_flag_tx);
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,13 +1,10 @@
use crate::modules::{
external_interface::Hotkeys,
message_handler::MessageHandler,
stream_states::{state_update::StateUpdate, stream_state::StreamState},
};
use crate::modules::{message_handler::{MessageHandler}, stream_states::{state_update::StateUpdate, stream_state::StreamState}, external_interface::Hotkeys};
#[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,11 +1,12 @@
#[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;
#[cfg(test)]
pub mod stream_states_tests;
pub mod state_update_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,10 +66,11 @@ 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,79 +1,36 @@
use crate::modules::stream_states::{
scenes::{Scenes, SlideChange, SubScenes},
state_update::StateUpdate,
};
use crate::modules::stream_states::{state_update::StateUpdate, scenes::{Scenes, SubScenes, SlideChange}};
#[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\": \"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\": \"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\": \"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\"}"
@ -82,252 +39,100 @@ 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\": \"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\": \"false\"}"
)
.unwrap()
),
StateUpdate::StreamSoundToggleOn(false)
);
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\": \"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_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\": \"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\": \"Next_Slide\"}").unwrap()
),
StateUpdate::ChangeSlide(SlideChange::NextHotkey)
);
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\": \"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
);
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,124 +39,62 @@ 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,
));
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);
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::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);
@ -190,6 +128,7 @@ fn test_updating() {
assert_eq!(stream_state.scene_is_augmented, true);
}
#[test]
fn can_run_in_thread() {
let (tx, rx) = mpsc::channel();
@ -210,4 +149,4 @@ fn can_run_in_thread() {
Ok(_) => return,
Err(_) => panic!(),
}
}
}