wip

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

Author: patrickelectric

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

@@ -12,21 +12,20 @@
       </v-toolbar-title>
       <v-spacer />
       <v-btn
-        v-if="is_hotspot_interface"
+        v-if="is_hotspot_running_on_this_interface"
         v-tooltip="'Hotspot settings'"
         icon
         @click="show_settings_dialog = true"
       >
         <v-icon>mdi-cog</v-icon>
       </v-btn>
       <v-btn
-        v-if="is_hotspot_interface"
-        v-tooltip="'Toggle hotspot'"
+        v-tooltip="hotspot_status ? 'Disable hotspot' : 'Enable hotspot'"
         icon
         :color="hotspot_status ? 'success' : 'gray'"
         hide-details="auto"
         :loading="hotspot_status_loading"
-        :disabled="hotspot_supported === false"
+        :disabled="!hotspot_supported"
         @click="toggleHotspot"
       >
         <v-icon>{{ hotspot_status ? 'mdi-access-point' : 'mdi-access-point-off' }}</v-icon>
@@ -94,8 +93,8 @@ import Vue from 'vue'
 import Notifier from '@/libs/notifier'
 import wifi from '@/store/wifi'
 import { wifi_service } from '@/types/frontend_services'
-import { Network, WifiInterfaceStatus } from '@/types/wifi'
-import back_axios from '@/utils/api'
+import { InterfaceHotspotStatus, Network, WifiInterfaceStatus } from '@/types/wifi'
+import back_axios, { isBackendOffline } from '@/utils/api'
 
 import SpinningLogo from '../common/SpinningLogo.vue'
 import InterfaceConnectionDialog from './InterfaceConnectionDialog.vue'
