wip

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

Author: patrickelectric

core/frontend/src/components/wifi/WifiSettingsDialog.vue

@@ -1,6 +1,6 @@
 <template>
   <v-dialog
-    width="300"
+    width="350"
     :value="show"
     @input="showDialog"
   >
@@ -14,6 +14,17 @@
           ref="form"
           lazy-validation
         >
+          <v-select
+            v-model="selected_interface"
+            :items="available_interfaces"
+            item-text="name"
+            item-value="name"
+            label="Primary WiFi Interface"
+            hide-details="auto"
+            :loading="loading_interfaces"
+            class="mb-4"
+          />
+
           <v-text-field
             v-model="inputed_ssid"
             label="Hotspot SSID"
@@ -64,7 +75,7 @@ import Notifier from '@/libs/notifier'
 import wifi from '@/store/wifi'
 import { wifi_service } from '@/types/frontend_services'
 import { VForm } from '@/types/vuetify'
-import { NetworkCredentials } from '@/types/wifi'
+import { NetworkCredentials, WifiInterface } from '@/types/wifi'
 import back_axios from '@/utils/api'
 
 const notifier = new Notifier(wifi_service)
@@ -87,20 +98,65 @@ export default Vue.extend({
       inputed_password: wifi.hotspot_credentials?.password || '',
       enable_smart_hotspot: wifi.smart_hotspot_status || false,
       saving_settings: false,
+      available_interfaces: [] as WifiInterface[],
+      selected_interface: '',
+      loading_interfaces: false,
     }
   },
   computed: {
     form(): VForm {
       return this.$refs.form as VForm
     },
   },
