From 905c33ad4a333dfb2242a2a03c3b7e7dc1f596db Mon Sep 17 00:00:00 2001 From: Daniel Prilik Date: Wed, 4 Nov 2020 11:50:13 -0500 Subject: [PATCH] stop using DynResult for error handling I plan to refactor the code to have a single "fatal_error" channel that all threads get a handle to, and `Box` can't be sent between threads safely. --- src/config.rs | 43 +++++++++++++++++----------- src/controller/controls/media.rs | 22 ++++++++------ src/controller/controls/null.rs | 10 +++---- src/controller/controls/paddle.rs | 22 +++++++------- src/controller/controls/scroll.rs | 18 +++++++----- src/controller/controls/scroll_mt.rs | 24 +++++++++------- src/controller/controls/volume.rs | 20 +++++++------ src/controller/controls/zoom.rs | 16 ++++++----- src/controller/mod.rs | 25 ++++++++-------- src/dial_device.rs | 18 ++++++------ src/error.rs | 8 ++++-- src/main.rs | 33 ++++++++++----------- 12 files changed, 147 insertions(+), 112 deletions(-) diff --git a/src/config.rs b/src/config.rs index c415212..1bacbf6 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,57 +1,68 @@ use std::fs; use std::io::prelude::*; -use crate::DynResult; +use crate::error::{Error, Result}; -// This current implementation is incredibly barebones. -// It literally just reads/writes the last selected mode from the file. +// This current implementation is incredibly barebones and brittle. +// It literally just reads/writes the last selected mode from the file as a raw +// index into the modes array. That's it. // // No TOML, No JSON, just raw text. // -// It shouldn't be too hard to get a proper serde-based implementation up and -// running, it's moreso that it'll bump compile times for no good reason. I'll -// set that all up once I need the complexity. +// While it wouldn't be too hard to get a proper serde-based implementation up +// and running, it'll just bump compile times up for no good reason, so I'll +// only set it up once I need the added complexity. + +// TODO: stop using strings for errors lol pub struct Config { pub last_mode: usize, } -fn get_cfg_file() -> DynResult { +fn get_cfg_file() -> Result { let proj_dirs = directories::ProjectDirs::from("com", "prilik", "surface-dial-daemon") - .ok_or("could not open config directory")?; + .ok_or_else(|| Error::ConfigFile("could not open config directory".into()))?; let cfg_folder = proj_dirs.config_dir(); let cfg_file_path = proj_dirs.config_dir().join("config.txt"); - fs::create_dir_all(cfg_folder).map_err(|_| "could not create config dir")?; + fs::create_dir_all(cfg_folder) + .map_err(|e| Error::ConfigFile(format!("could not create config dir: {}", e)))?; if !cfg_file_path.exists() { - fs::write(&cfg_file_path, "0")?; + fs::write(&cfg_file_path, "0") + .map_err(|e| Error::ConfigFile(format!("could not write to config file: {}", e)))?; } let cfg_file = fs::OpenOptions::new() .write(true) .read(true) .open(cfg_file_path) - .map_err(|e| format!("could not open config file: {}", e))?; + .map_err(|e| Error::ConfigFile(format!("could not open config file: {}", e)))?; Ok(cfg_file) } impl Config { - pub fn from_disk() -> DynResult { + pub fn from_disk() -> Result { let mut cfg_file = get_cfg_file()?; let mut content = String::new(); - cfg_file.read_to_string(&mut content)?; + cfg_file + .read_to_string(&mut content) + .map_err(|e| Error::ConfigFile(format!("could not read the config file: {}", e)))?; - let last_mode = content.parse()?; + let last_mode = content + .parse() + .map_err(|e| Error::ConfigFile(format!("could not parse the config file: {}", e)))?; Ok(Config { last_mode }) } - pub fn to_disk(&self) -> DynResult<()> { + pub fn to_disk(&self) -> Result<()> { let mut cfg_file = get_cfg_file()?; - cfg_file.write_all(format!("{}", self.last_mode).as_bytes())?; + cfg_file + .write_all(format!("{}", self.last_mode).as_bytes()) + .map_err(|e| Error::ConfigFile(format!("could not write to the config file: {}", e)))?; Ok(()) } diff --git a/src/controller/controls/media.rs b/src/controller/controls/media.rs index 076e7d2..323ee3a 100644 --- a/src/controller/controls/media.rs +++ b/src/controller/controls/media.rs @@ -1,7 +1,7 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::{Error, Result}; use crate::fake_input::FakeInput; -use crate::DynResult; use evdev_rs::enums::EV_KEY; @@ -25,27 +25,33 @@ impl ControlMode for Media { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(true, Some(36))?; Ok(()) } - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_release(&mut self, _: &DialHaptics) -> DynResult<()> { - self.fake_input.key_click(&[EV_KEY::KEY_PLAYPAUSE])?; + fn on_btn_release(&mut self, _: &DialHaptics) -> Result<()> { + self.fake_input + .key_click(&[EV_KEY::KEY_PLAYPAUSE]) + .map_err(Error::Evdev)?; Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { if delta > 0 { eprintln!("next song"); - self.fake_input.key_click(&[EV_KEY::KEY_NEXTSONG])?; + self.fake_input + .key_click(&[EV_KEY::KEY_NEXTSONG]) + .map_err(Error::Evdev)?; } else { eprintln!("last song"); - self.fake_input.key_click(&[EV_KEY::KEY_PREVIOUSSONG])?; + self.fake_input + .key_click(&[EV_KEY::KEY_PREVIOUSSONG]) + .map_err(Error::Evdev)?; } Ok(()) } diff --git a/src/controller/controls/null.rs b/src/controller/controls/null.rs index 1218c12..9f345d5 100644 --- a/src/controller/controls/null.rs +++ b/src/controller/controls/null.rs @@ -1,6 +1,6 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; -use crate::DynResult; +use crate::error::Result; impl ControlMode for () { fn meta(&self) -> ControlModeMeta { @@ -10,20 +10,20 @@ impl ControlMode for () { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(false, Some(0))?; Ok(()) } - fn on_btn_press(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_release(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_release(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_dial(&mut self, _haptics: &DialHaptics, _delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _haptics: &DialHaptics, _delta: i32) -> Result<()> { Ok(()) } } diff --git a/src/controller/controls/paddle.rs b/src/controller/controls/paddle.rs index c01592e..c406bb4 100644 --- a/src/controller/controls/paddle.rs +++ b/src/controller/controls/paddle.rs @@ -5,8 +5,8 @@ use std::time::Duration; use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::Result; use crate::fake_input::FakeInput; -use crate::DynResult; use evdev_rs::enums::EV_KEY; @@ -152,29 +152,29 @@ impl ControlMode for Paddle { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(false, Some(3600))?; - self.msg.send(Msg::Enabled(true))?; + let _ = self.msg.send(Msg::Enabled(true)); Ok(()) } - fn on_end(&mut self, _haptics: &DialHaptics) -> DynResult<()> { - self.msg.send(Msg::Enabled(false))?; + fn on_end(&mut self, _haptics: &DialHaptics) -> Result<()> { + let _ = self.msg.send(Msg::Enabled(false)); Ok(()) } - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { - self.msg.send(Msg::ButtonDown)?; + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { + let _ = self.msg.send(Msg::ButtonDown); Ok(()) } - fn on_btn_release(&mut self, _: &DialHaptics) -> DynResult<()> { - self.msg.send(Msg::ButtonUp)?; + fn on_btn_release(&mut self, _: &DialHaptics) -> Result<()> { + let _ = self.msg.send(Msg::ButtonUp); Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { - self.msg.send(Msg::Delta(delta))?; + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { + let _ = self.msg.send(Msg::Delta(delta)); Ok(()) } } diff --git a/src/controller/controls/scroll.rs b/src/controller/controls/scroll.rs index 6adb2e9..50e8af0 100644 --- a/src/controller/controls/scroll.rs +++ b/src/controller/controls/scroll.rs @@ -1,7 +1,7 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::{Error, Result}; use crate::fake_input::{FakeInput, ScrollStep}; -use crate::DynResult; pub struct Scroll { fake_input: FakeInput, @@ -23,26 +23,30 @@ impl ControlMode for Scroll { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(false, Some(90))?; Ok(()) } - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_release(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_release(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { if delta > 0 { eprintln!("scroll down"); - self.fake_input.scroll_step(ScrollStep::Down)?; + self.fake_input + .scroll_step(ScrollStep::Down) + .map_err(Error::Evdev)?; } else { eprintln!("scroll up"); - self.fake_input.scroll_step(ScrollStep::Up)?; + self.fake_input + .scroll_step(ScrollStep::Up) + .map_err(Error::Evdev)?; } Ok(()) diff --git a/src/controller/controls/scroll_mt.rs b/src/controller/controls/scroll_mt.rs index ee7ed19..ce23101 100644 --- a/src/controller/controls/scroll_mt.rs +++ b/src/controller/controls/scroll_mt.rs @@ -1,7 +1,7 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::{Error, Result}; use crate::fake_input::FakeInput; -use crate::DynResult; pub struct ScrollMT { acc_delta: i32, @@ -26,35 +26,37 @@ impl ControlMode for ScrollMT { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(false, Some(3600))?; self.acc_delta = 0; - self.fake_input.scroll_mt_start()?; + self.fake_input.scroll_mt_start().map_err(Error::Evdev)?; Ok(()) } - fn on_end(&mut self, _haptics: &DialHaptics) -> DynResult<()> { - self.fake_input.scroll_mt_end()?; + fn on_end(&mut self, _haptics: &DialHaptics) -> Result<()> { + self.fake_input.scroll_mt_end().map_err(Error::Evdev)?; Ok(()) } // HACK: the button will reset the scroll event, which sometimes helps - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { - self.fake_input.scroll_mt_end()?; + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { + self.fake_input.scroll_mt_end().map_err(Error::Evdev)?; Ok(()) } - fn on_btn_release(&mut self, _haptics: &DialHaptics) -> DynResult<()> { - self.fake_input.scroll_mt_start()?; + fn on_btn_release(&mut self, _haptics: &DialHaptics) -> Result<()> { + self.fake_input.scroll_mt_start().map_err(Error::Evdev)?; Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { self.acc_delta += delta; - self.fake_input.scroll_mt_step(self.acc_delta)?; + self.fake_input + .scroll_mt_step(self.acc_delta) + .map_err(Error::Evdev)?; Ok(()) } diff --git a/src/controller/controls/volume.rs b/src/controller/controls/volume.rs index d926a4d..e337b84 100644 --- a/src/controller/controls/volume.rs +++ b/src/controller/controls/volume.rs @@ -1,7 +1,7 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::{Error, Result}; use crate::fake_input::FakeInput; -use crate::DynResult; use evdev_rs::enums::EV_KEY; @@ -25,32 +25,36 @@ impl ControlMode for Volume { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(true, Some(36 * 2))?; Ok(()) } - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { // TODO: support double-click to play/pause Ok(()) } - fn on_btn_release(&mut self, _: &DialHaptics) -> DynResult<()> { + fn on_btn_release(&mut self, _: &DialHaptics) -> Result<()> { eprintln!("play/pause"); // self.fake_input.mute()? - self.fake_input.key_click(&[EV_KEY::KEY_PLAYPAUSE])?; + self.fake_input + .key_click(&[EV_KEY::KEY_PLAYPAUSE]) + .map_err(Error::Evdev)?; Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { if delta > 0 { eprintln!("volume up"); self.fake_input - .key_click(&[EV_KEY::KEY_LEFTSHIFT, EV_KEY::KEY_VOLUMEUP])?; + .key_click(&[EV_KEY::KEY_LEFTSHIFT, EV_KEY::KEY_VOLUMEUP]) + .map_err(Error::Evdev)?; } else { eprintln!("volume down"); self.fake_input - .key_click(&[EV_KEY::KEY_LEFTSHIFT, EV_KEY::KEY_VOLUMEDOWN])?; + .key_click(&[EV_KEY::KEY_LEFTSHIFT, EV_KEY::KEY_VOLUMEDOWN]) + .map_err(Error::Evdev)?; } Ok(()) diff --git a/src/controller/controls/zoom.rs b/src/controller/controls/zoom.rs index 5729334..a622c26 100644 --- a/src/controller/controls/zoom.rs +++ b/src/controller/controls/zoom.rs @@ -1,7 +1,7 @@ use crate::controller::{ControlMode, ControlModeMeta}; use crate::dial_device::DialHaptics; +use crate::error::{Error, Result}; use crate::fake_input::FakeInput; -use crate::DynResult; use evdev_rs::enums::EV_KEY; @@ -25,28 +25,30 @@ impl ControlMode for Zoom { } } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { haptics.set_mode(true, Some(36))?; Ok(()) } - fn on_btn_press(&mut self, _: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_release(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_release(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _: &DialHaptics, delta: i32) -> Result<()> { if delta > 0 { eprintln!("zoom in"); self.fake_input - .key_click(&[EV_KEY::KEY_LEFTCTRL, EV_KEY::KEY_EQUAL])?; + .key_click(&[EV_KEY::KEY_LEFTCTRL, EV_KEY::KEY_EQUAL]) + .map_err(Error::Evdev)?; } else { eprintln!("zoom out"); self.fake_input - .key_click(&[EV_KEY::KEY_LEFTCTRL, EV_KEY::KEY_MINUS])?; + .key_click(&[EV_KEY::KEY_LEFTCTRL, EV_KEY::KEY_MINUS]) + .map_err(Error::Evdev)?; } Ok(()) diff --git a/src/controller/mod.rs b/src/controller/mod.rs index c610bee..b897ce1 100644 --- a/src/controller/mod.rs +++ b/src/controller/mod.rs @@ -1,7 +1,7 @@ use std::sync::{Arc, Mutex}; use crate::dial_device::{DialDevice, DialEventKind, DialHaptics}; -use crate::DynResult; +use crate::error::{Error, Result}; pub mod controls; @@ -13,14 +13,14 @@ pub struct ControlModeMeta { pub trait ControlMode { fn meta(&self) -> ControlModeMeta; - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()>; - fn on_end(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()>; + fn on_end(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_press(&mut self, haptics: &DialHaptics) -> DynResult<()>; - fn on_btn_release(&mut self, haptics: &DialHaptics) -> DynResult<()>; - fn on_dial(&mut self, haptics: &DialHaptics, delta: i32) -> DynResult<()>; + fn on_btn_press(&mut self, haptics: &DialHaptics) -> Result<()>; + fn on_btn_release(&mut self, haptics: &DialHaptics) -> Result<()>; + fn on_dial(&mut self, haptics: &DialHaptics, delta: i32) -> Result<()>; } enum ActiveMode { @@ -59,7 +59,7 @@ impl DialController { } } - pub fn run(&mut self) -> DynResult<()> { + pub fn run(&mut self) -> Result<()> { let initial_mode = match self.active_mode { ActiveMode::Normal(i) => i, ActiveMode::Meta => 0, @@ -137,7 +137,7 @@ impl ControlMode for MetaMode { unreachable!() // meta mode never queries itself } - fn on_start(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_start(&mut self, haptics: &DialHaptics) -> Result<()> { use notify_rust::*; self.notif = Some( Notification::new() @@ -150,7 +150,8 @@ impl ControlMode for MetaMode { self.metas[self.current_mode].name )) .icon("emblem-system") - .show()?, + .show() + .map_err(Error::Notif)?, ); haptics.buzz(1)?; @@ -161,11 +162,11 @@ impl ControlMode for MetaMode { Ok(()) } - fn on_btn_press(&mut self, _haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_press(&mut self, _haptics: &DialHaptics) -> Result<()> { Ok(()) } - fn on_btn_release(&mut self, haptics: &DialHaptics) -> DynResult<()> { + fn on_btn_release(&mut self, haptics: &DialHaptics) -> Result<()> { if self.first_release { self.first_release = false; } else { @@ -182,7 +183,7 @@ impl ControlMode for MetaMode { Ok(()) } - fn on_dial(&mut self, _haptics: &DialHaptics, delta: i32) -> DynResult<()> { + fn on_dial(&mut self, _haptics: &DialHaptics, delta: i32) -> Result<()> { if delta > 0 { self.current_mode += 1; } else { diff --git a/src/dial_device.rs b/src/dial_device.rs index 7a37884..8f5190b 100644 --- a/src/dial_device.rs +++ b/src/dial_device.rs @@ -5,7 +5,7 @@ use std::time::Duration; use evdev_rs::{Device, InputEvent, ReadStatus}; use hidapi::{HidApi, HidDevice}; -use crate::error::Error; +use crate::error::{Error, Result}; pub struct DialDevice { long_press_timeout: Duration, @@ -31,7 +31,7 @@ pub enum DialEventKind { } impl DialDevice { - pub fn new(long_press_timeout: Duration) -> Result { + pub fn new(long_press_timeout: Duration) -> Result { let mut control = None; let mut axis = None; @@ -72,13 +72,13 @@ impl DialDevice { let (events_tx, events_rx) = mpsc::channel(); // TODO: interleave control events with regular events + // (once we figure out what control events actually do...) + // inb4 "y not async/await" std::thread::spawn({ let events = events_tx; move || loop { - events - .send(axis.next_event(evdev_rs::ReadFlag::NORMAL)) - .expect("failed to send axis event"); + let _ = events.send(axis.next_event(evdev_rs::ReadFlag::NORMAL)); } }); @@ -91,7 +91,7 @@ impl DialDevice { }) } - pub fn next_event(&mut self) -> Result { + pub fn next_event(&mut self) -> Result { let evt = if self.possible_long_press { self.events.recv_timeout(self.long_press_timeout) } else { @@ -166,7 +166,7 @@ pub struct DialHaptics { } impl DialHaptics { - fn new() -> Result { + fn new() -> Result { let api = HidApi::new().map_err(Error::HidError)?; let hid_device = api.open(0x045e, 0x091b).map_err(|_| Error::MissingDial)?; @@ -190,7 +190,7 @@ impl DialHaptics { /// `steps` should be a value between 0 and 3600, which corresponds to the /// number of subdivisions the dial should use. If left unspecified, this /// defaults to 36 (an arbitrary choice that "feels good" most of the time) - pub fn set_mode(&self, haptics: bool, steps: Option) -> Result<(), Error> { + pub fn set_mode(&self, haptics: bool, steps: Option) -> Result<()> { let steps = steps.unwrap_or(36); assert!(steps <= 3600); @@ -213,7 +213,7 @@ impl DialHaptics { Ok(()) } - pub fn buzz(&self, repeat: u8) -> Result<(), Error> { + pub fn buzz(&self, repeat: u8) -> Result<()> { let mut buf = [0; 5]; buf[0] = 0x01; // Report ID buf[1] = repeat; // RepeatCount diff --git a/src/error.rs b/src/error.rs index e30ffff..be16810 100644 --- a/src/error.rs +++ b/src/error.rs @@ -3,8 +3,11 @@ use std::io; use evdev_rs::InputEvent; +pub type Result = std::result::Result; + #[derive(Debug)] pub enum Error { + ConfigFile(String), OpenDevInputDir(io::Error), OpenEventFile(std::path::PathBuf, io::Error), HidError(hidapi::HidError), @@ -12,12 +15,13 @@ pub enum Error { MultipleDials, UnexpectedEvt(InputEvent), Evdev(io::Error), - Io(io::Error), + Notif(notify_rust::error::Error), } impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { + Error::ConfigFile(e) => write!(f, "Could not open config file: {}", e), Error::OpenDevInputDir(e) => write!(f, "Could not open /dev/input directory: {}", e), Error::OpenEventFile(path, e) => write!(f, "Could not open {:?}: {}", path, e), Error::HidError(e) => write!(f, "HID API Error: {}", e), @@ -25,7 +29,7 @@ impl fmt::Display for Error { Error::MultipleDials => write!(f, "Found multiple dials"), Error::UnexpectedEvt(evt) => write!(f, "Unexpected event: {:?}", evt), Error::Evdev(e) => write!(f, "Evdev error: {}", e), - Error::Io(e) => write!(f, "Io error: {}", e), + Error::Notif(e) => write!(f, "Notification error: {}", e), } } } diff --git a/src/main.rs b/src/main.rs index 3d72468..4bcbbb5 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,13 +7,11 @@ mod dial_device; mod error; mod fake_input; -pub type DynResult = Result>; - use std::sync::mpsc; use crate::controller::DialController; use crate::dial_device::DialDevice; -use crate::error::Error; +use crate::error::Result; use notify_rust::{Hint, Notification, Timeout}; use signal_hook::{iterator::Signals, SIGINT, SIGTERM}; @@ -58,7 +56,21 @@ fn main() { std::process::exit(1); }); - if let Err(e) = true_main(kill_notif_tx.clone()) { + std::thread::spawn({ + let kill_notif_tx = kill_notif_tx.clone(); + move || { + let signals = Signals::new(&[SIGTERM, SIGINT]).unwrap(); + for sig in signals.forever() { + eprintln!("received signal {:?}", sig); + match kill_notif_tx.send(Some(("Terminated!".into(), "dialog-warning"))) { + Ok(_) => {} + Err(_) => std::process::exit(1), + } + } + } + }); + + if let Err(e) = true_main() { println!("{}", e); } @@ -66,7 +78,7 @@ fn main() { let _ = handle.join(); } -fn true_main(kill_notif_tx: mpsc::Sender>) -> DynResult<()> { +fn true_main() -> Result<()> { println!("Started"); let cfg = config::Config::from_disk()?; @@ -74,17 +86,6 @@ fn true_main(kill_notif_tx: mpsc::Sender>) -> Dyn let dial = DialDevice::new(std::time::Duration::from_millis(750))?; println!("Found the dial"); - std::thread::spawn(move || { - let signals = Signals::new(&[SIGTERM, SIGINT]).unwrap(); - for sig in signals.forever() { - eprintln!("received signal {:?}", sig); - match kill_notif_tx.send(Some(("Terminated!".into(), "dialog-warning"))) { - Ok(_) => {} - Err(_) => std::process::exit(1), - } - } - }); - let mut controller = DialController::new( dial, cfg.last_mode,