Method sync_from_interfaces

multi_interface.py:219–265

Sync incoming interface metadata (from nmcli, wifi manager, or API).

(self, interfaces: List[Dict])

        return None

    def sync_from_interfaces(self, interfaces: List[Dict]):
        """Sync incoming interface metadata (from nmcli, wifi manager, or API)."""
        selected = self._select_interfaces(interfaces)
        timestamp = time.time()
        global_enabled = self.is_multi_mode_enabled()
        default_iface = self._default_iface
        focus_interface = self.get_focus_interface()

        with self._lock:
            new_state: Dict[str, Dict] = {}
            for iface in selected:
                name = iface.get('name')
                if not name:
                    continue
                role = 'internal' if name == default_iface else 'external'
                base_enabled = self._resolve_enabled_flag(name, global_enabled)
                entry = {
                    'name': name,
                    'role': role,
                    'state': iface.get('state', 'UNKNOWN'),
                    'connected': bool(iface.get('connected')),
                    'connected_ssid': iface.get('connected_ssid'),
                    'ip_address': iface.get('ip_address'),
                    'cidr': iface.get('cidr'),
                    'network_cidr': iface.get('network_cidr'),
                    'mac_address': iface.get('mac_address'),
                    'scan_enabled': base_enabled,
                    'last_refresh': timestamp,
                    'reason': None,
                    'focus_selected': bool(name and name == focus_interface),
                }

                if not global_enabled:
                    entry['scan_enabled'] = False
                    entry['reason'] = 'global_disabled'
                elif not entry['connected_ssid']:
                    entry['scan_enabled'] = False
                    entry['reason'] = 'no_ssid'
                elif not entry['connected']:
                    entry['scan_enabled'] = False
                    entry['reason'] = 'disconnected'

                new_state[name] = entry

            self.interfaces = new_state
            self.last_refresh = timestamp
            self._refresh_focus_flags()

    def get_scan_jobs(self) -> List[ScanJob]:
        """Return all scan jobs respecting interface limits and enable flags.