feat(config): add regex dependency and update app data persistence

refactor: modify key behavior and remove unused serialization code
chore: update README and LICENSE files

Author: ccuqme

Cargo.toml

@@ -15,6 +15,7 @@ serde_json = "1.0.134"
 lazy_static = "1.5.0"
 thiserror = "2.0.9"
 log = "0.4.22"
+regex = "1.11.1"
 
 [dependencies.libcosmic]
 git = "https://github.com/pop-os/libcosmic.git"

README.md

@@ -1,4 +1,4 @@
-![image](https://github.com/user-attachments/assets/b6aba3b6-d9ee-47ba-a204-8d3c7e01f572)
+![image](https://github.com/user-attachments/assets/4d5facec-9f27-4457-8890-9412347ee145)
 
 # AutoClicker for Keyboard and Mouse
 
@@ -21,6 +21,7 @@ This application simulates repeated key presses and mouse clicks at a specified
 
 - Global hotkeys **do not work** with pure Wayland applications on the COSMIC Desktop, but they work fine with Xwayland applications (e.g., Steam and games running through Proton).
 - The application starts with a phantom winit window. This is a minor issue that may be addressed in the future.
+- Modifier Behavior set to "Click" is currently not working. Got busy, and decided to commit the current changes. Will finish modifier behavior at a later date.
 
 ## Building from Source
 
@@ -48,6 +49,7 @@ To build the application from source, you need to have Rust and Cargo installed.
 - [lazy_static](https://crates.io/crates/lazy_static)
 - [thiserror](https://crates.io/crates/thiserror)
 - [log](https://crates.io/crates/log)
+- [regex](https://crates.io/crates/regex)
 
 ## Contributing
 

THIRD_PARTY_LICENSES.txt

@@ -13,6 +13,8 @@ thiserror: Apache-2.0 or MIT
 
 log: Apache-2.0 or MIT
 
+regex: Apache-2.0 or MIT
+
 For full license texts, please see:
 - MPL-2.0: https://www.mozilla.org/en-US/MPL/2.0/
 - Apache-2.0: https://www.apache.org/licenses/LICENSE-2.0

src/app.rs

@@ -1,12 +1,6 @@
-use cosmic::{
-    cosmic_config::{Config as CosmicConfig, CosmicConfigEntry, Error as CosmicError},
-    iced::keyboard::Key,
-};
 use serde::{Serialize, Deserialize};
 use std::str::FromStr;
 
-use crate::utils::{KeyWrapper, serialize_keys, deserialize_keys};
-
 const KEY_BEHAVIOR_MODES: [(&str, KeyBehaviorMode); 2] = [
     ("Click", KeyBehaviorMode::Click),
     ("Hold", KeyBehaviorMode::Hold),
@@ -44,34 +38,40 @@ impl Default for KeyBehaviorMode {
     }
 }
 
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct Config {
-    pub captured_keys: Vec<KeyWrapper>,
-    pub current_key_bind: Vec<KeyWrapper>,
-    pub interval_ms: u64,
-    pub modifier_mode: KeyBehaviorMode,
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum ModifierBehaviorMode {
+    Hold,
+    Click,
 }
 
-impl CosmicConfigEntry for Config {
-    const VERSION: u64 = 1;
-
-    fn write_entry(&self, _config: &CosmicConfig) -> std::result::Result<(), CosmicError> {
-        serde_json::to_string(self)
-            .map_err(|e| CosmicError::Io(std::io::Error::new(std::io::ErrorKind::Other, format!("JSON error: {}", e))))?;
-        Ok(())
+impl std::fmt::Display for ModifierBehaviorMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ModifierBehaviorMode::Hold => write!(f, "Hold"),
+            ModifierBehaviorMode::Click => write!(f, "Click"),
+        }
     }
+}
 
-    fn get_entry(_config: &CosmicConfig) -> std::result::Result<Self, (Vec<CosmicError>, Self)> {
-        // Try to read from config, fallback to default if fails
-        let default = Self::default();
-        Ok(default)
+impl FromStr for ModifierBehaviorMode {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<ModifierBehaviorMode, Self::Err> {
+        match input {
+            "Hold" => Ok(ModifierBehaviorMode::Hold),
+            "Click" => Ok(ModifierBehaviorMode::Click),
+            _ => Err(()),
+        }
     }
+}
 
-    fn update_keys<T: AsRef<str>>(&mut self, _: &CosmicConfig, _: &[T]) -> (Vec<CosmicError>, Vec<&'static str>) {
-        (vec![], vec![])
+impl Default for ModifierBehaviorMode {
+    fn default() -> Self {
+        ModifierBehaviorMode::Click
     }
 }
 
+
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, Default)]
 pub struct HotkeyModifiers {
     pub ctrl: bool,
@@ -111,20 +111,19 @@ impl Default for TempHotkeyState {
     }
 }
 
-#[derive(Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct AppData {
     #[serde(skip)]
-    pub captured_keys: Vec<Key>,
-    #[serde(serialize_with = "serialize_keys", deserialize_with = "deserialize_keys")]
-    pub selected_keys: Vec<Key>,
+    pub captured_keys: Vec<String>,
+    #[serde(default)]
+    pub selected_keys: Vec<String>,
     #[serde(default)]
     pub global_keybind: GlobalHotkey,
     pub interval_ms: u64,
-    pub modifier_mode: KeyBehaviorMode,
+    pub key_behavior: KeyBehaviorMode,
+    pub modifier_behavior: ModifierBehaviorMode,
     #[serde(skip)]
     pub capturing_global_hotkey: bool,
     #[serde(skip)]
-    pub captured_global_hotkey: Option<Key>,
-    #[serde(skip)]
     pub temp_hotkey: TempHotkeyState,
 }

src/config.rs

@@ -1,13 +1,11 @@
 pub const MIN_INTERVAL_MS: u64 = 10;
-pub const MAX_INTERVAL_MS: u64 = 1000;
+pub const MAX_INTERVAL_MS: u64 = 5000;
 pub const DEFAULT_INTERVAL_MS: u64 = 100;
-pub const HOTKEY_TOGGLE_DELAY_MS: u64 = 500;
 pub const SIMULATION_HOLD_DELAY_MS: u64 = 50;
-pub const SIMULATION_HOLD_INTERVAL_MS: u64 = 10;
 
 pub const MAX_RETRIES: u32 = 3;
 pub const RETRY_DELAY_MS: u64 = 5;
 pub const MAX_DEVICE_INIT_RETRIES: u32 = 3;
 pub const DEVICE_INIT_RETRY_DELAY_MS: u64 = 100;
 
-pub const LISTENER_SLEEP_MS: u64 = 10;
+pub const LISTENER_SLEEP_MS: u64 = 10;

src/constants.rs

@@ -14,10 +14,9 @@ use evdev_rs::{
 };
 
 use crate::{
-    config::KeyBehaviorMode,
+    config::{KeyBehaviorMode, ModifierBehaviorMode},
     constants::{
         SIMULATION_HOLD_DELAY_MS, 
-        SIMULATION_HOLD_INTERVAL_MS,
         MAX_RETRIES,
         RETRY_DELAY_MS,
         MAX_DEVICE_INIT_RETRIES,
@@ -26,25 +25,39 @@ use crate::{
     error::{SimulatorError, Result},
 };
 
-fn write_event_with_retry(device: &UInputDevice, event: &InputEvent) -> Result<()> {
+fn retry<T, F>(mut operation: F, max_retries: u32, delay_ms: u64, log_fn: impl Fn(usize)) -> Result<T>
+where
+    F: FnMut() -> Result<T>,
+{
     let mut last_error = None;
-    for attempt in 0..MAX_RETRIES {
-        match device.write_event(event) {
-            Ok(_) => return Ok(()),
+    for attempt in 0..max_retries {
+        match operation() {
+            Ok(result) => return Ok(result),
             Err(e) => {
                 last_error = Some(e);
-                if attempt < MAX_RETRIES - 1 {
-                    log::debug!("Write event attempt {} failed, retrying...", attempt + 1);
-                    thread::sleep(Duration::from_millis(RETRY_DELAY_MS));
+                if attempt < max_retries - 1 {
+                    log_fn((attempt + 1) as usize);
+                    thread::sleep(Duration::from_millis(delay_ms));
                 }
             }
         }
     }
-    Err(SimulatorError::KeySimulation(format!(
-        "Failed after {} retries: {:?}", 
-        MAX_RETRIES, 
-        last_error.unwrap()
-    )).into())
+    Err(last_error.unwrap())
+}
+
+fn write_event_with_retry(device: &UInputDevice, event: &InputEvent) -> Result<()> {
+    retry(
+        || {
+            device.write_event(event)
+                .map_err(|e| SimulatorError::KeySimulation(format!("Failed event: {:?}", e)).into())
+        },
+        MAX_RETRIES,
+        RETRY_DELAY_MS,
+        |attempt| {
+            log::debug!("Write event attempt {} failed, retrying...", attempt);
+        },
+    )
+    .map_err(|e| e)
 }
 
 fn write_key_events(device: &UInputDevice, keys: &[EventCode], value: i32, timeval: &TimeVal) -> Result<()> {
@@ -81,37 +94,68 @@ fn setup_device(selected_keys: &Arc<Mutex<Vec<EventCode>>>) -> Result<UInputDevi
 }
 
 fn setup_device_with_retry(selected_keys: &Arc<Mutex<Vec<EventCode>>>) -> Result<UInputDevice> {
-    let mut last_error = None;
-    for attempt in 0..MAX_DEVICE_INIT_RETRIES {
-        match setup_device(selected_keys) {
-            Ok(device) => return Ok(device),
-            Err(e) => {
-                last_error = Some(e);
-                if attempt < MAX_DEVICE_INIT_RETRIES - 1 {
-                    log::warn!("Device initialization attempt {} failed, retrying...", attempt + 1);
-                    thread::sleep(Duration::from_millis(DEVICE_INIT_RETRY_DELAY_MS));
+    retry(
+        || setup_device(selected_keys),
+        MAX_DEVICE_INIT_RETRIES,
+        DEVICE_INIT_RETRY_DELAY_MS,
+        |attempt| {
+            log::warn!("Device initialization attempt {} failed, retrying...", attempt);
+        },
+    )
+    .map_err(|e| SimulatorError::DeviceInitialization(format!("Failed after {} retries: {:?}", MAX_DEVICE_INIT_RETRIES, e)).into())
+}
+
+// New function to initialize simulation keys
+pub fn initialize_simulation_keys(
+    app_data: &crate::config::AppData,
+    selected_keys: &mut Vec<evdev_rs::enums::EventCode>,
+    key_behavior: &mut crate::config::KeyBehaviorMode,
+) {
+    selected_keys.clear();
+    *key_behavior = app_data.key_behavior;
+
+    log::debug!("Initializing simulation with keys: {:?}", app_data.selected_keys);
+
+    for raw in &app_data.selected_keys {
+        if let Some(device_key) = crate::utils::key_utils::raw_key_to_device_keycode(raw) {
+            if let Some(ev_key) = crate::utils::key_utils::keycode_to_evkey(device_key) {
+                // Handle modifier keys based on modifier behavior setting
+                if crate::utils::key_utils::is_modifier_key(raw) && 
+                   app_data.modifier_behavior == crate::config::ModifierBehaviorMode::Click {
+                    selected_keys.push(evdev_rs::enums::EventCode::EV_KEY(ev_key));
+                } else {
+                    selected_keys.push(evdev_rs::enums::EventCode::EV_KEY(ev_key));
                 }
+                log::debug!("Added key: {:?}", ev_key);
             }
+        } else {
+            log::warn!("Failed to map key: {}", raw);
         }
     }
-    Err(SimulatorError::DeviceInitialization(format!(
-        "Failed after {} retries: {:?}", 
-        MAX_DEVICE_INIT_RETRIES, 
-        last_error.unwrap()
-    )).into())
+
+    if selected_keys.is_empty() {
+        log::warn!("No valid keys initialized for simulation");
+    } else {
+        log::info!("Simulation initialized with {} keys", selected_keys.len());
+    }
 }
 
 // Main simulation loop that handles both click and hold modes
 pub fn simulate_keys(
     running: Arc<Mutex<bool>>,
     interval_ms: Arc<Mutex<u64>>,
     selected_keys: Arc<Mutex<Vec<EventCode>>>,
-    modifier_mode: Arc<Mutex<KeyBehaviorMode>>,
+    key_behavior: Arc<Mutex<KeyBehaviorMode>>,
+    modifier_behavior: ModifierBehaviorMode,
 ) -> Result<()> {
     let uinput_device = setup_device_with_retry(&selected_keys)?;
     let timeval = TimeVal::new(0, 0);
-    let keys = selected_keys.lock().unwrap().clone();
-    let mode = *modifier_mode.lock().unwrap();
+    // Combine acquisitions for keys and mode.
+    let (keys, mode) = {
+        let keys = selected_keys.lock().unwrap().clone();
+        let mode = *key_behavior.lock().unwrap();
+        (keys, mode)
+    };
 
     log::info!("Device initialized with keys: {:?}", keys);
     log::info!("Key behavior mode set to: {:?}", mode);
@@ -127,24 +171,42 @@ pub fn simulate_keys(
             write_key_events(&uinput_device, &keys, 1, &timeval)?;
 
             while *running.lock().unwrap() {
-                write_key_events(&uinput_device, &[], 0, &timeval)?; // Just sync
-                thread::sleep(Duration::from_millis(SIMULATION_HOLD_INTERVAL_MS));
+                write_key_events(&uinput_device, &[], 0, &timeval)?;
             }
 
             // Release keys
             write_key_events(&uinput_device, &keys, 0, &timeval)?;
         }
         KeyBehaviorMode::Click => {
-            while *running.lock().unwrap() {
-                let interval = *interval_ms.lock().unwrap();
+            if modifier_behavior == ModifierBehaviorMode::Click {
+                let (mod_keys, non_mod_keys): (Vec<EventCode>, Vec<EventCode>) =
+                    keys.iter().cloned().partition(|k| crate::utils::key_utils::is_modifier_evcode(k));
+
+                while *running.lock().unwrap() {
+                    let interval = *interval_ms.lock().unwrap();
+                    for nm in &non_mod_keys {
+                        if !mod_keys.is_empty() {
+                            write_key_events(&uinput_device, &mod_keys, 1, &timeval)?;
+                        }
+                        write_key_events(&uinput_device, &[*nm], 1, &timeval)?;
+                        write_key_events(&uinput_device, &[*nm], 0, &timeval)?;
+                        if !mod_keys.is_empty() {
+                            write_key_events(&uinput_device, &mod_keys, 0, &timeval)?;
+                        }
+                        thread::sleep(Duration::from_millis(interval));
+                    }
+                }
+            } else {
+                while *running.lock().unwrap() {
+                    let interval = *interval_ms.lock().unwrap();
 
-                // Press keys
-                write_key_events(&uinput_device, &keys, 1, &timeval)?;
-                thread::sleep(Duration::from_millis(SIMULATION_HOLD_DELAY_MS));
+                    // Press keys
+                    write_key_events(&uinput_device, &keys, 1, &timeval)?;
 
-                // Release keys
-                write_key_events(&uinput_device, &keys, 0, &timeval)?;
-                thread::sleep(Duration::from_millis(interval));
+                    // Release keys
+                    write_key_events(&uinput_device, &keys, 0, &timeval)?;
+                    thread::sleep(Duration::from_millis(interval));
+                }
             }
         }
     }