android wifi scan and auto re-connect

Target platform: android Q10 platform

android 会将已连接的wifi AP保存到这个文件： data/misc/wifi/WifiConfigStore.xml

然后当wifi 再次打开的时候 scan results后 会将scan results和保存的已连接的wifi AP 中对比, 如果有已保存的wifi网络，则自动重连。

以下是一个已保存的网络节点

ID: 0 SSID: "Pixel_8287" PROVIDER-NAME: null BSSID: null FQDN: null PRIO: 0 HIDDEN: false PMF: false
 NetworkSelectionStatus NETWORK_SELECTION_ENABLED
 hasEverConnected: true
 numAssociation 3
 update time=04-13 15:58:20.958
 creation time=04-13 15:56:48.640
 validatedInternetAccess trusted
 macRandomizationSetting: 0
 mRandomizedMacAddress: 4e:c2:34:a4:04:79
 KeyMgmt: WPA_PSK Protocols: WPA RSN
 AuthAlgorithms: OPEN
 PairwiseCiphers: TKIP CCMP
 GroupCiphers: WEP40 WEP104 TKIP CCMP
 GroupMgmtCiphers:
 SuiteBCiphers:
 PSK/SAE: *
Enterprise config:
IP config:
IP assignment: DHCP
Proxy settings: NONE
 cuid=1000 cname=android.uid.system:1000 luid=1000 lname=android.uid.system:1000 lcuid=1000 userApproved=USER_UNSPECIFIED noInternetAccessExpected=true
lastConnected: 04-13 18:04:49.865
recentFailure: Association Rejection code: 0

 

frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiConnectivityManager.java

