wip

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

Author: patrickelectric

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

@@ -3,6 +3,7 @@
 
 from fastapi import APIRouter, HTTPException, status
 from fastapi_versioning import versioned_api_route
+from loguru import logger
 from typedefs import (
     ConnectRequest,
     DisconnectRequest,
@@ -426,9 +427,15 @@ async def set_interface_mode(request: SetInterfaceModeRequest) -> Dict[str, str]
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail=f"Failed to set mode {request.mode} on {request.interface}",
             )
+    except HTTPException as he:
+        logger.error(f"HTTPException in set_interface_mode: {he.detail}")
+        raise
     except ValueError as e:
+        logger.error(f"ValueError in set_interface_mode: {e}")
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
     except Exception as e:
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) from e
+        error_msg = str(e) if str(e) else f"{type(e).__name__}: (no message)"
+        logger.error(f"Exception in set_interface_mode: type={type(e).__name__}, msg={error_msg}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=error_msg) from e
 
     return {"status": "success", "interface": request.interface, "mode": request.mode.value}

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

@@ -5,6 +5,7 @@
 import select
 import signal
 import subprocess
+import time
 from concurrent.futures import CancelledError
 from typing import Any, Dict, List, Optional
 
@@ -1002,8 +1003,11 @@ async def set_interface_mode(self, interface: str, mode: WifiInterfaceMode) -> b
             return True
 
         if mode == WifiInterfaceMode.HOTSPOT:
-            # Disconnect from any network first
-            await self.disconnect_interface(interface)
+            # Disconnect from any network first (ignore errors if not connected)
+            try:
+                await self.disconnect_interface(interface)
+            except Exception as e:
+                logger.debug(f"Disconnect before hotspot mode (expected if not connected): {e}")
             # Enable hotspot in "direct" mode (no virtual interface)
             success = await self._enable_hotspot_direct(interface)
             if success:
@@ -1030,24 +1034,76 @@ async def _enable_hotspot_direct(self, interface: str, save_settings: bool = Tru
         credentials = self.hotspot_credentials()
 
         # Use create_ap directly on the physical interface (no virtual interface)
+        cmd = [
+            "create_ap",
+            "-n",  # No internet sharing
+            "--freq-band",
+            "2.4",
+            interface,  # Use physical interface directly
+            credentials.ssid,
+            credentials.password,
+        ]
+
         try:
-            cmd = [
-                "create_ap",
-                "--daemon",
-                "-n",  # No internet sharing
-                "--freq-band",
-                "2.4",
-                interface,  # Use physical interface directly
-                credentials.ssid,
-                credentials.password,
-            ]
-            # pylint: disable-next=consider-using-with
-            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            # Stop existing hotspot on this interface if running
+            if interface in self._create_ap_processes:
+                existing_process = self._create_ap_processes[interface]
+                if existing_process.poll() is None:
+                    logger.info(f"Stopping existing hotspot on {interface}...")
+                    existing_process.terminate()
+                    existing_process.wait()
+                del self._create_ap_processes[interface]
+
+            # pylint: disable=consider-using-with
+            process = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, bufsize=1
+            )
+            # pylint: enable=consider-using-with
+
+            success = False
+            loop = asyncio.get_running_loop()
+            start_time = loop.time()
+            timeout = 30
+
+            while process.poll() is None:
+                if select.select([process.stdout], [], [], 0)[0]:
+                    assert process.stdout is not None
+                    line = process.stdout.readline()
+
+                    line = line.strip()
+                    if line:
+                        logger.info(f"create_ap ({interface} direct): {line}")
+                        if "Done" in line or "AP-ENABLED" in line:
+                            success = True
+                            break
+                        if "ERROR" in line:
+                            logger.error(f"create_ap error on {interface}: {line}")
+                            return False
+
+                    if loop.time() - start_time > timeout:
+                        logger.error(f"Timeout waiting for create_ap on {interface}")
+                        return False
+
+                await asyncio.sleep(0.1)
+
+            if not success:
+                exit_code = process.poll()
+                logger.error(
+                    f"Failed to start create_ap directly on {interface}, exit code: {exit_code}. "
+                    "The adapter may report AP mode support but cannot actually run as an access point."
+                )
+                return False
+
+            logger.info(f"Successfully started create_ap directly on {interface} with PID {process.pid}")
             self._create_ap_processes[interface] = process
             self._hotspot_interface = interface
             self._create_ap_process = process  # Backward compatibility
-            logger.info(f"Started hotspot directly on {interface} with SSID {credentials.ssid}")
+
+            self._tasks.append(loop.create_task(self._monitor_create_ap_output(process)))
+
+            logger.info(f"Hotspot enabled directly on {interface}")
             return True
+
         except Exception as e:
             logger.error(f"Failed to start direct hotspot on {interface}: {e}")
             return False