wip

Signed-off-by: Patrick José Pereira <patrickelectric@gmail.com>

Author: patrickelectric

core/services/wifi/settings.py

@@ -24,3 +24,26 @@ def migrate(self, data: Dict[str, Any]) -> None:
             super().migrate(data)
 
         data["VERSION"] = SettingsV1.VERSION
+
+
+class SettingsV2(SettingsV1):
+    VERSION = 2
+    # Stores user-selected mode per interface: {"wlan0": "normal", "wlan1": "hotspot"}
+    interface_modes = pykson.ObjectField(dict, default_value={})
+
+    def __init__(self, *args: str, **kwargs: int) -> None:
+        super().__init__(*args, **kwargs)
+        self.VERSION = SettingsV2.VERSION
+
+    def migrate(self, data: Dict[str, Any]) -> None:
+        if data["VERSION"] == SettingsV2.VERSION:
+            return
+
+        if data["VERSION"] < SettingsV2.VERSION:
+            super().migrate(data)
+
+        # Migration from version 1 to 2: add interface_modes
+        if "interface_modes" not in data:
+            data["interface_modes"] = {}
+
+        data["VERSION"] = SettingsV2.VERSION

core/services/wifi/wifi_handlers/AbstractWifiHandler.py

@@ -3,7 +3,7 @@
 from typing import List, Optional
 
 from commonwealth.settings.manager import Manager
-from settings import SettingsV1
+from settings import SettingsV2
 from typedefs import SavedWifiNetwork, ScannedWifiNetwork, WifiCredentials, WifiStatus
 from wifi_handlers.wpa_supplicant.wpa_supplicant import WPASupplicant
 
@@ -12,7 +12,7 @@ class AbstractWifiManager:
     wpa = WPASupplicant()
 
     def __init__(self) -> None:
-        self._settings_manager = Manager("wifi-manager", SettingsV1)
+        self._settings_manager = Manager("wifi-manager", SettingsV2)
         self._settings_manager.load()
 
     @abc.abstractmethod

core/services/wifi/wifi_handlers/networkmanager/networkmanager.py

@@ -104,6 +104,60 @@ def __init__(self) -> None:
         self._nm_settings = NetworkManagerSettings(self._bus)
         logger.info("NetworkManagerWifi initialized")
 
+    def _save_interface_mode(self, interface: str, mode: WifiInterfaceMode) -> None:
+        """Persist the interface mode to settings."""
+        interface_modes = getattr(self._settings_manager.settings, "interface_modes", {}) or {}
+        interface_modes[interface] = mode.value
+        self._settings_manager.settings.interface_modes = interface_modes
+        self._settings_manager.save()
+        logger.info(f"Saved {interface} mode: {mode.value}")
+
+    def _get_stored_interface_mode(self, interface: str) -> Optional[WifiInterfaceMode]:
+        """Get the stored mode for an interface from settings, or None if not set."""
+        interface_modes = getattr(self._settings_manager.settings, "interface_modes", {}) or {}
+        mode_str = interface_modes.get(interface)
+        if mode_str:
+            try:
+                return WifiInterfaceMode(mode_str)
+            except ValueError:
+                logger.warning(f"Invalid stored mode '{mode_str}' for {interface}")
+        return None
+
+    async def get_default_mode_for_interface(self, interface: str) -> WifiInterfaceMode:
+        """Get the default mode for an interface based on stored setting or capabilities."""
+        caps = await self.get_interface_capabilities(interface)
+
+        # First check if user has explicitly set a mode
+        stored_mode = self._get_stored_interface_mode(interface)
+        if stored_mode is not None:
+            # Verify the stored mode is still supported by this hardware
+            if stored_mode in caps.available_modes:
+                return stored_mode
+            logger.warning(f"Stored mode {stored_mode} no longer supported on {interface}, using default")
+
+        # No stored preference or stored mode not supported - determine based on capabilities
+        if caps.supports_dual_mode:
+            return WifiInterfaceMode.DUAL
+        return WifiInterfaceMode.NORMAL
+
+    async def restore_interface_modes(self) -> None:
+        """Restore interface modes from settings on startup."""
+        for interface in list(self._device_paths.keys()):
+            try:
+                default_mode = await self.get_default_mode_for_interface(interface)
+                current_mode = self._interface_modes.get(interface, WifiInterfaceMode.NORMAL)
+                if default_mode != current_mode:
+                    logger.info(f"Restoring {interface} to {default_mode} mode")
+                    success = await self.set_interface_mode(interface, default_mode)
+                    if not success:
+                        logger.warning(f"Failed to restore {interface} to {default_mode} mode, defaulting to NORMAL")
+                        self._interface_modes[interface] = WifiInterfaceMode.NORMAL
+                else:
+                    self._interface_modes[interface] = default_mode
+            except Exception as e:
+                logger.error(f"Error restoring mode for {interface}: {e}")
+                self._interface_modes[interface] = WifiInterfaceMode.NORMAL
+
     async def _set_interface_managed(self, interface: str, managed: bool) -> None:
         """Set the NetworkManager 'Managed' property for an interface via D-Bus."""
         device_path = self._device_paths.get(interface)
@@ -259,6 +313,10 @@ async def start(self) -> None:
 
         # Create virtual AP interface if needed
         await self._create_virtual_interface()
+
+        # Restore interface modes from settings
+        await self.restore_interface_modes()
+
         self._tasks.append(asyncio.get_event_loop().create_task(self._autoscan()))
         self._tasks.append(asyncio.get_event_loop().create_task(self.hotspot_watchdog()))
 
@@ -1102,6 +1160,7 @@ async def set_interface_mode(self, interface: str, mode: WifiInterfaceMode) -> b
         if mode == WifiInterfaceMode.NORMAL:
             # Just disable hotspot (already done above), interface returns to normal
             self._interface_modes[interface] = mode
+            self._save_interface_mode(interface, mode)
             return True
 
         if mode == WifiInterfaceMode.HOTSPOT:
@@ -1114,13 +1173,15 @@ async def set_interface_mode(self, interface: str, mode: WifiInterfaceMode) -> b
             success = await self._enable_hotspot_direct(interface)
             if success:
                 self._interface_modes[interface] = mode
+                self._save_interface_mode(interface, mode)
             return success
 
         # mode == WifiInterfaceMode.DUAL
         # Enable hotspot using virtual interface (existing behavior)
         success = await self.enable_hotspot_on_interface(interface, save_settings=True)
         if success:
             self._interface_modes[interface] = mode
+            self._save_interface_mode(interface, mode)
         return success
 
     async def _enable_hotspot_direct(self, interface: str, save_settings: bool = True) -> bool: