Add adapter power on/off functionality

locales/app.yml

@@ -49,10 +49,14 @@ menus:
           fr: "Déconnexion"
   settings:
     options:
+      power_off_adapter:
+        name:
+          en: "Power Off Adapter"
+          fr: "Mettre l'adaptateur hors tension"
       disable_device:
         name:
-          en: "Disable Wi-Fi"
-          fr: "Désactiver le Wi-Fi"
+          en: "Disable Wi-Fi/AP Device"
+          fr: "Désactiver le périphérique Wi-Fi/AP"
       switch_mode:
         name:
           en: "%{mode} Mode"
@@ -85,12 +89,22 @@ menus:
         name:
           en: "Settings"
           fr: "Paramètres"
+  adapter:
+    options:
+      power_on_adapter:
+        name:
+          en: "Power On Adapter"
+          fr: "Mettre l'adaptateur sous tension"
   device:
     options:
+      power_off_adapter:
+        name:
+          en: "Power Off Adapter"
+          fr: "Mettre l'adaptateur hors tension"
       enable_device:
         name:
-          en: "Enable Wi-Fi"
-          fr: "Activer le Wi-Fi"
+          en: "Enable Wi-Fi/AP Device"
+          fr: "Activer le périphérique Wi-Fi/AP"
 
 notifications:
   station:
@@ -176,20 +190,29 @@ notifications:
     unknown_mode:
       en: "Unknown mode"
       fr: "Mode inconnu"
+    adapter_powered_on:
+      en: "Adapter Powered On"
+      fr: "Adaptateur sous tension"
+    adapter_powered_off:
+      en: "Adapter Powered Off"
+      fr: "Adaptateur hors tension"
     device_enabled:
-      en: "Wi-Fi enabled"
-      fr: "Wi-Fi activé"
+      en: "Wi-Fi/AP device enabled"
+      fr: "Périphérique Wi-Fi/AP activé"
     device_disabled:
-      en: "Wi-Fi disabled"
-      fr: "Wi-Fi désactivé"
+      en: "Wi-Fi/AP device disabled"
+      fr: "Périphérique Wi-Fi/AP désactivé"
     main_menu_exited:
       en: "Exited main menu"
       fr: "Sortie du menu principal"
     ap_menu_exited:
       en: "Exited Access Point menu"
       fr: "Sortie du menu Point d'accès"
-    device_menu_exited:
+    adapter_menu_exited:
       en: "Exited adapter menu"
+      fr: "Sortie du menu de l'adaptateur"
+    device_menu_exited:
+      en: "Exited device menu"
       fr: "Sortie du menu de l'appareil"
 
 modes:

src/app.rs

@@ -2,8 +2,8 @@ use crate::{
     icons::Icons,
     iw::{adapter::Adapter, agent::AgentManager, known_network::KnownNetwork, network::Network},
     menu::{
-        ApMenuOptions, DeviceMenuOptions, KnownNetworkOptions, MainMenuOptions, Menu,
-        SettingsMenuOptions,
+        AdapterMenuOptions, ApMenuOptions, DeviceMenuOptions, KnownNetworkOptions, MainMenuOptions,
+        Menu, SettingsMenuOptions,
     },
     notification::NotificationManager,
 };