handleScanResults

    WifiConfiguration candidate = mNetworkSelector.selectNetwork(scanDetails, buildBssidBlacklist(), mWifiInfo, mStateMachine.isConnected(), mStateMachine.isDisconnected(), mUntrustedConnectionAllowed);

 

    /**
     * Select the best network from the ones in range.
     *
     * @param scanDetails    List of ScanDetail for all the APs in range
     * @param bssidBlacklist Blacklisted BSSIDs
     * @param wifiInfo       Currently connected network
     * @param connected      True if the device is connected
     * @param disconnected   True if the device is disconnected
     * @param untrustedNetworkAllowed True if untrusted networks are allowed for connection
     * @return Configuration of the selected network, or Null if nothing
     */
    @Nullable
    public WifiConfiguration selectNetwork(List<ScanDetail> scanDetails,
            HashSet<String> bssidBlacklist, WifiInfo wifiInfo,
            boolean connected, boolean disconnected, boolean untrustedNetworkAllowed) {
        mFilteredNetworks.clear();
        mConnectableNetworks.clear();
        if (scanDetails.size() == 0) {
            localLog("Empty connectivity scan result");
            return null;
        }

        WifiConfiguration currentNetwork =
                mWifiConfigManager.getConfiguredNetwork(wifiInfo.getNetworkId());

        // Always get the current BSSID from WifiInfo in case that firmware initiated
        // roaming happened.
        String currentBssid = wifiInfo.getBSSID();

        // Shall we start network selection at all?
        if (!isNetworkSelectionNeeded(scanDetails, wifiInfo, connected, disconnected)) {
            return null;
        }

        // Update all configured networks before initiating network selection.
        updateConfiguredNetworks();

        // Update the registered network evaluators.
        for (NetworkEvaluator registeredEvaluator : mEvaluators) {
            registeredEvaluator.update(scanDetails);
        }

        // Filter out unwanted networks.
        mFilteredNetworks = filterScanResults(scanDetails, bssidBlacklist,
                connected && wifiInfo.score >= WIFI_POOR_SCORE, currentBssid);
        if (mFilteredNetworks.size() == 0) {
            return null;
        }

        // Determine the weight for the last user selection
        final int lastUserSelectedNetworkId = mWifiConfigManager.getLastSelectedNetwork();
        final double lastSelectionWeight = calculateLastSelectionWeight();
        final ArraySet<Integer> mNetworkIds = new ArraySet<>();

        // Go through the registered network evaluators in order
        WifiConfiguration selectedNetwork = null;
        WifiCandidates wifiCandidates = new WifiCandidates(mWifiScoreCard);
        if (currentNetwork != null) {
            wifiCandidates.setCurrent(currentNetwork.networkId, currentBssid);
        }
        for (NetworkEvaluator registeredEvaluator : mEvaluators) {
            localLog("About to run " + registeredEvaluator.getName() + " :");
            WifiConfiguration choice = registeredEvaluator.evaluateNetworks(
                    new ArrayList<>(mFilteredNetworks), currentNetwork, currentBssid, connected,
                    untrustedNetworkAllowed,
                    (scanDetail, config, score) -> {
                        if (config != null) {
                            mConnectableNetworks.add(Pair.create(scanDetail, config));
                            mNetworkIds.add(config.networkId);
                            if (config.networkId == lastUserSelectedNetworkId) {
                                wifiCandidates.add(scanDetail, config,
                                        registeredEvaluator.getId(), score, lastSelectionWeight);
                            } else {
                                wifiCandidates.add(scanDetail, config,
                                        registeredEvaluator.getId(), score);
                            }
                            mWifiMetrics.setNominatorForNetwork(config.networkId,
                                    evaluatorIdToNominatorId(registeredEvaluator.getId()));
                        }
                    });
            if (choice != null && !mNetworkIds.contains(choice.networkId)) {
                Log.wtf(TAG, registeredEvaluator.getName()
                        + " failed to report choice with noConnectibleListener");
            }
            if (selectedNetwork == null && choice != null) {
                selectedNetwork = choice; // First one wins
                localLog(registeredEvaluator.getName() + " selects "
                        + WifiNetworkSelector.toNetworkString(selectedNetwork));
            }
        }

        if (mConnectableNetworks.size() != wifiCandidates.size()) {
            localLog("Connectable: " + mConnectableNetworks.size()
                    + " Candidates: " + wifiCandidates.size());
        }

        // Update the NetworkSelectionStatus in the configs for the current candidates
        // This is needed for the legacy user connect choice, at least
        Collection<Collection<WifiCandidates.Candidate>> groupedCandidates =
                wifiCandidates.getGroupedCandidates();
        for (Collection<WifiCandidates.Candidate> group: groupedCandidates) {
            WifiCandidates.Candidate best = null;
            for (WifiCandidates.Candidate candidate: group) {
                // Of all the candidates with the same networkId, choose the
                // one with the smallest evaluatorId, and break ties by
                // picking the one with the highest score.
                if (best == null
                        || candidate.getEvaluatorId() < best.getEvaluatorId()
                        || (candidate.getEvaluatorId() == best.getEvaluatorId()
                            && candidate.getEvaluatorScore() > best.getEvaluatorScore())) {
                    best = candidate;
                }
            }
            if (best != null) {
                ScanDetail scanDetail = best.getScanDetail();
                if (scanDetail != null) {
                    mWifiConfigManager.setNetworkCandidateScanResult(best.getNetworkConfigId(),
                            scanDetail.getScanResult(), best.getEvaluatorScore());
                }
            }
        }

        ArrayMap<Integer, Integer> experimentNetworkSelections = new ArrayMap<>(); // for metrics

        final int legacySelectedNetworkId = selectedNetwork == null
                ? WifiConfiguration.INVALID_NETWORK_ID
                : selectedNetwork.networkId;

        int selectedNetworkId = legacySelectedNetworkId;

        // Run all the CandidateScorers
        boolean legacyOverrideWanted = true;
        final WifiCandidates.CandidateScorer activeScorer = getActiveCandidateScorer();
        for (WifiCandidates.CandidateScorer candidateScorer : mCandidateScorers.values()) {
            WifiCandidates.ScoredCandidate choice;
            try {
                choice = wifiCandidates.choose(candidateScorer);
            } catch (RuntimeException e) {
                Log.wtf(TAG, "Exception running a CandidateScorer", e);
                continue;
            }
            int networkId = choice.candidateKey == null
                    ? WifiConfiguration.INVALID_NETWORK_ID
                    : choice.candidateKey.networkId;
            String chooses = " would choose ";
            if (candidateScorer == activeScorer) {
                chooses = " chooses ";
                legacyOverrideWanted = candidateScorer.userConnectChoiceOverrideWanted();
                selectedNetworkId = networkId;
            }
            String id = candidateScorer.getIdentifier();
            int expid = experimentIdFromIdentifier(id);
            localLog(id + chooses + networkId
                    + " score " + choice.value + "+/-" + choice.err
                    + " expid " + expid);
            experimentNetworkSelections.put(expid, networkId);
        }

        // Update metrics about differences in the selections made by various methods
        final int activeExperimentId = activeScorer == null ? LEGACY_CANDIDATE_SCORER_EXP_ID
                : experimentIdFromIdentifier(activeScorer.getIdentifier());
        experimentNetworkSelections.put(LEGACY_CANDIDATE_SCORER_EXP_ID, legacySelectedNetworkId);
        for (Map.Entry<Integer, Integer> entry :
                experimentNetworkSelections.entrySet()) {
            int experimentId = entry.getKey();
            if (experimentId == activeExperimentId) continue;
            int thisSelectedNetworkId = entry.getValue();
            mWifiMetrics.logNetworkSelectionDecision(experimentId, activeExperimentId,
                    selectedNetworkId == thisSelectedNetworkId,
                    groupedCandidates.size());
        }

        // Get a fresh copy of WifiConfiguration reflecting any scan result updates
        selectedNetwork = mWifiConfigManager.getConfiguredNetwork(selectedNetworkId);
        if (selectedNetwork != null && legacyOverrideWanted) {
            selectedNetwork = overrideCandidateWithUserConnectChoice(selectedNetwork);
            mLastNetworkSelectionTimeStamp = mClock.getElapsedSinceBootMillis();
        }
        return selectedNetwork;
    }

 

    private boolean isNetworkSelectionNeeded(List<ScanDetail> scanDetails, WifiInfo wifiInfo,
                        boolean connected, boolean disconnected) {
        if (scanDetails.size() == 0) {
            localLog("Empty connectivity scan results. Skip network selection.");
            return false;
        }

        if (connected) {
            // Is roaming allowed?
            if (!mEnableAutoJoinWhenAssociated) {
                localLog("Switching networks in connected state is not allowed."
                        + " Skip network selection.");
                return false;
            }

            // Has it been at least the minimum interval since last network selection?
            if (mLastNetworkSelectionTimeStamp != INVALID_TIME_STAMP) {
                long gap = mClock.getElapsedSinceBootMillis()
                            - mLastNetworkSelectionTimeStamp;
                if (gap < MINIMUM_NETWORK_SELECTION_INTERVAL_MS) {
                    localLog("Too short since last network selection: " + gap + " ms."
                            + " Skip network selection.");
                    return false;
                }
            }

            if (isCurrentNetworkSufficient(wifiInfo, scanDetails)) {
                localLog("Current connected network already sufficient. Skip network selection.");
                return false;
            } else {
                localLog("Current connected network is not sufficient.");
                return true;
            }
        } else if (disconnected) {
            return true;
        } else {
            // No network selection if ClientModeImpl is in a state other than
            // CONNECTED or DISCONNECTED.
            localLog("ClientModeImpl is in neither CONNECTED nor DISCONNECTED state."
                    + " Skip network selection.");
            return false;
        }
    }

 

    private boolean isCurrentNetworkSufficient(WifiInfo wifiInfo, List<ScanDetail> scanDetails) {
        // Currently connected?
        if (wifiInfo.getSupplicantState() != SupplicantState.COMPLETED) {
            localLog("No current connected network.");
            return false;
        } else {
            localLog("Current connected network: " + wifiInfo.getSSID()
                    + " , ID: " + wifiInfo.getNetworkId());
        }

        int currentRssi = wifiInfo.getRssi();
        boolean hasQualifiedRssi = currentRssi
                > mScoringParams.getSufficientRssi(wifiInfo.getFrequency());
        boolean hasActiveStream = (wifiInfo.txSuccessRate > mStayOnNetworkMinimumTxRate)
                || (wifiInfo.rxSuccessRate > mStayOnNetworkMinimumRxRate);
        if (hasQualifiedRssi && hasActiveStream) {
            localLog("Stay on current network because of good RSSI and ongoing traffic");
            return true;
        }
        WifiConfiguration network =
                mWifiConfigManager.getConfiguredNetwork(wifiInfo.getNetworkId());

        if (network == null) {
            localLog("Current network was removed.");
            return false;
        }

        if (mWifiConfigManager.getLastSelectedNetwork() == network.networkId
                && (mClock.getElapsedSinceBootMillis()
                    - mWifiConfigManager.getLastSelectedTimeStamp())
                <= LAST_USER_SELECTION_SUFFICIENT_MS) {
            localLog("Current network is recently user-selected.");
            return true;
        }

        // OSU (Online Sign Up) network for Passpoint Release 2 is sufficient network.
        if (network.osu) {
            return true;
        }

        // Ephemeral network is not qualified.
        if (wifiInfo.isEphemeral()) {
            localLog("Current network is an ephemeral one.");
            return false;
        }

        if (wifiInfo.is24GHz()) {
            // 2.4GHz networks is not qualified whenever 5GHz is available
            if (is5GHzNetworkAvailable(scanDetails)) {
                localLog("Current network is 2.4GHz. 5GHz networks available.");
                return false;
            }
        }
        if (!hasQualifiedRssi) {
            localLog("Current network RSSI[" + currentRssi + "]-acceptable but not qualified.");
            return false;
        }

        // Open network is not qualified.
        if (WifiConfigurationUtil.isConfigForOpenNetwork(network)) {
            localLog("Current network is a open one.");
            return false;
        }

        // Network with no internet access reports is not qualified.
        if (network.numNoInternetAccessReports > 0 && !network.noInternetAccessExpected) {
            localLog("Current network has [" + network.numNoInternetAccessReports
                    + "] no-internet access reports.");
            return false;
        }
        return true;
    }