From fa35c382d074aa43ccca570337f47b5baa29a712 Mon Sep 17 00:00:00 2001 From: Misieq01 Date: Thu, 8 Aug 2024 18:43:23 +0200 Subject: [PATCH] working_rust_auto_mining --- package-lock.json | 10 - package.json | 1 - src-tauri/src/auto_miner.rs | 109 --------- src-tauri/src/main.rs | 221 ++++++++++-------- src-tauri/src/user_listener.rs | 121 ++++++++++ src/App.tsx | 7 +- .../SideBar/Miner/components/AutoMiner.tsx | 60 +---- src/hooks/useMining.ts | 12 +- src/hooks/useUserMousePosition.ts | 33 --- src/store/useUIStore.ts | 13 +- src/types/invoke.ts | 4 +- 11 files changed, 261 insertions(+), 330 deletions(-) delete mode 100644 src-tauri/src/auto_miner.rs create mode 100644 src-tauri/src/user_listener.rs delete mode 100644 src/hooks/useUserMousePosition.ts diff --git a/package-lock.json b/package-lock.json index ebf7dba4..23b31078 100644 --- a/package-lock.json +++ b/package-lock.json @@ -15,7 +15,6 @@ "react": "^18.2.0", "react-dom": "^18.2.0", "react-icons": "^5.2.1", - "react-idle-timer": "^5.7.2", "zustand": "^4.5.4" }, "devDependencies": { @@ -4592,15 +4591,6 @@ "react": "*" } }, - "node_modules/react-idle-timer": { - "version": "5.7.2", - "resolved": "https://registry.npmjs.org/react-idle-timer/-/react-idle-timer-5.7.2.tgz", - "integrity": "sha512-+BaPfc7XEUU5JFkwZCx6fO1bLVK+RBlFH+iY4X34urvIzZiZINP6v2orePx3E6pAztJGE7t4DzvL7if2SL/0GQ==", - "peerDependencies": { - "react": ">=16", - "react-dom": ">=16" - } - }, "node_modules/react-is": { "version": "18.3.1", "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", diff --git a/package.json b/package.json index 0eeb96fd..a908be9c 100644 --- a/package.json +++ b/package.json @@ -18,7 +18,6 @@ "react": "^18.2.0", "react-dom": "^18.2.0", "react-icons": "^5.2.1", - "react-idle-timer": "^5.7.2", "zustand": "^4.5.4" }, "devDependencies": { diff --git a/src-tauri/src/auto_miner.rs b/src-tauri/src/auto_miner.rs deleted file mode 100644 index 83f61eb0..00000000 --- a/src-tauri/src/auto_miner.rs +++ /dev/null @@ -1,109 +0,0 @@ -use device_query::{ DeviceQuery, DeviceState }; -use log::info; -use tauri::{ window, Manager }; -use tokio::{ time::{ sleep, Duration } }; -use tokio_util::sync::CancellationToken; - -#[derive(Debug, Clone)] -pub struct AutoMiner { - pub is_listening: bool, - pub is_mining: bool, - pub idle_timeout: u64, - pub cancelation_token: Option, -} - -#[derive(Clone, serde::Serialize)] -pub struct Payload { - event_type: String, -} - -impl AutoMiner { - pub fn new() -> Self { - Self { - is_listening: false, - is_mining: false, - idle_timeout: 5000, - cancelation_token: None, - } - } - - pub fn read_user_mouse_coords() -> (i32, i32) { - let device_state = DeviceState::new(); - let mouse = device_state.get_mouse(); - - return mouse.coords; - } - - pub fn start_listening_to_mouse_poisition_change(&mut self, _window: tauri::Window) { - let idle_timeout = self.idle_timeout; - - let cancellation_token = CancellationToken::new(); - self.cancelation_token = Some(cancellation_token.clone()); - self.is_listening = true; - - let mut auto_miner = self.to_owned(); - let window = _window.clone(); - - let mut timeout_counter: u64 = 0; - let mut last_mouse_coords = AutoMiner::read_user_mouse_coords(); - - tokio::spawn(async move { - tokio::select! { - _ = async { - loop { - let current_mouse_coords = AutoMiner::read_user_mouse_coords(); - - if current_mouse_coords != last_mouse_coords { - last_mouse_coords = current_mouse_coords; - timeout_counter = 0; - println!("Mouse moved to: {:?}", current_mouse_coords); - } else { - timeout_counter += 1000; - println!("Mouse idle for: {:?}", timeout_counter); - } - - - if timeout_counter >= idle_timeout && !auto_miner.is_mining { - AutoMiner::start_auto_mining(&window); - auto_miner.is_mining = true; - } - - if timeout_counter < idle_timeout && auto_miner.is_mining { - AutoMiner::stop_auto_mining(&window); - auto_miner.is_mining = false; - } - - sleep(Duration::from_millis(idle_timeout)).await; - } - } => {}, - _ = cancellation_token.cancelled() => { - info!("AutoMiner::start_listening_to_mouse_poisition_change() has been cancelled"); - AutoMiner::stop_auto_mining(&window); - auto_miner.is_mining = false; - } - } - }); - } - - pub fn stop_listening_to_mouse_poisition_change(&mut self) { - match &self.cancelation_token { - Some(token) => { - token.cancel(); - self.is_listening = false; - } - None => { - info!("AutoMiner::stop_listening_to_mouse_poisition_change() has been cancelled"); - } - } - } - - pub fn start_auto_mining(window: &tauri::Window) { - window.emit("message", Payload { event_type: "user_idle".to_string() }).unwrap(); - println!("Mining started"); - } - - pub fn stop_auto_mining(window: &tauri::Window) { - window.emit("message", Payload { event_type: "user_active".to_string() }).unwrap(); - println!("Mining stopped"); - } -} diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs index cc747336..a2fd6e88 100644 --- a/src-tauri/src/main.rs +++ b/src-tauri/src/main.rs @@ -1,10 +1,10 @@ // Prevents additional console window on Windows in release, DO NOT REMOVE!! #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] -mod auto_miner; mod cpu_miner; mod mm_proxy_manager; mod process_watcher; +mod user_listener; mod xmrig; mod xmrig_adapter; @@ -20,29 +20,28 @@ mod wallet_manager; mod wallet_adapter; -use crate::auto_miner::AutoMiner; use crate::cpu_miner::CpuMiner; use crate::internal_wallet::InternalWallet; use crate::mm_proxy_manager::MmProxyManager; use crate::node_manager::NodeManager; +use crate::user_listener::UserListener; use crate::wallet_adapter::WalletBalance; use crate::wallet_manager::WalletManager; -use futures_util::lock::Mutex; use futures_util::TryFutureExt; -use log::{ debug, error, info, warn }; -use serde::{ Deserialize, Serialize }; +use log::{debug, error, info, warn}; +use serde::{Deserialize, Serialize}; use std::sync::Arc; use std::thread::sleep; -use std::{ panic, process }; +use std::{panic, process}; use tari_common_types::tari_address::TariAddress; use tari_core::transactions::tari_amount::MicroMinotari; use tari_shutdown::Shutdown; -use tauri::{ RunEvent, UpdaterEvent }; +use tauri::{RunEvent, UpdaterEvent}; use tokio::sync::RwLock; use tokio::try_join; use crate::xmrig_adapter::XmrigAdapter; -use device_query::{ DeviceQuery, DeviceState }; +use device_query::{DeviceQuery, DeviceState}; use dirs_next::cache_dir; #[derive(Debug, Serialize, Deserialize, Clone)] @@ -56,34 +55,38 @@ struct SetupStatusEvent { async fn setup_application<'r>( window: tauri::Window, state: tauri::State<'r, UniverseAppState>, - app: tauri::AppHandle + app: tauri::AppHandle, ) -> Result<(), String> { - let _ = window.emit("message", SetupStatusEvent { - event_type: "setup_status".to_string(), - title: "Starting up".to_string(), - progress: 0.0, - }); + let _ = window.emit( + "message", + SetupStatusEvent { + event_type: "setup_status".to_string(), + title: "Starting up".to_string(), + progress: 0.0, + }, + ); let data_dir = app.path_resolver().app_local_data_dir().unwrap(); - let task1 = state.node_manager + let task1 = state + .node_manager .ensure_started(state.shutdown.to_signal(), data_dir.clone(), window.clone()) .map_err(|e| { error!(target: LOG_TARGET, "Could not start node manager: {:?}", e); e.to_string() }); - let task2 = state.wallet_manager + let task2 = state + .wallet_manager .ensure_started(state.shutdown.to_signal(), data_dir, window.clone()) .map_err(|e| { error!(target: LOG_TARGET, "Could not start wallet manager: {:?}", e); e.to_string() }); - let task3 = XmrigAdapter::ensure_latest(cache_dir().unwrap(), false, window.clone()).map_err( - |e| { + let task3 = + XmrigAdapter::ensure_latest(cache_dir().unwrap(), false, window.clone()).map_err(|e| { error!(target: LOG_TARGET, "Could not download xmrig: {:?}", e); e.to_string() - } - ); + }); match try_join!(task1, task2, task3) { Ok(_) => { @@ -94,11 +97,14 @@ async fn setup_application<'r>( // return Err(e.to_string()); } } - _ = window.emit("message", SetupStatusEvent { - event_type: "setup_status".to_string(), - title: "Applications started".to_string(), - progress: 1.0, - }); + _ = window.emit( + "message", + SetupStatusEvent { + event_type: "setup_status".to_string(), + title: "Applications started".to_string(), + progress: 1.0, + }, + ); Ok(()) } @@ -111,24 +117,21 @@ async fn check_user_mouse_position<'r>(_window: tauri::Window) -> Result<(i32, i } #[tauri::command] -async fn start_auto_mining<'r>( +async fn start_listening_to_user_activity<'r>( window: tauri::Window, state: tauri::State<'r, UniverseAppState>, - app: tauri::AppHandle ) -> Result<(), String> { - let mut auto_miner = state.auto_miner.write().await; - auto_miner.start_listening_to_mouse_poisition_change(window); + let mut user_listener = state.user_listener.write().await; + user_listener.start_listening_to_mouse_poisition_change(window); Ok(()) } #[tauri::command] -async fn stop_auto_mining<'r>( - window: tauri::Window, +async fn stop_listening_to_user_activity<'r>( state: tauri::State<'r, UniverseAppState>, - app: tauri::AppHandle ) -> Result<(), String> { - let mut auto_miner = state.auto_miner.write().await; - auto_miner.stop_listening_to_mouse_poisition_change(); + let mut user_listener = state.user_listener.write().await; + user_listener.stop_listening_to_mouse_poisition_change(); Ok(()) } @@ -136,26 +139,31 @@ async fn stop_auto_mining<'r>( async fn start_mining<'r>( window: tauri::Window, state: tauri::State<'r, UniverseAppState>, - app: tauri::AppHandle + app: tauri::AppHandle, ) -> Result<(), String> { let config = state.cpu_miner_config.read().await; - state.node_manager + state + .node_manager .ensure_started( state.shutdown.to_signal(), app.path_resolver().app_local_data_dir().unwrap(), - window.clone() - ).await + window.clone(), + ) + .await .map_err(|e| e.to_string())?; let mm_proxy_manager = state.mm_proxy_manager.read().await; - state.cpu_miner - .write().await + state + .cpu_miner + .write() + .await .start( state.shutdown.to_signal(), &config, &mm_proxy_manager, app.path_resolver().app_local_data_dir().unwrap(), - window.clone() - ).await + window.clone(), + ) + .await .map_err(|e| { dbg!(e.to_string()); e.to_string() @@ -165,15 +173,21 @@ async fn start_mining<'r>( #[tauri::command] async fn stop_mining<'r>(state: tauri::State<'r, UniverseAppState>) -> Result<(), String> { - state.cpu_miner - .write().await - .stop().await + state + .cpu_miner + .write() + .await + .stop() + .await .map_err(|e| e.to_string())?; // stop the mmproxy. TODO: change it so that the cpu miner stops this dependency. - state.mm_proxy_manager - .write().await - .stop().await + state + .mm_proxy_manager + .write() + .await + .stop() + .await .map_err(|e| e.to_string())?; // state.node_manager.stop().await.map_err(|e| e.to_string())?; @@ -185,12 +199,18 @@ async fn stop_mining<'r>(state: tauri::State<'r, UniverseAppState>) -> Result<() async fn status(state: tauri::State<'_, UniverseAppState>) -> Result { let cpu_miner = state.cpu_miner.read().await; let (_sha_hash_rate, randomx_hash_rate, block_reward, block_height, block_time, is_synced) = - state.node_manager.get_network_hash_rate_and_block_reward().await.unwrap_or_else(|e| { - // warn!(target: LOG_TARGET, "Error getting network hash rate and block reward: {:?}", e); - (0, 0, MicroMinotari(0), 0, 0, false) - }); - let cpu = match - cpu_miner.status(randomx_hash_rate, block_reward).await.map_err(|e| e.to_string()) + state + .node_manager + .get_network_hash_rate_and_block_reward() + .await + .unwrap_or_else(|e| { + // warn!(target: LOG_TARGET, "Error getting network hash rate and block reward: {:?}", e); + (0, 0, MicroMinotari(0), 0, 0, false) + }); + let cpu = match cpu_miner + .status(randomx_hash_rate, block_reward) + .await + .map_err(|e| e.to_string()) { Ok(cpu) => cpu, Err(e) => { @@ -267,7 +287,7 @@ struct UniverseAppState { shutdown: Shutdown, cpu_miner: RwLock, cpu_miner_config: Arc>, - auto_miner: Arc>, + user_listener: Arc>, mm_proxy_manager: Arc>, node_manager: NodeManager, wallet_manager: WalletManager, @@ -277,12 +297,10 @@ pub const LOG_TARGET: &str = "tari::universe::main"; fn main() { let default_hook = panic::take_hook(); - panic::set_hook( - Box::new(move |info| { - default_hook(info); - process::exit(1); - }) - ); + panic::set_hook(Box::new(move |info| { + default_hook(info); + process::exit(1); + })); let mut shutdown = Shutdown::new(); let mm_proxy_manager = Arc::new(RwLock::new(MmProxyManager::new())); @@ -290,43 +308,44 @@ fn main() { let wallet_manager = WalletManager::new(node_manager.clone()); let wallet_manager2 = wallet_manager.clone(); - let cpu_config = Arc::new( - RwLock::new(CpuMinerConfig { - node_connection: CpuMinerConnection::BuiltInProxy, - tari_address: TariAddress::default(), - }) - ); + let cpu_config = Arc::new(RwLock::new(CpuMinerConfig { + node_connection: CpuMinerConnection::BuiltInProxy, + tari_address: TariAddress::default(), + })); let app_state = UniverseAppState { shutdown: shutdown.clone(), cpu_miner: CpuMiner::new().into(), cpu_miner_config: cpu_config.clone(), - auto_miner: Arc::new(RwLock::new(AutoMiner::new())), + user_listener: Arc::new(RwLock::new(UserListener::new())), mm_proxy_manager: mm_proxy_manager.clone(), node_manager, wallet_manager, }; - let app = tauri::Builder - ::default() + let app = tauri::Builder::default() .manage(app_state) .setup(|app| { - tari_common - ::initialize_logging( - &app.path_resolver().app_config_dir().unwrap().join("log4rs_config.yml"), - &app.path_resolver().app_log_dir().unwrap(), - include_str!("../log4rs_sample.yml") - ) - .expect("Could not set up logging"); + tari_common::initialize_logging( + &app.path_resolver() + .app_config_dir() + .unwrap() + .join("log4rs_config.yml"), + &app.path_resolver().app_log_dir().unwrap(), + include_str!("../log4rs_sample.yml"), + ) + .expect("Could not set up logging"); let config_path = app.path_resolver().app_config_dir().unwrap(); let thread = tauri::async_runtime::spawn(async move { match InternalWallet::load_or_create(config_path).await { Ok(wallet) => { cpu_config.write().await.tari_address = wallet.get_tari_address(); - wallet_manager2.set_view_private_key_and_spend_key( - wallet.get_view_key(), - wallet.get_spend_key() - ).await; + wallet_manager2 + .set_view_private_key_and_spend_key( + wallet.get_view_key(), + wallet.get_spend_key(), + ) + .await; } Err(e) => { error!(target: LOG_TARGET, "Error loading internal wallet: {:?}", e); @@ -346,17 +365,15 @@ fn main() { } } }) - .invoke_handler( - tauri::generate_handler![ - setup_application, - status, - start_mining, - stop_mining, - check_user_mouse_position, - start_auto_mining, - stop_auto_mining - ] - ) + .invoke_handler(tauri::generate_handler![ + setup_application, + status, + start_mining, + stop_mining, + check_user_mouse_position, + start_listening_to_user_activity, + stop_listening_to_user_activity + ]) .build(tauri::generate_context!()) .expect("error while running tauri application"); @@ -366,19 +383,21 @@ fn main() { app.package_info().version ); - println!("Logs stored at {:?}", app.path_resolver().app_log_dir().unwrap()); + println!( + "Logs stored at {:?}", + app.path_resolver().app_log_dir().unwrap() + ); app.run(move |_app_handle, event| { match event { - tauri::RunEvent::Updater(updater_event) => - match updater_event { - UpdaterEvent::Error(e) => { - error!(target: LOG_TARGET, "Updater error: {:?}", e); - } - _ => { - info!(target: LOG_TARGET, "Updater event: {:?}", updater_event); - } + tauri::RunEvent::Updater(updater_event) => match updater_event { + UpdaterEvent::Error(e) => { + error!(target: LOG_TARGET, "Updater error: {:?}", e); + } + _ => { + info!(target: LOG_TARGET, "Updater event: {:?}", updater_event); } + }, tauri::RunEvent::ExitRequested { api: _, .. } => { // api.prevent_exit(); info!(target: LOG_TARGET, "App shutdown caught"); diff --git a/src-tauri/src/user_listener.rs b/src-tauri/src/user_listener.rs new file mode 100644 index 00000000..6d0f4223 --- /dev/null +++ b/src-tauri/src/user_listener.rs @@ -0,0 +1,121 @@ +use device_query::{DeviceQuery, DeviceState}; +use log::info; +use tokio::time::{sleep, Duration}; +use tokio_util::sync::CancellationToken; + +#[derive(Debug, Clone)] +pub struct UserListener { + pub is_listening: bool, + pub is_mining_initialized: bool, + pub idle_timeout: u64, + pub cancelation_token: Option, +} + +#[derive(Clone, serde::Serialize)] +pub struct UserActivityEventPayload { + event_type: String, +} + +impl UserListener { + pub fn new() -> Self { + Self { + is_listening: false, + is_mining_initialized: false, + idle_timeout: 5000, + cancelation_token: None, + } + } + + pub fn read_user_mouse_coords() -> (i32, i32) { + let device_state = DeviceState::new(); + let mouse = device_state.get_mouse(); + + return mouse.coords; + } + + pub fn start_listening_to_mouse_poisition_change(&mut self, window: tauri::Window) { + let idle_timeout = self.idle_timeout; + + let cancellation_token = CancellationToken::new(); + self.cancelation_token = Some(cancellation_token.clone()); + self.is_listening = true; + + let mut user_listener = self.to_owned(); + let window = window.clone(); + + let mut timeout_counter: u64 = 0; + let mut last_mouse_coords = UserListener::read_user_mouse_coords(); + + tokio::spawn(async move { + tokio::select! { + _ = async { + info!("UserListener::listening for user inactivity has been started"); + loop { + let current_mouse_coords = UserListener::read_user_mouse_coords(); + + if current_mouse_coords != last_mouse_coords { + last_mouse_coords = current_mouse_coords; + timeout_counter = 0; + } else { + timeout_counter += 1000; + } + + + if timeout_counter >= idle_timeout && !user_listener.is_mining_initialized { + UserListener::on_user_idle(&window); + user_listener.is_mining_initialized = true; + } + + if timeout_counter < idle_timeout && user_listener.is_mining_initialized { + UserListener::on_user_active(&window); + user_listener.is_mining_initialized = false; + } + + sleep(Duration::from_millis(idle_timeout)).await; + } + } => {}, + _ = cancellation_token.cancelled() => { + info!("UserListener::listening for user inactivity has been cancelled"); + UserListener::on_user_active(&window); + user_listener.is_mining_initialized = false; + } + } + }); + } + + pub fn stop_listening_to_mouse_poisition_change(&mut self) { + match &self.cancelation_token { + Some(token) => { + token.cancel(); + self.is_listening = false; + } + None => { + info!( + "UserListener::triggered cancelation of listening for user inactivity but no cancelation token was found" + ); + } + } + } + + pub fn on_user_idle(window: &tauri::Window) { + window + .emit( + "message", + UserActivityEventPayload { + event_type: "user_idle".to_string(), + }, + ) + .unwrap(); + } + + pub fn on_user_active(window: &tauri::Window) { + window + .emit( + "message", + UserActivityEventPayload { + event_type: "user_active".to_string(), + }, + ) + .unwrap(); + } +} diff --git a/src/App.tsx b/src/App.tsx index 014fad23..cb08e4a5 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -15,7 +15,6 @@ import { useGetStatus } from './hooks/useGetStatus.ts'; import { listen } from '@tauri-apps/api/event'; import { TauriEvent } from './types.ts'; import useAppStateStore from './store/appStateStore.ts'; -import { useUserMousePosition } from './hooks/useUserMousePosition.ts'; import { useMining } from './hooks/useMining.ts'; function App() { @@ -24,6 +23,7 @@ function App() { const startupInitiated = useRef(false); const setSetupDetails = useAppStateStore((s) => s.setSetupDetails); const settingUpFinished = useAppStateStore((s) => s.settingUpFinished); + const { startMining, stopMining } = useMining(); useEffect(() => { const unlistenPromise = listen( @@ -38,12 +38,12 @@ function App() { } break; case 'user_idle': - invoke('start_mining').then(() => { + startMining().then(() => { console.log('Mining started'); }); break; case 'user_active': - invoke('stop_mining').then(() => { + stopMining().then(() => { console.log('Mining stopped'); }); break; @@ -69,7 +69,6 @@ function App() { }, []); useGetStatus(); - useUserMousePosition(); return ( diff --git a/src/containers/SideBar/Miner/components/AutoMiner.tsx b/src/containers/SideBar/Miner/components/AutoMiner.tsx index aa28987c..1dc5bea6 100644 --- a/src/containers/SideBar/Miner/components/AutoMiner.tsx +++ b/src/containers/SideBar/Miner/components/AutoMiner.tsx @@ -2,74 +2,18 @@ import { FormGroup, Switch, Stack, Typography } from '@mui/material'; import { AutoMinerContainer } from '../styles'; import { invoke } from '@tauri-apps/api/tauri'; -// const checkIfMousePositionsEqual = (a: [number, number], b: [number, number]) => { -// return a[0] === b[0] && a[1] === b[1]; -// } - function AutoMiner() { - // const isAutoMining = useUIStore((s) => s.isAutoMining); - // const setIsAutoMining = useUIStore((s) => s.setIsAutoMining); - // const userMousePosition = useUIStore((s) => s.userMousePosition); - // const setBackground = useUIStore((s) => s.setBackground); - // const { startMining, stopMining } = useMining(); - - // const lastMousePosition = React.useRef<[number, number] | null>(null); - // const isTimerRunning = React.useRef(false); - - // const enableAutoMining = () => { - // startMining(); - // setBackground('mining'); - // }; - // const disableAutoMining = () => { - // stopMining(); - // setBackground('idle'); - // }; - - // const { start,reset } = useIdleTimer({ timeout: 1000 * 30,startManually: true, onIdle: enableAutoMining, events: []}); - - // React.useEffect(() => { - // if (lastMousePosition.current === null) { - // lastMousePosition.current = userMousePosition; - // } - // }, [userMousePosition]); - - // React.useEffect(() => { - // if (lastMousePosition.current === null) return; - // const isMousePositionChanged = !checkIfMousePositionsEqual(userMousePosition, lastMousePosition.current); - // lastMousePosition.current = userMousePosition; - - // if (isAutoMining && !isMousePositionChanged && !isTimerRunning.current) { - // start(); - // isTimerRunning.current = true; - // } - - // if (isMousePositionChanged) { - // reset(); - // disableAutoMining(); - // isTimerRunning.current = false; - // } - // }, [isAutoMining,userMousePosition]); - - // const handleAutoMining = () => { - // if (isAutoMining) { - // setIsAutoMining(false) - // disableAutoMining(); - // } else { - // setIsAutoMining(true); - // } - // }; - const handleAutoMining = (event: React.ChangeEvent) => { const isChecked = event.target.checked; console.log('Auto mining checked', isChecked); if (isChecked) { - invoke('start_auto_mining').then(() => { + invoke('start_listening_to_user_activity').then(() => { console.log('Auto mining stopped'); }); } if (!isChecked) { - invoke('stop_auto_mining').then(() => { + invoke('stop_listening_to_user_activity').then(() => { console.log('Auto mining started'); }); } diff --git a/src/hooks/useMining.ts b/src/hooks/useMining.ts index d8236df8..1bb52b2c 100644 --- a/src/hooks/useMining.ts +++ b/src/hooks/useMining.ts @@ -1,8 +1,12 @@ -import { useCallback, useState } from 'react'; +import { useCallback } from 'react'; import { invoke } from '@tauri-apps/api/tauri'; +import { useUIStore } from '../store/useUIStore'; export function useMining() { - const [isLoading, setIsLoading] = useState(false); + const isLoading = useUIStore((s) => s.isMiningLoading); + const setIsLoading = useUIStore((s) => s.setIsMiningLoading); + const setBackground = useUIStore((s) => s.setBackground); + const startMining = useCallback(async () => { setIsLoading(true); try { @@ -12,6 +16,7 @@ export function useMining() { console.error('Could not start mining', e); } finally { setIsLoading(false); + setBackground('mining'); } }, []); const stopMining = useCallback(async () => { @@ -23,12 +28,13 @@ export function useMining() { console.error('Could not stop mining', e); } finally { setIsLoading(false); + setBackground('idle'); } }, []); return { startMining, stopMining, - isLoading + isLoading, }; } diff --git a/src/hooks/useUserMousePosition.ts b/src/hooks/useUserMousePosition.ts deleted file mode 100644 index 5fd1da75..00000000 --- a/src/hooks/useUserMousePosition.ts +++ /dev/null @@ -1,33 +0,0 @@ -import { invoke } from '@tauri-apps/api/tauri'; -import { useEffect } from 'react'; -import { useUIStore } from '../store/useUIStore'; -import useAppStateStore from '../store/appStateStore'; - -export const useUserMousePosition = () => { - const setUserMousePosition = useUIStore((s) => s.setUserMousePosition); - const setError = useAppStateStore((s) => s.setError); - - useEffect(() => { - const intervalId = setInterval(() => { - invoke('check_user_mouse_position') - .then((response) => { - if (response && response.length === 2) { - setUserMousePosition(response); - } else { - console.error( - 'check_user_mouse_position returned invalid response', - response - ); - } - }) - .catch((e) => { - console.error('Could not listen to user inactivity', e); - setError(e.toString()); - }); - }, 1000); - - return () => { - clearInterval(intervalId); - }; - }, []); -}; diff --git a/src/store/useUIStore.ts b/src/store/useUIStore.ts index 106bf0b4..d291b2de 100644 --- a/src/store/useUIStore.ts +++ b/src/store/useUIStore.ts @@ -6,17 +6,14 @@ interface State { view: viewType; visualMode: boolean; sidebarOpen: boolean; - isAutoMining: boolean; - userMousePosition: [number, number]; - + isMiningLoading: boolean; } interface Actions { setBackground: (background: State['background']) => void; setView: (view: State['view']) => void; setVisualMode: (visualMode: State['visualMode']) => void; setSidebarOpen: (sidebarOpen: State['sidebarOpen']) => void; - setIsAutoMining: (isAutoMining: State['isAutoMining']) => void; - setUserMousePosition: (userMousePosition: State['userMousePosition']) => void; + setIsMiningLoading: (isMiningLoading: State['isMiningLoading']) => void; } type UIStoreState = State & Actions; @@ -26,8 +23,7 @@ const initialState: State = { view: 'mining', visualMode: true, sidebarOpen: false, - isAutoMining: false, - userMousePosition: [0, 0], + isMiningLoading: false, }; export const useUIStore = create()((set) => ({ @@ -36,6 +32,5 @@ export const useUIStore = create()((set) => ({ setView: (view) => set({ view }), setVisualMode: (visualMode) => set({ visualMode }), setSidebarOpen: (sidebarOpen) => set({ sidebarOpen }), - setIsAutoMining: (isAutoMining) => set({ isAutoMining }), - setUserMousePosition: (userMousePosition) => set({ userMousePosition }), + setIsMiningLoading: (isMiningLoading) => set({ isMiningLoading }), })); diff --git a/src/types/invoke.ts b/src/types/invoke.ts index 4c97b183..badda498 100644 --- a/src/types/invoke.ts +++ b/src/types/invoke.ts @@ -8,6 +8,6 @@ declare module '@tauri-apps/api/tauri' { function invoke(param: 'status'): Promise; function invoke(param: 'start_mining'): Promise; function invoke(param: 'stop_mining'): Promise; - function invoke(param: 'start_auto_mining'): Promise; - function invoke(param: 'stop_auto_mining'): Promise; + function invoke(param: 'start_listening_to_user_activity'): Promise; + function invoke(param: 'stop_listening_to_user_activity'): Promise; }