Check inotify paths are valid. Add dgu/egpu/ac_online checks

daemon/src/ctrl_platform.rs

@@ -225,7 +225,7 @@ impl CtrlPlatform {
             .platform
             .get_panel_od()
             .map_err(|err| {
-                warn!("CtrlRogBios: get panel overdrive {}", err);
+                warn!("CtrlRogBios: get_panel_od {}", err);
                 err
             })
             .unwrap_or(false);
@@ -239,6 +239,73 @@ impl CtrlPlatform {
     #[dbus_interface(signal)]
     async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
     }
+
+    async fn set_dgpu_disable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        disable: bool,
+    ) {
+        if self
+            .platform
+            .set_dgpu_disable(disable)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_dgpu_disable {}", err);
+                err
+            })
+            .is_ok()
+        {
+            Self::notify_dgpu_disable(&ctxt, disable).await.ok();
+        }
+    }
+
+    fn dgpu_disable(&self) -> bool {
+        self.platform
+            .get_dgpu_disable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_dgpu_disable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_dgpu_disable(
+        signal_ctxt: &SignalContext<'_>,
+        disable: bool,
+    ) -> zbus::Result<()> {
+    }
+
+    async fn set_egpu_enable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enable: bool,
+    ) {
+        if self
+            .platform
+            .set_egpu_enable(enable)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_egpu_enable {}", err);
+                err
+            })
+            .is_ok()
+        {
+            Self::notify_egpu_enable(&ctxt, enable).await.ok();
+        }
+    }
+
+    fn egpu_enable(&self) -> bool {
+        self.platform
+            .get_egpu_enable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_egpu_enable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
+    }
 }
 
 #[async_trait]
@@ -265,6 +332,8 @@ impl crate::Reloadable for CtrlPlatform {
 
 impl CtrlPlatform {
     task_watch_item!(panel_od platform);
+    task_watch_item!(dgpu_disable platform);
+    task_watch_item!(egpu_enable platform);
     task_watch_item!(gpu_mux_mode platform);
 }
 
@@ -312,6 +381,8 @@ impl CtrlTask for CtrlPlatform {
         .await;
 
         self.watch_panel_od(signal_ctxt.clone()).await?;
+        self.watch_dgpu_disable(signal_ctxt.clone()).await?;
+        self.watch_egpu_enable(signal_ctxt.clone()).await?;
         self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
 
         Ok(())

daemon/src/ctrl_power.rs

@@ -7,6 +7,7 @@ use rog_platform::supported::ChargeSupportedFunctions;
 use std::sync::Arc;
 use zbus::dbus_interface;
 use zbus::export::futures_util::lock::Mutex;
+use zbus::export::futures_util::StreamExt;
 use zbus::Connection;
 use zbus::SignalContext;
 
@@ -74,11 +75,23 @@ impl CtrlPower {
         }
     }
 
+    fn mains_online(&self) -> bool {
+        if self.power.has_online() {
+            if let Ok(v) = self.power.get_online() {
+                return v == 1;
+            }
+        }
+        false
+    }
+
     #[dbus_interface(signal)]
     async fn notify_charge_control_end_threshold(
         ctxt: &SignalContext<'_>,
         limit: u8,
     ) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_mains_online(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()>;
 }
 
 #[async_trait]
@@ -167,7 +180,29 @@ impl CtrlTask for CtrlPower {
         )
         .await;
 
-        self.watch_charge_control_end_threshold(signal_ctxt).await?;
+        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+            .await?;
+
+        let ctrl = self.clone();
+        match ctrl.power.monitor_online() {
+            Ok(mut watch) => {
+                tokio::spawn(async move {
+                    let mut buffer = [0; 32];
+                    watch
+                        .event_stream(&mut buffer)
+                        .unwrap()
+                        .for_each(|_| async {
+                            if let Ok(value) = ctrl.power.get_online() {
+                                Self::notify_mains_online(&signal_ctxt, value == 1)
+                                    .await
+                                    .unwrap();
+                            }
+                        })
+                        .await;
+                });
+            }
+            Err(e) => info!("inotify watch failed: {}", e),
+        }
 
         Ok(())
     }

daemon/src/daemon.rs

@@ -115,7 +115,7 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
             start_tasks(zbus, &mut connection).await?;
         }
         Err(err) => {
-            error!("AniMe control: {}", err);
+            info!("AniMe control: {}", err);
         }
     }
 

daemon/src/lib.rs

@@ -56,16 +56,20 @@ macro_rules! task_watch_item {
 
             let ctrl = self.clone();
             concat_idents::concat_idents!(watch_fn = monitor_, $name {
-            let mut watch = self.$self_inner.watch_fn()?;
-            tokio::spawn(async move {
-                    let mut buffer = [0; 32];
-                    watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
-                        let value = ctrl.$name();
-                        concat_idents::concat_idents!(notif_fn = notify_, $name {
-                            Self::notif_fn(&signal_ctxt, value).await.unwrap();
+                match self.$self_inner.watch_fn() {
+                    Ok(mut watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                let value = ctrl.$name();
+                                concat_idents::concat_idents!(notif_fn = notify_, $name {
+                                    Self::notif_fn(&signal_ctxt, value).await.unwrap();
+                                });
+                            }).await;
                         });
-                    }).await;
-                });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
             });
             Ok(())
         }