Method _set_current_ssid

wifi_manager.py:288–341

Update current SSID and propagate to storage with debounce. First-time establishment (no active network yet) propagates immediately so the per-network DB switches before the next scan cycle. Subsequent *changes* between known SSIDs are debounced: a transient misread of

(self, ssid)

                    ssid = str(entry).strip()
                if ssid and ssid not in seen:
                    known_ssids.append(ssid)
                    seen.add(ssid)
        except Exception as exc:
            self.logger.debug(f"Unable to enumerate known SSIDs: {exc}")
        return known_ssids

    def _run_iwlist_scan(self, interface, *, system_profiles=None, known_ssids=None, log_target=None):
        """Execute iwlist scan and return normalized network list."""
        logger_target = log_target or self.logger
        system_profiles = set(system_profiles or [])
        known_set = set(known_ssids or self._get_known_ssids())
        cmd = ['sudo', 'iwlist', interface, 'scan']
        logger_target.debug(f"Running iwlist scan on {interface}: {' '.join(cmd)}")
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=20)
        except FileNotFoundError:
            logger_target.warning("iwlist command not available; cannot perform fallback scan")
            return []
        except Exception as exc:
            logger_target.warning(f"iwlist scan execution failed: {exc}")
            return []

        if result.returncode != 0:
            stderr_snippet = (result.stderr or '').strip()
            logger_target.warning(f"iwlist scan returned code {result.returncode} on {interface}: {stderr_snippet}")
            return []

        parsed_networks = self._parse_iwlist_output(result.stdout or '') or []
        if not parsed_networks:
            logger_target.info(f"iwlist scan on {interface} returned no parseable networks")
            return []

        deduped = {}
        for network in parsed_networks:
            ssid = network.get('ssid')
            if not ssid or ssid == self.ap_ssid:
                continue
            try:
                signal = int(network.get('signal', 0) or 0)
            except (TypeError, ValueError):
                signal = 0
            existing = deduped.get(ssid)
            if not existing or signal > existing.get('signal', 0):
                enriched = {
                    'ssid': ssid,
                    'signal': signal,
                    'security': network.get('security', 'Unknown'),
                    'known': ssid in known_set or ssid in system_profiles,
                    'has_system_profile': ssid in system_profiles,
                    'scan_method': 'iwlist'
                }
                deduped[ssid] = enriched

        final_networks = sorted(deduped.values(), key=lambda x: x.get('signal', 0), reverse=True)
        logger_target.info(f"iwlist scan discovered {len(final_networks)} networks on {interface}")
        return final_networks