+  watch: {
+    show(newVal: boolean): void {
+      if (newVal) {
+        this.fetchInterfaces()
+      }
+    },
+  },
   methods: {
+    async fetchInterfaces(): Promise<void> {
+      this.loading_interfaces = true
+      try {
+        const response = await back_axios({
+          method: 'get',
+          url: `${wifi.API_URL}/interfaces`,
+          timeout: 10000,
+        })
+        this.available_interfaces = response.data as WifiInterface[]
+        const primaryInterface = this.available_interfaces.find((iface) => iface.is_primary)
+        if (primaryInterface) {
+          this.selected_interface = primaryInterface.name
+        } else if (this.available_interfaces.length > 0) {
+          this.selected_interface = this.available_interfaces[0].name
+        }
+      } catch (error) {
+        notifier.pushBackError('WIFI_INTERFACES_FETCH_FAIL', error, true)
+      } finally {
+        this.loading_interfaces = false
+      }
+    },
     async saveSettings(): Promise<boolean> {
       if (!this.form.validate()) {
         return false
       }
       this.saving_settings = true
       try {
+        if (this.selected_interface) {
+          await back_axios({
+            method: 'post',
+            url: `${wifi.API_URL}/interfaces/primary`,
+            params: { interface_name: this.selected_interface },
+            timeout: 10000,
+          })
+            .then(() => {
+              notifier.pushSuccess('WIFI_INTERFACE_UPDATE_SUCCESS', 'Successfully updated primary WiFi interface.')
+            })
+            .catch((error) => {
+              notifier.pushBackError('WIFI_INTERFACE_UPDATE_FAIL', error, true)
+            })
+        }
         const credentials: NetworkCredentials = { ssid: this.inputed_ssid, password: this.inputed_password }
         await back_axios({
           method: 'post',

core/frontend/src/store/wifi.ts

@@ -4,7 +4,7 @@ import {
 
 import store from '@/store'
 import {
-  Network, NetworkCredentials, SavedNetwork, WifiStatus, HotspotStatus
+  HotspotStatus, Network, NetworkCredentials, SavedNetwork, WifiInterface, WifiStatus,
 } from '@/types/wifi'
 import { sorted_networks } from '@/utils/wifi'
 
@@ -31,6 +31,8 @@ class WifiStore extends VuexModule {
 
   hotspot_credentials: NetworkCredentials | null = null
 
+  interfaces: WifiInterface[] | null = null
+
   is_loading: boolean = true
 
   @Mutation
@@ -93,6 +95,11 @@ class WifiStore extends VuexModule {
     this.is_loading = loading
   }
 
+  @Mutation
+  setInterfaces(interfaces: WifiInterface[] | null): void {
+    this.interfaces = interfaces
+  }
+
   get connectable_networks(): Network[] | null {
     if (this.available_networks === null) {
       return null

core/frontend/src/types/wifi.ts

@@ -48,3 +48,8 @@ export interface NetworkCredentials {
     ssid: string
     password: string
 }
+
+export interface WifiInterface {
+    name: string
+    is_primary: boolean
+}

core/services/wifi/main.py

@@ -24,6 +24,7 @@
     SavedWifiNetwork,
     ScannedWifiNetwork,
     WifiCredentials,
+    WifiInterface,
 )
 from uvicorn import Config, Server
 from wifi_handlers.AbstractWifiHandler import AbstractWifiManager
@@ -163,6 +164,20 @@ def get_hotspot_credentials() -> Any:
     return wifi_manager.hotspot_credentials()
 
 
+@app.get("/interfaces", response_model=List[WifiInterface], summary="Get available WiFi interfaces.")
+@version(1, 0)
+async def get_interfaces() -> Any:
+    assert wifi_manager is not None
+    return await wifi_manager.get_interfaces()
+
+
+@app.post("/interfaces/primary", summary="Set the primary WiFi interface.")
+@version(1, 0)
+async def set_primary_interface(interface_name: str) -> Any:
+    assert wifi_manager is not None
+    await wifi_manager.set_primary_interface(interface_name)
+
+
 app = VersionedFastAPI(app, version="1.0.0", prefix_format="/v{major}.{minor}", enable_latest=True)
 app.mount("/", StaticFiles(directory=str(FRONTEND_FOLDER), html=True))
 

core/services/wifi/settings.py

@@ -9,6 +9,7 @@ class SettingsV1(settings.BaseSettings):
     hotspot_enabled = pykson.BooleanField()
     hotspot_ssid = pykson.StringField()
     hotspot_password = pykson.StringField()
+    primary_interface = pykson.StringField()
     smart_hotspot_enabled = pykson.BooleanField()
 
     def __init__(self, *args: str, **kwargs: int) -> None:

core/services/wifi/typedefs.py

@@ -59,3 +59,8 @@ class ConnectionStatus(str, Enum):
     JUST_CONNECTED = "JUST_CONNECTED"
     STILL_CONNECTED = "STILL_CONNECTED"
     UNKNOWN = "UNKNOWN"
+
+
+class WifiInterface(BaseModel):
+    name: str
+    is_primary: bool

core/services/wifi/wifi_handlers/AbstractWifiHandler.py

@@ -4,7 +4,7 @@
 
 from commonwealth.settings.manager import Manager
 from settings import SettingsV1
-from typedefs import SavedWifiNetwork, ScannedWifiNetwork, WifiCredentials, WifiStatus
+from typedefs import SavedWifiNetwork, ScannedWifiNetwork, WifiCredentials, WifiInterface, WifiStatus
 from wifi_handlers.wpa_supplicant.wpa_supplicant import WPASupplicant
 
 
@@ -109,3 +109,13 @@ def configure(self, _parser: Namespace) -> None:
 
     def add_arguments(self, _parser: ArgumentParser) -> None:
         """Add arguments to the parser"""
+
+    @abc.abstractmethod
+    async def get_interfaces(self) -> List[WifiInterface]:
+        """Get available WiFi interfaces."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def set_primary_interface(self, interface_name: str) -> None:
+        """Set the primary WiFi interface."""
+        raise NotImplementedError

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

@@ -20,7 +20,7 @@
     NetworkManagerSettings,
 )
 from sdbus_async.networkmanager.enums import AccessPointCapabilities, WpaSecurityFlags
-from typedefs import SavedWifiNetwork, ScannedWifiNetwork, WifiCredentials, WifiStatus
+from typedefs import SavedWifiNetwork, ScannedWifiNetwork, WifiCredentials, WifiInterface, WifiStatus
 from wifi_handlers.AbstractWifiHandler import AbstractWifiManager
 
 
@@ -107,19 +107,46 @@ async def start(self) -> None:
         for sig in (signal.SIGTERM, signal.SIGINT):
             loop.add_signal_handler(sig, lambda s=sig: asyncio.create_task(self.handle_shutdown(s)))
 
-        # Find WiFi device
+        # Find WiFi device (use configured interface if set)
+        await self._select_wifi_device()
+
+        # Create virtual AP interface if needed
+        await self._create_virtual_interface()
+        self._tasks.append(asyncio.get_event_loop().create_task(self._autoscan()))
+        self._tasks.append(asyncio.get_event_loop().create_task(self.hotspot_watchdog()))
+
+    async def _get_wifi_devices(self) -> List[tuple[str, str]]:
+        """Get all WiFi devices as (device_path, interface_name) tuples."""
         assert self._nm is not None
+        wifi_devices: List[tuple[str, str]] = []
         devices = await self._nm.get_devices()
         for device_path in devices:
             device = NetworkDeviceWireless(device_path, self._bus)
             if await device.device_type == DeviceType.WIFI:
-                self._device_path = device_path
-                break
+                interface_name = await device.interface
+                wifi_devices.append((device_path, interface_name))
+        return wifi_devices
+
+    async def _select_wifi_device(self) -> None:
+        """Select the WiFi device based on settings or first available."""
+        wifi_devices = await self._get_wifi_devices()
+        if not wifi_devices:
+            logger.warning("No WiFi devices found")
+            return
 
-        # Create virtual AP interface if needed
-        await self._create_virtual_interface()
-        self._tasks.append(asyncio.get_event_loop().create_task(self._autoscan()))
-        self._tasks.append(asyncio.get_event_loop().create_task(self.hotspot_watchdog()))
+        configured_interface = self._settings_manager.settings.primary_interface
+        if configured_interface:
+            for device_path, interface_name in wifi_devices:
+                if interface_name == configured_interface:
+                    self._device_path = device_path
+                    logger.info(f"Using configured WiFi interface: {configured_interface}")
+                    return
+
+            logger.warning(f"Configured interface {configured_interface} not found, using first available")
+
+        # Use first available device
+        self._device_path = wifi_devices[0][0]
+        logger.info(f"Using WiFi interface: {wifi_devices[0][1]}")
 
     async def _autoscan(self) -> None:
 
@@ -615,3 +642,31 @@ async def hotspot_watchdog(self) -> None:
             if not await self.hotspot_is_running():
                 logger.info("No network connection detected, enabling hotspot")
                 await self.enable_hotspot()
+
+    async def get_interfaces(self) -> List[WifiInterface]:
+        """Get available WiFi interfaces."""
+        wifi_devices = await self._get_wifi_devices()
+        current_interface = None
+        if self._device_path:
+            device = NetworkDeviceWireless(self._device_path, self._bus)
+            current_interface = await device.interface
+
+        return [
+            WifiInterface(name=interface_name, is_primary=interface_name == current_interface)
+            for _, interface_name in wifi_devices
+        ]
+
+    async def set_primary_interface(self, interface_name: str) -> None:
+        """Set the primary WiFi interface."""
+        wifi_devices = await self._get_wifi_devices()
+        available_interfaces = [name for _, name in wifi_devices]
+
+        if interface_name not in available_interfaces:
+            raise ValueError(f"Interface {interface_name} not found. Available: {available_interfaces}")
+
+        self._settings_manager.settings.primary_interface = interface_name
+        self._settings_manager.save()
+
+        # Switch to the new interface
+        await self._select_wifi_device()
+        logger.info(f"Primary interface set to: {interface_name}")

core/services/wifi/wifi_handlers/wpa_supplicant/WifiManager.py

@@ -17,6 +17,7 @@
     SavedWifiNetwork,
     ScannedWifiNetwork,
     WifiCredentials,
+    WifiInterface,
     WifiStatus,
 )
 from wifi_handlers.AbstractWifiHandler import AbstractWifiManager
@@ -577,3 +578,16 @@ async def supports_hotspot(self) -> bool:
 
     async def hotspot_is_running(self) -> bool:
         return self.hotspot.is_running()
+
+    async def get_interfaces(self) -> List[WifiInterface]:
+        """Get available WiFi interfaces (wpa_supplicant only uses one interface)."""
+        if self.wpa_path:
+            interface_name = os.path.basename(self.wpa_path)
+            return [WifiInterface(name=interface_name, is_primary=True)]
+        return []
+
+    async def set_primary_interface(self, interface_name: str) -> None:
+        """Set primary interface - wpa_supplicant requires restart to change interface."""
+        self._settings_manager.settings.primary_interface = interface_name
+        self._settings_manager.save()
+        logger.info(f"Primary interface set to: {interface_name}. Restart required to take effect.")