Merge pull request #75 from wiiznokes/dev

feat: remove bridge.update call from update

DEV.md

@@ -20,9 +20,8 @@
 
 ## Todo/upgradable parts
 - add cargo-packager a way to localize ressource: done but not merged
-- add app icon on windows (nsis)
+- add app icon on windows, with cargo packager (nsis)
 - add resource folder only for nsis
-- execute as admin by default: nsis
 - return error from the windows server
 - stop windows server with a command: implemented but could be improved with taking app state back
 - get app_state back when we close the ui
@@ -42,7 +41,7 @@
 - find out how to do blocking operation on the command pool of Iced, without blocking the thread
 - support const value in trait that use enum_dispatch
 - fix the time_stamp of env_logger
-
+- pop when leaving the app, to save the current config or auto create temp config
 
 ## run specific test:
 ```

build.rs

@@ -3,7 +3,8 @@ use std::{env, io};
 // https://github.com/mxre/winres/
 
 fn main() -> io::Result<()> {
-    if env::var_os("CARGO_CFG_WINDOWS").is_some() && std::env::var("PROFILE").unwrap() == "release" {
+    if env::var_os("CARGO_CFG_WINDOWS").is_some() && std::env::var("PROFILE").unwrap() == "release"
+    {
         winres::WindowsResource::new()
             .set_icon("resource/app_icon/app_icon150.ico")
             .set_manifest_file("resource/windows/manifest.xml")

data/src/update.rs

@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use hardware::{HardwareBridge, HardwareBridgeT, Mode, Value};
+use hardware::{HardwareBridge, Mode, Value};
 
 use thiserror::Error;
 
@@ -42,14 +42,15 @@ impl Update {
     }
 
     // todo: remember what nodes are valid
+    /// Update graph in an optimal way. This shouln't be use
+    /// with a graphical interface.
+    /// Warning: doesn't call update from the bridge, it's the role of the caller.
     pub fn optimized(
         &mut self,
         nodes: &mut Nodes,
         root_nodes: &RootNodes,
         bridge: &mut HardwareBridge,
     ) -> Result<()> {
-        bridge.update()?;
-
         let mut updated: HashSet<Id> = HashSet::new();
         for node_id in root_nodes {
             if let Err(e) = Self::update_rec(nodes, node_id, &mut updated, bridge) {
@@ -60,7 +61,7 @@ impl Update {
     }
 
     /// Doesn't update root nodes and doesn't re update nodes that could have been updated (fans).
-    /// Also, don't call update function of the bridge, it must have been called by the caller
+    /// Warning: doesn't call update from the bridge, it's the role of the caller.
     pub fn all(&mut self, nodes: &mut Nodes, bridge: &mut HardwareBridge) -> Result<()> {
         let ids_to_update_sorted: Vec<Id>;
         {

hardware/src/windows.rs

@@ -409,13 +409,8 @@ mod test {
     fn update(bridge: &mut WindowsBridge, hardware: &Hardware) {
         info!("");
 
-        bench(
-            || {
-                bridge.update().unwrap();
-                "lhm".to_string()
-            },
-            "update",
-        );
+        bridge.update().unwrap();
+        std::thread::sleep(crate::TIME_TO_UPDATE);
 
         for h in &hardware.controls {
             get_value(bridge, &h.internal_index, &h.name);

src/cli.rs

@@ -30,6 +30,12 @@ pub fn run_cli(mut app_state: AppState) {
     display_info(app_state.dir_manager.settings(), current_config);
 
     loop {
+        if let Err(e) = app_state.bridge.update() {
+            error!("{}", e);
+            break;
+        }
+        std::thread::sleep(hardware::TIME_TO_UPDATE);
+
         if let Err(e) = app_state.update.optimized(
             &mut app_state.app_graph.nodes,
             &app_state.app_graph.root_nodes,
@@ -38,9 +44,12 @@ pub fn run_cli(mut app_state: AppState) {
             error!("{}", e);
         }
 
-        let duration = Duration::from_millis(app_state.dir_manager.settings().update_delay);
+        let settings_update_delay =
+            Duration::from_millis(app_state.dir_manager.settings().update_delay)
+                - hardware::TIME_TO_UPDATE;
+        let final_delay = std::cmp::max(settings_update_delay, Duration::from_millis(50));
 
-        match rx.recv_timeout(duration) {
+        match rx.recv_timeout(final_delay) {
             Ok(action) => match action {
                 UserAction::Quit => {
                     println!("quit requested");

src/fake_integrated_test.rs

@@ -35,6 +35,12 @@ fn test_config() {
     };
 
     for _ in 0..20 {
+        if let Err(e) = app_state.bridge.update() {
+            error!("{}", e);
+            break;
+        }
+        std::thread::sleep(hardware::TIME_TO_UPDATE);
+
         app_state
             .update
             .optimized(

ui/src/lib.rs

@@ -85,12 +85,7 @@ impl cosmic::Application for Ui {
             .current_config_text()
             .to_owned();
 
-        let commands = Command::batch([
-            command::set_theme(to_cosmic_theme(&flags.dir_manager.settings().theme)),
-            command::message(cosmic::app::Message::App(AppMsg::Tick)),
-        ]);
-
-        let ui_state = Ui {
+        let mut ui_state = Ui {
             nodes_c: NodesC::new(flags.app_graph.nodes.values()),
             app_state: flags,
             core,
@@ -99,35 +94,24 @@ impl cosmic::Application for Ui {
             current_config_cached,
             is_updating: false,
         };
+
+        let update_graph_command = ui_state.maybe_update_hardware_to_update_graph();
+
+        let commands = Command::batch([
+            command::set_theme(to_cosmic_theme(
+                &ui_state.app_state.dir_manager.settings().theme,
+            )),
+            update_graph_command,
+        ]);
+
         (ui_state, commands)
     }
 
     fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
         let dir_manager = &mut self.app_state.dir_manager;
 
-        fn wait_update_to_finish(msg_to_send: AppMsg) -> Command<AppMsg> {
-            Command::perform(
-                async {
-                    tokio::time::sleep(hardware::TIME_TO_UPDATE).await;
-                },
-                |_| cosmic::app::Message::App(msg_to_send),
-            )
-        }
-
         match message {
-            AppMsg::Tick => {
-                if !self.is_updating {
-                    self.is_updating = true;
-                    if let Err(e) = self.app_state.bridge.update() {
-                        error!("{}", e);
-                        self.is_updating = false;
-                    } else {
-                        return wait_update_to_finish(AppMsg::UpdateGraph);
-                    }
-                } else {
-                    debug!("An update is already processing: skipping that one.");
-                }
-            }
+            AppMsg::Tick => return self.maybe_update_hardware_to_update_graph(),
             AppMsg::UpdateGraph => {
                 if let Err(e) = self.app_state.update.all(
                     &mut self.app_state.app_graph.nodes,
@@ -139,7 +123,7 @@ impl cosmic::Application for Ui {
                     error!("{}", e);
                     self.is_updating = false;
                 } else {
-                    return wait_update_to_finish(AppMsg::UpdateRootNodes);
+                    return wait_hardware_update_to_finish(AppMsg::UpdateRootNodes);
                 }
             }
             AppMsg::UpdateRootNodes => {
@@ -393,7 +377,7 @@ impl cosmic::Application for Ui {
                                     AppGraph::from_config(config, self.app_state.bridge.hardware());
                                 self.nodes_c = NodesC::new(self.app_state.app_graph.nodes.values());
 
-                                return command::message(cosmic::app::Message::App(AppMsg::Tick));
+                                return self.maybe_update_hardware_to_update_graph();
                             }
                             None => {
                                 self.current_config_cached.clear();
@@ -536,3 +520,30 @@ fn to_cosmic_theme(theme: &AppTheme) -> theme::Theme {
         AppTheme::System => theme::system_preference(),
     }
 }
+
+fn wait_hardware_update_to_finish(msg_to_send: AppMsg) -> Command<AppMsg> {
+    Command::perform(
+        async {
+            tokio::time::sleep(hardware::TIME_TO_UPDATE).await;
+        },
+        |_| cosmic::app::Message::App(msg_to_send),
+    )
+}
+
+impl Ui {
+    fn maybe_update_hardware_to_update_graph(&mut self) -> Command<AppMsg> {
+        if !self.is_updating {
+            self.is_updating = true;
+            if let Err(e) = self.app_state.bridge.update() {
+                error!("{}", e);
+                self.is_updating = false;
+            } else {
+                return wait_hardware_update_to_finish(AppMsg::UpdateGraph);
+            }
+        } else {
+            warn!("An update is already processing: skipping that one.");
+        }
+
+        Command::none()
+    }
+}