@@ -125,6 +124,7 @@ export default Vue.extend({
       show_settings_dialog: false,
       hotspot_status_loading: false,
       ssid_filter: undefined as string | undefined,
+      interface_hotspot_status: null as InterfaceHotspotStatus | null,
     }
   },
   computed: {
@@ -148,16 +148,19 @@ export default Vue.extend({
         (network) => network.ssid.toLowerCase().includes(filter),
       )
     },
-    is_hotspot_interface(): boolean {
-      return this.interfaceName === 'wlan0'
+    is_hotspot_running_on_this_interface(): boolean {
+      return wifi.current_hotspot_interface === this.interfaceName
     },
-    hotspot_status(): boolean | null {
-      return wifi.hotspot_status?.enabled ?? null
+    hotspot_status(): boolean {
+      return this.interface_hotspot_status?.enabled ?? false
     },
-    hotspot_supported(): boolean | null {
-      return wifi.hotspot_status?.supported ?? null
+    hotspot_supported(): boolean {
+      return this.interface_hotspot_status?.supported ?? true
     },
   },
+  mounted() {
+    this.fetchHotspotStatus()
+  },
   methods: {
     isNetworkConnected(network: Network): boolean {
       const status = this.connection_status
@@ -180,19 +183,56 @@ export default Vue.extend({
     forgetNetwork(network: Network): void {
       wifi.forgettNetwork(network)
     },
+    async fetchHotspotStatus(): Promise<void> {
+      await back_axios({
+        method: 'get',
+        url: `${wifi.API_URL_V2}/wifi/hotspot/${this.interfaceName}`,
+        timeout: 10000,
+      })
+        .then((response) => {
+          this.interface_hotspot_status = response.data
+        })
+        .catch((error) => {
+          if (isBackendOffline(error)) return
+          // Fallback to v1 API for backward compatibility
+          this.interface_hotspot_status = {
+            interface: this.interfaceName,
+            supported: wifi.hotspot_status?.supported ?? true,
+            enabled: wifi.hotspot_status?.enabled ?? false,
+            ssid: null,
+            password: null,
+          }
+        })
+    },
     async toggleHotspot(): Promise<void> {
       this.hotspot_status_loading = true
+      const action = this.hotspot_status ? 'disable' : 'enable'
+
       await back_axios({
         method: 'post',
-        url: `${wifi.API_URL}/hotspot`,
-        params: { enable: !this.hotspot_status },
-        timeout: 20000,
+        url: `${wifi.API_URL_V2}/wifi/hotspot/${action}`,
+        data: { interface: this.interfaceName },
+        timeout: 30000,
       })
         .then(() => {
-          notifier.pushSuccess('HOTSPOT_STATUS_TOGGLE_SUCCESS', 'Successfully toggled hotspot state.')
+          notifier.pushSuccess('HOTSPOT_STATUS_TOGGLE_SUCCESS', `Hotspot ${action}d on ${this.interfaceName}.`)
+          this.fetchHotspotStatus()
         })
         .catch((error) => {
-          notifier.pushBackError('HOTSPOT_STATUS_TOGGLE_FAIL', error, true)
+          if (isBackendOffline(error)) return
+          // Fallback to v1 API
+          back_axios({
+            method: 'post',
+            url: `${wifi.API_URL}/hotspot`,
+            params: { enable: !this.hotspot_status },
+            timeout: 20000,
+          })
+            .then(() => {
+              notifier.pushSuccess('HOTSPOT_STATUS_TOGGLE_SUCCESS', 'Successfully toggled hotspot state.')
+            })
+            .catch((fallbackError) => {
+              notifier.pushBackError('HOTSPOT_STATUS_TOGGLE_FAIL', fallbackError, true)
+            })
         })
         .finally(() => {
           this.hotspot_status_loading = false

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

@@ -167,6 +167,7 @@ export default Vue.extend({
         .then((response) => {
           const data = response.data as WifiInterfaceList
           wifi.setWifiInterfaces(data.interfaces)
+          wifi.setCurrentHotspotInterface(data.hotspot_interface)
         })
         .catch((error) => {
           // Silently fail - v2 API might not be available

core/frontend/src/store/wifi.ts

@@ -4,8 +4,13 @@ import {
 
 import store from '@/store'
 import {
-  Network, NetworkCredentials, SavedNetwork, WifiStatus, HotspotStatus,
-  WifiInterface, WifiInterfaceList, WifiInterfaceScanResult, WifiInterfaceStatus,
+  HotspotStatus,
+  Network,
+  NetworkCredentials,
+  SavedNetwork,
+  WifiInterface,
+  WifiInterfaceStatus,
+  WifiStatus,
 } from '@/types/wifi'
 import { sorted_networks } from '@/utils/wifi'
 
@@ -34,7 +39,7 @@ class WifiStore extends VuexModule {
 
   hotspot_credentials: NetworkCredentials | null = null
 
-  is_loading: boolean = true
+  is_loading = true
 
   // Multi-interface support (v2 API)
   wifi_interfaces: WifiInterface[] = []
@@ -43,6 +48,8 @@ class WifiStore extends VuexModule {
 
   interface_status: Map<string, WifiInterfaceStatus> = new Map()
 
+  current_hotspot_interface: string | null = null
+
   @Mutation
   setCurrentNetwork(network: Network | null): void {
     this.current_network = network
@@ -122,6 +129,11 @@ class WifiStore extends VuexModule {
     this.interface_status.set(payload.interface_name, payload.status)
   }
 
+  @Mutation
+  setCurrentHotspotInterface(interface_name: string | null): void {
+    this.current_hotspot_interface = interface_name
+  }
+
   get connectable_networks(): Network[] | null {
     if (this.available_networks === null) {
       return null

core/frontend/src/types/wifi.ts

@@ -62,7 +62,7 @@ export interface WifiInterface {
 
 export interface WifiInterfaceList {
     interfaces: WifiInterface[]
-    hotspot_interface: string
+    hotspot_interface: string | null
 }
 
 export interface WifiInterfaceStatus {
@@ -90,3 +90,20 @@ export interface ConnectRequest {
 export interface DisconnectRequest {
     interface: string
 }
+
+export interface HotspotRequest {
+    interface: string
+}
+
+export interface HotspotCredentialsRequest {
+    interface: string
+    credentials: NetworkCredentials
+}
+
+export interface InterfaceHotspotStatus {
+    interface: string
+    supported: boolean
+    enabled: boolean
+    ssid: string | null
+    password: string | null
+}

core/services/wifi/api/v2/routers/interfaces.py

@@ -29,10 +29,8 @@ async def list_interfaces() -> WifiInterfaceList:
     """Get list of all available WiFi interfaces on the system.
 
     Returns interface name, connection status, connected SSID (if any),
-    signal strength, and IP address.
-
-    Note: The hotspot interface (wlan0) is included but hotspot operations
-    are always bound to wlan0 regardless of which interface is used for client connections.
+    signal strength, and IP address. Also indicates which interface (if any)
+    is currently running the hotspot.
     """
     manager = get_wifi_manager()
 
@@ -53,10 +51,12 @@ async def list_interfaces() -> WifiInterfaceList:
         except Exception as e:
             logger.error(f"Error getting interface status: {e}")
             interfaces = []
+        hotspot_interface = "wlan0" if await manager.hotspot_is_running() else None
     else:
         interfaces = await manager.get_wifi_interfaces()
+        hotspot_interface = await manager.get_hotspot_interface() if hasattr(manager, "get_hotspot_interface") else None
 
-    return WifiInterfaceList(interfaces=interfaces, hotspot_interface="wlan0")
+    return WifiInterfaceList(interfaces=interfaces, hotspot_interface=hotspot_interface)
 
 
 @interfaces_router_v2.get("/{interface_name}", response_model=WifiInterface, summary="Get specific interface status.")

core/services/wifi/api/v2/routers/wifi.py

@@ -1,13 +1,17 @@
 import sys
-from typing import List, cast
+from typing import Dict, List, Optional, cast
 
 from fastapi import APIRouter, HTTPException, status
 from fastapi_versioning import versioned_api_route
 from typedefs import (
     ConnectRequest,
     DisconnectRequest,
+    HotspotCredentialsRequest,
+    HotspotRequest,
+    InterfaceHotspotStatus,
     SavedWifiNetwork,
     ScannedWifiNetwork,
+    WifiCredentials,
     WifiInterfaceScanResult,
     WifiInterfaceStatus,
 )
@@ -222,3 +226,120 @@ async def remove_saved_network(ssid: str) -> dict[str, str]:
         ) from error
 
     return {"status": "removed", "ssid": ssid}
+
+
+# Hotspot endpoints
+
+
+@wifi_router_v2.get(
+    "/hotspot/{interface_name}",
+    response_model=InterfaceHotspotStatus,
+    summary="Get hotspot status for a specific interface.",
+)
+async def get_hotspot_status(interface_name: str) -> InterfaceHotspotStatus:
+    """Get hotspot status for a specific WiFi interface."""
+    manager = get_wifi_manager()
+
+    supported = True
+    enabled = False
+    credentials: Optional[WifiCredentials] = None
+
+    if hasattr(manager, "supports_hotspot_on_interface"):
+        supported = await manager.supports_hotspot_on_interface(interface_name)
+    elif hasattr(manager, "supports_hotspot"):
+        supported = await manager.supports_hotspot()
+
+    if hasattr(manager, "hotspot_is_running_on_interface"):
+        enabled = await manager.hotspot_is_running_on_interface(interface_name)
+    elif hasattr(manager, "get_hotspot_interface"):
+        # Check if hotspot is running on this specific interface
+        current_hotspot_iface = await manager.get_hotspot_interface()
+        enabled = current_hotspot_iface == interface_name
+    elif hasattr(manager, "hotspot_is_running"):
+        # Legacy fallback - can only tell if hotspot is running, not on which interface
+        # Assume first interface for backward compatibility
+        enabled = await manager.hotspot_is_running() and interface_name == "wlan0"
+
+    if hasattr(manager, "hotspot_credentials"):
+        credentials = manager.hotspot_credentials()
+
+    return InterfaceHotspotStatus(
+        interface=interface_name,
+        supported=supported,
+        enabled=enabled,
+        ssid=credentials.ssid if credentials else None,
+        password=credentials.password if credentials else None,
+    )
+
+
+@wifi_router_v2.post(
+    "/hotspot/enable",
+    summary="Enable hotspot on a specific interface.",
+)
+async def enable_hotspot(request: HotspotRequest) -> Dict[str, str]:
+    """Enable hotspot on a specific WiFi interface.
+
+    This allows running a hotspot on any available WiFi interface,
+    not just the default one.
+    """
+    manager = get_wifi_manager()
+
+    try:
+        if hasattr(manager, "enable_hotspot_on_interface"):
+            success = await manager.enable_hotspot_on_interface(request.interface)
+        else:
+            success = await manager.enable_hotspot()
+
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Failed to enable hotspot on {request.interface}",
+            )
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) from e
+
+    return {"status": "enabled", "interface": request.interface}
+
+
+@wifi_router_v2.post(
+    "/hotspot/disable",
+    summary="Disable hotspot on a specific interface.",
+)
+async def disable_hotspot(request: HotspotRequest) -> Dict[str, str]:
+    """Disable hotspot on a specific WiFi interface."""
+    manager = get_wifi_manager()
+
+    try:
+        if hasattr(manager, "disable_hotspot_on_interface"):
+            await manager.disable_hotspot_on_interface(request.interface)
+        else:
+            await manager.disable_hotspot()
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) from e
+
+    return {"status": "disabled", "interface": request.interface}
+
+
+@wifi_router_v2.post(
+    "/hotspot/credentials",
+    summary="Update hotspot credentials.",
+)
+async def set_hotspot_credentials(request: HotspotCredentialsRequest) -> Dict[str, str]:
+    """Update the hotspot SSID and password.
+
+    Note: Changes take effect on next hotspot enable.
+    """
+    manager = get_wifi_manager()
+
+    try:
+        if hasattr(manager, "set_hotspot_credentials"):
+            await manager.set_hotspot_credentials(request.credentials)
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_501_NOT_IMPLEMENTED,
+                detail="Hotspot credential management not supported by this handler",
+            )
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) from e
+
+    return {"status": "updated", "ssid": request.credentials.ssid}