@@ -79,15 +79,21 @@ impl App {
         icon_type: &str,
         spaces: usize,
     ) -> Result<Option<String>> {
+        if !self.adapter.is_powered {
+            self.handle_adapter_options(menu, menu_command, icon_type, spaces)
+                .await?;
+        }
+        if self.running && !self.adapter.device.is_enabled {
+            self.handle_device_options(menu, menu_command, icon_type, spaces)
+                .await?;
+        }
+        if !self.running {
+            return Ok(None);
+        }
+
         while self.running {
             self.adapter.refresh().await?;
 
-            if !self.adapter.device.is_powered {
-                self.handle_device_options(menu, menu_command, icon_type, spaces)
-                    .await?;
-                continue;
-            }
-
             match self.adapter.device.mode {
                 Mode::Station => {
                     self.run_station_mode(menu, menu_command, icon_type, spaces)
@@ -256,7 +262,8 @@ impl App {
                         )
                         .await?
                     {
-                        self.handle_settings_options(option, menu).await?;
+                        self.handle_settings_options(option, menu, menu_command, icon_type, spaces)
+                            .await?;
                         if !self.interactive {
                             self.running = false;
                         }
@@ -391,7 +398,8 @@ impl App {
                 if matches!(option, SettingsMenuOptions::Back) {
                     stay_in_settings_menu = false;
                 } else {
-                    self.handle_settings_options(option, menu).await?;
+                    self.handle_settings_options(option, menu, menu_command, icon_type, spaces)
+                        .await?;
                     if !self.interactive {
                         self.running = false;
                         stay_in_settings_menu = false;
@@ -415,11 +423,20 @@ impl App {
         &mut self,
         option: SettingsMenuOptions,
         menu: &Menu,
+        menu_command: &Option<String>,
+        icon_type: &str,
+        spaces: usize,
     ) -> Result<bool> {
         match option {
             SettingsMenuOptions::Back => Ok(false),
+            SettingsMenuOptions::PowerOffAdapter => {
+                self.perform_power_off_adapter(menu, menu_command, icon_type, spaces)
+                    .await?;
+                Ok(false)
+            }
             SettingsMenuOptions::DisableDevice => {
-                self.perform_device_disable().await?;
+                self.perform_device_disable(menu, menu_command, icon_type, spaces)
+                    .await?;
                 Ok(false)
             }
             SettingsMenuOptions::SwitchMode => {
@@ -431,36 +448,89 @@ impl App {
         }
     }
 
-    async fn handle_device_options(
+    async fn handle_adapter_options(
         &mut self,
         menu: &Menu,
         menu_command: &Option<String>,
         icon_type: &str,
         spaces: usize,
     ) -> Result<()> {
-        if let Some(option) = menu.prompt_enable_device(menu_command, icon_type, spaces) {
+        if let Some(option) = menu.prompt_power_on_adapter(menu_command, icon_type, spaces) {
             match option {
-                DeviceMenuOptions::EnableDevice => {
-                    self.adapter.device.power_on().await?;
+                AdapterMenuOptions::PowerOnAdapter => {
+                    self.adapter.power_on().await?;
                     self.reset(self.current_mode).await?;
-                    info!("{}", t!("notifications.app.device_enabled"));
+                    info!("{}", t!("notifications.app.adapter_powered_on"));
                     try_send_notification!(
                         self.notification_manager,
                         None,
-                        Some(t!("notifications.app.device_enabled").to_string()),
-                        Some("enable_device"),
+                        Some(t!("notifications.app.adapter_powered_on").to_string()),
+                        Some("power_on_adapter"),
                         None
                     );
                 }
             }
         } else {
-            debug!("{}", t!("notifications.app.device_menu_exited"));
+            debug!("{}", t!("notifications.app.adapter_menu_exited"));
             self.running = false;
         }
 
         Ok(())
     }
 
+    async fn handle_device_options(
+        &mut self,
+        menu: &Menu,
+        menu_command: &Option<String>,
+        icon_type: &str,
+        spaces: usize,
+    ) -> Result<()> {
+        loop {
+            if let Some(option) = menu.prompt_enable_device(menu_command, icon_type, spaces) {
+                match option {
+                    DeviceMenuOptions::PowerOffAdapter => {
+                        self.adapter.power_off().await?;
+                        self.reset(self.current_mode).await?;
+                        info!("{}", t!("notifications.app.adapter_powered_off"));
+                        try_send_notification!(
+                            self.notification_manager,
+                            None,
+                            Some(t!("notifications.app.adapter_powered_off").to_string()),
+                            Some("power_off_adapter"),
+                            None
+                        );
+                    }
+                    DeviceMenuOptions::EnableDevice => {
+                        self.adapter.device.enable().await?;
+                        self.reset(self.current_mode).await?;
+                        info!("{}", t!("notifications.app.device_enabled"));
+                        try_send_notification!(
+                            self.notification_manager,
+                            None,
+                            Some(t!("notifications.app.device_enabled").to_string()),
+                            Some("enable_device"),
+                            None
+                        );
+                    }
+                }
+            } else {
+                debug!("{}", t!("notifications.app.device_menu_exited"));
+                self.running = false;
+            }
+            if !self.adapter.is_powered {
+                self.handle_adapter_options(menu, menu_command, icon_type, spaces)
+                    .await?;
+            }
+            if !self.running {
+                break;
+            }
+            if self.adapter.device.is_enabled {
+                break;
+            }
+        }
+        Ok(())
+    }
+
     async fn handle_network_selection(
         &mut self,
         menu: &Menu,
@@ -862,8 +932,39 @@ impl App {
         Ok(())
     }
 
-    async fn perform_device_disable(&mut self) -> Result<()> {
-        self.adapter.device.power_off().await?;
+    async fn perform_power_off_adapter(
+        &mut self,
+        menu: &Menu,
+        menu_command: &Option<String>,
+        icon_type: &str,
+        spaces: usize,
+    ) -> Result<()> {
+        self.adapter.power_off().await?;
+
+        let msg = t!("notifications.app.adapter_powered_off").to_string();
+        info!("{msg}");
+        try_send_notification!(
+            self.notification_manager,
+            None,
+            Some(msg),
+            Some("power_off_adapter"),
+            None
+        );
+
+        self.handle_adapter_options(menu, menu_command, icon_type, spaces)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn perform_device_disable(
+        &mut self,
+        menu: &Menu,
+        menu_command: &Option<String>,
+        icon_type: &str,
+        spaces: usize,
+    ) -> Result<()> {
+        self.adapter.device.disable().await?;
 
         let msg = t!("notifications.app.device_disabled").to_string();
         info!("{msg}");
@@ -875,6 +976,9 @@ impl App {
             None
         );
 
+        self.handle_device_options(menu, menu_command, icon_type, spaces)
+            .await?;
+
         Ok(())
     }
 

src/icons.rs

@@ -56,8 +56,10 @@ impl Icons {
         font_icons.insert("disconnect", '\u{f0338}');
         font_icons.insert("scan", '\u{f46a}');
         font_icons.insert("settings", '\u{f0493}');
-        font_icons.insert("disable_device", '\u{f092d}');
-        font_icons.insert("enable_device", '\u{f0425}');
+        font_icons.insert("disable_device", '\u{f05aa}');
+        font_icons.insert("enable_device", '\u{f05a9}');
+        font_icons.insert("power_off_adapter", '\u{f0902}');
+        font_icons.insert("power_on_adapter", '\u{f0425}');
         font_icons.insert("switch_mode", '\u{f0fe2}');
         font_icons.insert("start_ap", '\u{f040d}');
         font_icons.insert("stop_ap", '\u{f0667}');
@@ -139,9 +141,16 @@ impl Icons {
             "scan_in_progress",
             IconDefinition::simple("network-wireless-acquiring-symbolic"),
         );
-        xdg_icons.insert("disable_device",
+        xdg_icons.insert(
+            "disable_device",
             IconDefinition::with_fallbacks(
                 Some("network-wireless-disabled-symbolic"),
+                "network-wireless-disabled-symbolic,network-wireless-off",
+            ),
+        );
+        xdg_icons.insert("power_off_adapter",
+            IconDefinition::with_fallbacks(
+                Some("network-wireless-hardware-disabled-symbolic"),
                 "network-wireless-hardware-disabled-symbolic,network-wireless-disabled-symbolic,network-wireless-off"
             )
         );
@@ -234,6 +243,10 @@ impl Icons {
             "enable_device",
             IconDefinition::simple("network-wireless-symbolic"),
         );
+        xdg_icons.insert(
+            "power_on_adapter",
+            IconDefinition::simple("network-wireless-symbolic"),
+        );
 
         Icons {
             font_icons,