| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.server.wifi; |
| |
| import android.content.Context; |
| import android.net.NetworkKey; |
| import android.net.NetworkScoreManager; |
| import android.net.WifiKey; |
| import android.net.wifi.ScanResult; |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiConfiguration.KeyMgmt; |
| import android.net.wifi.WifiConnectionStatistics; |
| import android.os.Process; |
| import android.provider.Settings; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.os.SystemClock; |
| |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.StringReader; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| /** |
| * AutoJoin controller is responsible for WiFi Connect decision |
| * |
| * It runs in the thread context of WifiStateMachine |
| * |
| */ |
| public class WifiAutoJoinController { |
| |
| private Context mContext; |
| private WifiStateMachine mWifiStateMachine; |
| private WifiConfigStore mWifiConfigStore; |
| private WifiNative mWifiNative; |
| |
| private NetworkScoreManager scoreManager; |
| private WifiNetworkScoreCache mNetworkScoreCache; |
| |
| private static final String TAG = "WifiAutoJoinController "; |
| private static boolean DBG = false; |
| private static boolean VDBG = false; |
| private static final boolean mStaStaSupported = false; |
| |
| public static int mScanResultMaximumAge = 40000; /* milliseconds unit */ |
| public static int mScanResultAutoJoinAge = 5000; /* milliseconds unit */ |
| |
| private String mCurrentConfigurationKey = null; //used by autojoin |
| |
| private final HashMap<String, ScanDetail> scanResultCache = new HashMap<>(); |
| |
| private WifiConnectionStatistics mWifiConnectionStatistics; |
| |
| /** |
| * Whether to allow connections to untrusted networks. |
| */ |
| private boolean mAllowUntrustedConnections = false; |
| |
| /* For debug purpose only: if the scored override a score */ |
| boolean didOverride = false; |
| |
| // Lose the non-auth failure blacklisting after 8 hours |
| private final static long loseBlackListHardMilli = 1000 * 60 * 60 * 8; |
| // Lose some temporary blacklisting after 30 minutes |
| private final static long loseBlackListSoftMilli = 1000 * 60 * 30; |
| |
| /** |
| * @see android.provider.Settings.Global#WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS |
| */ |
| private static final long DEFAULT_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS = 1000 * 60; // 1 minute |
| |
| public static final int AUTO_JOIN_IDLE = 0; |
| public static final int AUTO_JOIN_ROAMING = 1; |
| public static final int AUTO_JOIN_EXTENDED_ROAMING = 2; |
| public static final int AUTO_JOIN_OUT_OF_NETWORK_ROAMING = 3; |
| |
| public static final int HIGH_THRESHOLD_MODIFIER = 5; |
| |
| public static final int MAX_RSSI_DELTA = 50; |
| |
| // Below are AutoJoin wide parameters indicating if we should be aggressive before joining |
| // weak network. Note that we cannot join weak network that are going to be marked as unanted by |
| // ConnectivityService because this will trigger link flapping. |
| /** |
| * There was a non-blacklisted configuration that we bailed from because of a weak signal |
| */ |
| boolean didBailDueToWeakRssi = false; |
| /** |
| * number of time we consecutively bailed out of an eligible network because its signal |
| * was too weak |
| */ |
| int weakRssiBailCount = 0; |
| |
| WifiAutoJoinController(Context c, WifiStateMachine w, WifiConfigStore s, |
| WifiConnectionStatistics st, WifiNative n) { |
| mContext = c; |
| mWifiStateMachine = w; |
| mWifiConfigStore = s; |
| mWifiNative = n; |
| mNetworkScoreCache = null; |
| mWifiConnectionStatistics = st; |
| scoreManager = |
| (NetworkScoreManager) mContext.getSystemService(Context.NETWORK_SCORE_SERVICE); |
| if (scoreManager == null) |
| logDbg("Registered scoreManager NULL " + " service " + Context.NETWORK_SCORE_SERVICE); |
| |
| if (scoreManager != null) { |
| mNetworkScoreCache = new WifiNetworkScoreCache(mContext); |
| scoreManager.registerNetworkScoreCache(NetworkKey.TYPE_WIFI, mNetworkScoreCache); |
| } else { |
| logDbg("No network score service: Couldnt register as a WiFi score Manager, type=" |
| + Integer.toString(NetworkKey.TYPE_WIFI) |
| + " service " + Context.NETWORK_SCORE_SERVICE); |
| mNetworkScoreCache = null; |
| } |
| } |
| |
| void enableVerboseLogging(int verbose) { |
| if (verbose > 0) { |
| DBG = true; |
| VDBG = true; |
| } else { |
| DBG = false; |
| VDBG = false; |
| } |
| } |
| |
| /** |
| * Flush out scan results older than mScanResultMaximumAge |
| */ |
| private void ageScanResultsOut(int delay) { |
| if (delay <= 0) { |
| delay = mScanResultMaximumAge; // Something sane |
| } |
| long milli = System.currentTimeMillis(); |
| if (VDBG) { |
| logDbg("ageScanResultsOut delay " + Integer.valueOf(delay) + " size " |
| + Integer.valueOf(scanResultCache.size()) + " now " + Long.valueOf(milli)); |
| } |
| |
| Iterator<HashMap.Entry<String, ScanDetail>> iter = scanResultCache.entrySet().iterator(); |
| while (iter.hasNext()) { |
| HashMap.Entry<String, ScanDetail> entry = iter.next(); |
| ScanDetail scanDetail = entry.getValue(); |
| if ((scanDetail.getSeen() + delay) < milli) { |
| iter.remove(); |
| } |
| } |
| } |
| |
| |
| void averageRssiAndRemoveFromCache(ScanResult result) { |
| // Fetch the previous instance for this result |
| ScanDetail sd = scanResultCache.get(result.BSSID); |
| if (sd != null) { |
| ScanResult sr = sd.getScanResult(); |
| if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0 |
| && result.level == 0 |
| && sr.level < -20) { |
| // A 'zero' RSSI reading is most likely a chip problem which returns |
| // an unknown RSSI, hence ignore it |
| result.level = sr.level; |
| } |
| |
| // If there was a previous cache result for this BSSID, average the RSSI values |
| result.averageRssi(sr.level, sr.seen, mScanResultMaximumAge); |
| |
| // Remove the previous Scan Result - this is not necessary |
| scanResultCache.remove(result.BSSID); |
| } else if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0 && result.level == 0) { |
| // A 'zero' RSSI reading is most likely a chip problem which returns |
| // an unknown RSSI, hence initialize it to a sane value |
| result.level = mWifiConfigStore.scanResultRssiLevelPatchUp; |
| } |
| } |
| |
| void addToUnscoredNetworks(ScanResult result, List<NetworkKey> unknownScanResults) { |
| WifiKey wkey; |
| // Quoted SSIDs are the only one valid at this stage |
| try { |
| wkey = new WifiKey("\"" + result.SSID + "\"", result.BSSID); |
| } catch (IllegalArgumentException e) { |
| logDbg("AutoJoinController: received badly encoded SSID=[" + result.SSID + |
| "] ->skipping this network"); |
| wkey = null; |
| } |
| if (wkey != null) { |
| NetworkKey nkey = new NetworkKey(wkey); |
| //if we don't know this scan result then request a score from the scorer |
| unknownScanResults.add(nkey); |
| } |
| if (VDBG) { |
| String cap = ""; |
| if (result.capabilities != null) |
| cap = result.capabilities; |
| logDbg(result.SSID + " " + result.BSSID + " rssi=" |
| + result.level + " cap " + cap + " tsf " + result.timestamp + " is not scored"); |
| } |
| } |
| |
| int addToScanCache(List<ScanDetail> scanList) { |
| int numScanResultsKnown = 0; // Record number of scan results we knew about |
| WifiConfiguration associatedConfig = null; |
| boolean didAssociate = false; |
| long now = System.currentTimeMillis(); |
| |
| ArrayList<NetworkKey> unknownScanResults = new ArrayList<NetworkKey>(); |
| |
| for (ScanDetail scanDetail : scanList) { |
| ScanResult result = scanDetail.getScanResult(); |
| if (result.SSID == null) continue; |
| |
| if (VDBG) { |
| logDbg(" addToScanCache " + result.SSID + " " + result.BSSID |
| + " tsf=" + result.timestamp |
| + " now= " + now + " uptime=" + SystemClock.uptimeMillis() |
| + " elapsed=" + SystemClock.elapsedRealtime()); |
| } |
| |
| // Make sure we record the last time we saw this result |
| scanDetail.setSeen(); |
| |
| averageRssiAndRemoveFromCache(result); |
| |
| if (!mNetworkScoreCache.isScoredNetwork(result)) { |
| addToUnscoredNetworks(result, unknownScanResults); |
| } else { |
| if (VDBG) { |
| String cap = ""; |
| if (result.capabilities != null) |
| cap = result.capabilities; |
| int score = mNetworkScoreCache.getNetworkScore(result); |
| logDbg(result.SSID + " " + result.BSSID + " rssi=" |
| + result.level + " cap " + cap + " is scored : " + score); |
| } |
| } |
| |
| // scanResultCache.put(result.BSSID, new ScanResult(result)); |
| scanResultCache.put(result.BSSID, scanDetail); |
| // Add this BSSID to the scanResultCache of a Saved WifiConfiguration |
| didAssociate = mWifiConfigStore.updateSavedNetworkHistory(scanDetail); |
| |
| // If not successful, try to associate this BSSID to an existing Saved WifiConfiguration |
| if (!didAssociate) { |
| // We couldn't associate the scan result to a Saved WifiConfiguration |
| // Hence it is untrusted |
| result.untrusted = true; |
| } else { |
| // If the scan result has been blacklisted fir 18 hours -> unblacklist |
| if ((now - result.blackListTimestamp) > loseBlackListHardMilli) { |
| result.setAutoJoinStatus(ScanResult.ENABLED); |
| } |
| } |
| if (didAssociate) { |
| numScanResultsKnown++; |
| result.isAutoJoinCandidate++; |
| } else { |
| result.isAutoJoinCandidate = 0; |
| } |
| } |
| |
| if (unknownScanResults.size() != 0) { |
| NetworkKey[] newKeys = |
| unknownScanResults.toArray(new NetworkKey[unknownScanResults.size()]); |
| // Kick the score manager, we will get updated scores asynchronously |
| scoreManager.requestScores(newKeys); |
| } |
| return numScanResultsKnown; |
| } |
| |
| void logDbg(String message) { |
| logDbg(message, false); |
| } |
| |
| void logDbg(String message, boolean stackTrace) { |
| if (stackTrace) { |
| Log.d(TAG, message + " stack:" |
| + Thread.currentThread().getStackTrace()[2].getMethodName() + " - " |
| + Thread.currentThread().getStackTrace()[3].getMethodName() + " - " |
| + Thread.currentThread().getStackTrace()[4].getMethodName() + " - " |
| + Thread.currentThread().getStackTrace()[5].getMethodName()); |
| } else { |
| Log.d(TAG, message); |
| } |
| } |
| |
| // Called directly from WifiStateMachine |
| int newSupplicantResults(boolean doAutoJoin) { |
| int numScanResultsKnown; |
| List<ScanDetail> scanList = mWifiStateMachine.getScanResultsListNoCopyUnsync(); |
| numScanResultsKnown = addToScanCache(scanList); |
| ageScanResultsOut(mScanResultMaximumAge); |
| if (DBG) { |
| logDbg("newSupplicantResults size=" + Integer.valueOf(scanResultCache.size()) |
| + " known=" + numScanResultsKnown + " " |
| + doAutoJoin); |
| } |
| if (doAutoJoin) { |
| attemptAutoJoin(); |
| } |
| mWifiConfigStore.writeKnownNetworkHistory(false); |
| return numScanResultsKnown; |
| } |
| |
| |
| /** |
| * Not used at the moment |
| * should be a call back from WifiScanner HAL ?? |
| * this function is not hooked and working yet, it will receive scan results from WifiScanners |
| * with the list of IEs,then populate the capabilities by parsing the IEs and inject the scan |
| * results as normal. |
| */ |
| void newHalScanResults() { |
| List<ScanDetail> scanList = null;//mWifiScanner.syncGetScanResultsList(); |
| String akm = WifiParser.parse_akm(null, null); |
| logDbg(akm); |
| addToScanCache(scanList); |
| ageScanResultsOut(0); |
| attemptAutoJoin(); |
| mWifiConfigStore.writeKnownNetworkHistory(false); |
| } |
| |
| /** |
| * network link quality changed, called directly from WifiTrafficPoller, |
| * or by listening to Link Quality intent |
| */ |
| void linkQualitySignificantChange() { |
| attemptAutoJoin(); |
| } |
| |
| /** |
| * compare a WifiConfiguration against the current network, return a delta score |
| * If not associated, and the candidate will always be better |
| * For instance if the candidate is a home network versus an unknown public wifi, |
| * the delta will be infinite, else compare Kepler scores etc… |
| * Negatve return values from this functions are meaningless per se, just trying to |
| * keep them distinct for debug purpose (i.e. -1, -2 etc...) |
| */ |
| private int compareNetwork(WifiConfiguration candidate, |
| String lastSelectedConfiguration) { |
| if (candidate == null) |
| return -3; |
| |
| WifiConfiguration currentNetwork = mWifiStateMachine.getCurrentWifiConfiguration(); |
| if (currentNetwork == null) { |
| // Return any absurdly high score, if we are not connected there is no current |
| // network to... |
| return 1000; |
| } |
| |
| if (candidate.configKey(true).equals(currentNetwork.configKey(true))) { |
| return -2; |
| } |
| |
| if (DBG) { |
| logDbg("compareNetwork will compare " + candidate.configKey() |
| + " with current " + currentNetwork.configKey()); |
| } |
| int order = compareWifiConfigurations(currentNetwork, candidate); |
| |
| // The lastSelectedConfiguration is the configuration the user has manually selected |
| // thru WifiPicker, or that a 3rd party app asked us to connect to via the |
| // enableNetwork with disableOthers=true WifiManager API |
| // As this is a direct user choice, we strongly prefer this configuration, |
| // hence give +/-100 |
| if ((lastSelectedConfiguration != null) |
| && currentNetwork.configKey().equals(lastSelectedConfiguration)) { |
| // currentNetwork is the last selected configuration, |
| // so keep it above connect choices (+/-60) and |
| // above RSSI/scorer based selection of linked configuration (+/- 50) |
| // by reducing order by -100 |
| order = order - 100; |
| if (VDBG) { |
| logDbg(" ...and prefers -100 " + currentNetwork.configKey() |
| + " over " + candidate.configKey() |
| + " because it is the last selected -> " |
| + Integer.toString(order)); |
| } |
| } else if ((lastSelectedConfiguration != null) |
| && candidate.configKey().equals(lastSelectedConfiguration)) { |
| // candidate is the last selected configuration, |
| // so keep it above connect choices (+/-60) and |
| // above RSSI/scorer based selection of linked configuration (+/- 50) |
| // by increasing order by +100 |
| order = order + 100; |
| if (VDBG) { |
| logDbg(" ...and prefers +100 " + candidate.configKey() |
| + " over " + currentNetwork.configKey() |
| + " because it is the last selected -> " |
| + Integer.toString(order)); |
| } |
| } |
| |
| return order; |
| } |
| |
| /** |
| * update the network history fields fo that configuration |
| * - if userTriggered, we mark the configuration as "non selfAdded" since the user has seen it |
| * and took over management |
| * - if it is a "connect", remember which network were there at the point of the connect, so |
| * as those networks get a relative lower score than the selected configuration |
| * |
| * @param netId |
| * @param userTriggered : if the update come from WiFiManager |
| * @param connect : if the update includes a connect |
| */ |
| public void updateConfigurationHistory(int netId, boolean userTriggered, boolean connect) { |
| WifiConfiguration selected = mWifiConfigStore.getWifiConfiguration(netId); |
| if (selected == null) { |
| logDbg("updateConfigurationHistory nid=" + netId + " no selected configuration!"); |
| return; |
| } |
| |
| if (selected.SSID == null) { |
| logDbg("updateConfigurationHistory nid=" + netId + |
| " no SSID in selected configuration!"); |
| return; |
| } |
| |
| if (userTriggered) { |
| // Reenable autojoin for this network, |
| // since the user want to connect to this configuration |
| selected.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| selected.selfAdded = false; |
| selected.dirty = true; |
| } |
| |
| if (DBG && userTriggered) { |
| if (selected.connectChoices != null) { |
| logDbg("updateConfigurationHistory will update " |
| + Integer.toString(netId) + " now: " |
| + Integer.toString(selected.connectChoices.size()) |
| + " uid=" + Integer.toString(selected.creatorUid), true); |
| } else { |
| logDbg("updateConfigurationHistory will update " |
| + Integer.toString(netId) |
| + " uid=" + Integer.toString(selected.creatorUid), true); |
| } |
| } |
| |
| if (connect && userTriggered) { |
| boolean found = false; |
| int choice = 0; |
| int size = 0; |
| |
| // Reset the triggered disabled count, because user wanted to connect to this |
| // configuration, and we were not. |
| selected.numUserTriggeredWifiDisableLowRSSI = 0; |
| selected.numUserTriggeredWifiDisableBadRSSI = 0; |
| selected.numUserTriggeredWifiDisableNotHighRSSI = 0; |
| selected.numUserTriggeredJoinAttempts++; |
| |
| List<WifiConfiguration> networks = |
| mWifiConfigStore.getRecentConfiguredNetworks(12000, false); |
| if (networks != null) size = networks.size(); |
| logDbg("updateConfigurationHistory found " + size + " networks"); |
| if (networks != null) { |
| for (WifiConfiguration config : networks) { |
| if (DBG) { |
| logDbg("updateConfigurationHistory got " + config.SSID + " nid=" |
| + Integer.toString(config.networkId)); |
| } |
| |
| if (selected.configKey(true).equals(config.configKey(true))) { |
| found = true; |
| continue; |
| } |
| |
| // If the selection was made while config was visible with reasonably good RSSI |
| // then register the user preference, else ignore |
| if (config.visibility == null || |
| (config.visibility.rssi24 < mWifiConfigStore.thresholdBadRssi24.get() |
| && config.visibility.rssi5 < mWifiConfigStore.thresholdBadRssi5.get()) |
| ) { |
| continue; |
| } |
| |
| choice = MAX_RSSI_DELTA + 10; // Make sure the choice overrides the RSSI diff |
| |
| // The selected configuration was preferred over a recently seen config |
| // hence remember the user's choice: |
| // add the recently seen config to the selected's connectChoices array |
| |
| if (selected.connectChoices == null) { |
| selected.connectChoices = new HashMap<String, Integer>(); |
| } |
| |
| logDbg("updateConfigurationHistory add a choice " + selected.configKey(true) |
| + " over " + config.configKey(true) |
| + " choice " + Integer.toString(choice)); |
| |
| // Add the visible config to the selected's connect choice list |
| selected.connectChoices.put(config.configKey(true), choice); |
| |
| if (config.connectChoices != null) { |
| if (VDBG) { |
| logDbg("updateConfigurationHistory will remove " |
| + selected.configKey(true) + " from " + config.configKey(true)); |
| } |
| // Remove the selected from the recently seen config's connectChoice list |
| config.connectChoices.remove(selected.configKey(true)); |
| |
| if (selected.linkedConfigurations != null) { |
| // Remove the selected's linked configuration from the |
| // recently seen config's connectChoice list |
| for (String key : selected.linkedConfigurations.keySet()) { |
| config.connectChoices.remove(key); |
| } |
| } |
| } |
| } |
| if (found == false) { |
| // We haven't found the configuration that the user just selected in our |
| // scan cache. |
| // In that case we will need a new scan before attempting to connect to this |
| // configuration anyhow and thus we can process the scan results then. |
| logDbg("updateConfigurationHistory try to connect to an old network!! : " |
| + selected.configKey()); |
| } |
| |
| if (selected.connectChoices != null) { |
| if (VDBG) |
| logDbg("updateConfigurationHistory " + Integer.toString(netId) |
| + " now: " + Integer.toString(selected.connectChoices.size())); |
| } |
| } |
| } |
| |
| // TODO: write only if something changed |
| if (userTriggered || connect) { |
| mWifiConfigStore.writeKnownNetworkHistory(false); |
| } |
| } |
| |
| int getConnectChoice(WifiConfiguration source, WifiConfiguration target, boolean strict) { |
| int choice = 0; |
| if (source == null || target == null) { |
| return 0; |
| } |
| |
| if (source.connectChoices != null |
| && source.connectChoices.containsKey(target.configKey(true))) { |
| Integer val = source.connectChoices.get(target.configKey(true)); |
| if (val != null) { |
| choice = val; |
| } |
| } else if (source.linkedConfigurations != null) { |
| for (String key : source.linkedConfigurations.keySet()) { |
| WifiConfiguration config = mWifiConfigStore.getWifiConfiguration(key); |
| if (config != null) { |
| if (config.connectChoices != null) { |
| Integer val = config.connectChoices.get(target.configKey(true)); |
| if (val != null) { |
| choice = val; |
| } |
| } |
| } |
| } |
| } |
| |
| if (!strict && choice == 0) { |
| // We didn't find the connect choice; fallback to some default choices |
| int sourceScore = getSecurityScore(source); |
| int targetScore = getSecurityScore(target); |
| choice = sourceScore - targetScore; |
| } |
| |
| return choice; |
| } |
| |
| int compareWifiConfigurationsFromVisibility(WifiConfiguration.Visibility a, int aRssiBoost, |
| String dbgA, WifiConfiguration.Visibility b, int bRssiBoost, String dbgB) { |
| |
| int aRssiBoost5 = 0; // 5GHz RSSI boost to apply for purpose band selection (5GHz pref) |
| int bRssiBoost5 = 0; // 5GHz RSSI boost to apply for purpose band selection (5GHz pref) |
| |
| int aScore = 0; |
| int bScore = 0; |
| |
| boolean aPrefers5GHz = false; |
| boolean bPrefers5GHz = false; |
| |
| /** |
| * Calculate a boost to apply to RSSI value of configuration we want to join on 5GHz: |
| * Boost RSSI value of 5GHz bands iff the base value is better than threshold, |
| * penalize the RSSI value of 5GHz band iff the base value is lower than threshold |
| * This implements band preference where we prefer 5GHz if RSSI5 is good enough, whereas |
| * we prefer 2.4GHz otherwise. |
| */ |
| aRssiBoost5 = rssiBoostFrom5GHzRssi(a.rssi5, dbgA + "->"); |
| bRssiBoost5 = rssiBoostFrom5GHzRssi(b.rssi5, dbgB + "->"); |
| |
| // Select which band to use for a |
| if (a.rssi5 + aRssiBoost5 > a.rssi24) { |
| // Prefer a's 5GHz |
| aPrefers5GHz = true; |
| } |
| |
| // Select which band to use for b |
| if (b.rssi5 + bRssiBoost5 > b.rssi24) { |
| // Prefer b's 5GHz |
| bPrefers5GHz = true; |
| } |
| |
| if (aPrefers5GHz) { |
| if (bPrefers5GHz) { |
| // If both a and b are on 5GHz then we don't apply the 5GHz RSSI boost to either |
| // one, but directly compare the RSSI values, this improves stability, |
| // since the 5GHz RSSI boost can introduce large fluctuations |
| aScore = a.rssi5 + aRssiBoost; |
| } else { |
| // If only a is on 5GHz, then apply the 5GHz preference boost to a |
| aScore = a.rssi5 + aRssiBoost + aRssiBoost5; |
| } |
| } else { |
| aScore = a.rssi24 + aRssiBoost; |
| } |
| |
| if (bPrefers5GHz) { |
| if (aPrefers5GHz) { |
| // If both a and b are on 5GHz then we don't apply the 5GHz RSSI boost to either |
| // one, but directly compare the RSSI values, this improves stability, |
| // since the 5GHz RSSI boost can introduce large fluctuations |
| bScore = b.rssi5 + bRssiBoost; |
| } else { |
| // If only b is on 5GHz, then apply the 5GHz preference boost to b |
| bScore = b.rssi5 + bRssiBoost + bRssiBoost5; |
| } |
| } else { |
| bScore = b.rssi24 + bRssiBoost; |
| } |
| |
| if (VDBG) { |
| logDbg(" " + dbgA + " is5=" + aPrefers5GHz + " score=" + aScore |
| + " " + dbgB + " is5=" + bPrefers5GHz + " score=" + bScore); |
| } |
| |
| // Debug only, record RSSI comparison parameters |
| if (a != null) { |
| a.score = aScore; |
| a.currentNetworkBoost = aRssiBoost; |
| a.bandPreferenceBoost = aRssiBoost5; |
| } |
| if (b != null) { |
| b.score = bScore; |
| b.currentNetworkBoost = bRssiBoost; |
| b.bandPreferenceBoost = bRssiBoost5; |
| } |
| |
| // Compare a and b |
| // If a score is higher then a > b and the order is descending (negative) |
| // If b score is higher then a < b and the order is ascending (positive) |
| return bScore - aScore; |
| } |
| |
| // Compare WifiConfiguration by RSSI, and return a comparison value in the range [-50, +50] |
| // The result represents "approximately" an RSSI difference measured in dBM |
| // Adjusted with various parameters: |
| // +) current network gets a +15 boost |
| // +) 5GHz signal, if they are strong enough, get a +15 or +25 boost, representing the |
| // fact that at short range we prefer 5GHz band as it is cleaner of interference and |
| // provides for wider channels |
| int compareWifiConfigurationsRSSI(WifiConfiguration a, WifiConfiguration b, |
| String currentConfiguration) { |
| int order = 0; |
| |
| // Boost used so as to favor current config |
| int aRssiBoost = 0; |
| int bRssiBoost = 0; |
| |
| // Retrieve the visibility |
| WifiConfiguration.Visibility astatus = a.visibility; |
| WifiConfiguration.Visibility bstatus = b.visibility; |
| if (astatus == null || bstatus == null) { |
| // Error visibility wasn't set |
| logDbg(" compareWifiConfigurations NULL band status!"); |
| return 0; |
| } |
| |
| // Apply Hysteresis, boost RSSI of current configuration |
| if (null != currentConfiguration) { |
| if (a.configKey().equals(currentConfiguration)) { |
| aRssiBoost = mWifiConfigStore.currentNetworkBoost; |
| } else if (b.configKey().equals(currentConfiguration)) { |
| bRssiBoost = mWifiConfigStore.currentNetworkBoost; |
| } |
| } |
| |
| if (VDBG) { |
| logDbg(" compareWifiConfigurationsRSSI: " + a.configKey() |
| + " rssi=" + Integer.toString(astatus.rssi24) |
| + "," + Integer.toString(astatus.rssi5) |
| + " boost=" + Integer.toString(aRssiBoost) |
| + " " + b.configKey() + " rssi=" |
| + Integer.toString(bstatus.rssi24) + "," |
| + Integer.toString(bstatus.rssi5) |
| + " boost=" + Integer.toString(bRssiBoost) |
| ); |
| } |
| |
| order = compareWifiConfigurationsFromVisibility( |
| a.visibility, aRssiBoost, a.configKey(), |
| b.visibility, bRssiBoost, b.configKey()); |
| |
| // Normalize the order to [-50, +50] = [ -MAX_RSSI_DELTA, MAX_RSSI_DELTA] |
| if (order > MAX_RSSI_DELTA) order = MAX_RSSI_DELTA; |
| else if (order < -MAX_RSSI_DELTA) order = -MAX_RSSI_DELTA; |
| |
| if (VDBG) { |
| String prefer = " = "; |
| if (order > 0) { |
| prefer = " < "; // Ascending |
| } else if (order < 0) { |
| prefer = " > "; // Descending |
| } |
| logDbg(" compareWifiConfigurationsRSSI " + a.configKey() |
| + " rssi=(" + a.visibility.rssi24 |
| + "," + a.visibility.rssi5 |
| + ") num=(" + a.visibility.num24 |
| + "," + a.visibility.num5 + ")" |
| + prefer + b.configKey() |
| + " rssi=(" + b.visibility.rssi24 |
| + "," + b.visibility.rssi5 |
| + ") num=(" + b.visibility.num24 |
| + "," + b.visibility.num5 + ")" |
| + " -> " + order); |
| } |
| |
| return order; |
| } |
| |
| /** |
| * b/18490330 only use scorer for untrusted networks |
| * <p/> |
| * int compareWifiConfigurationsWithScorer(WifiConfiguration a, WifiConfiguration b) { |
| * <p/> |
| * boolean aIsActive = false; |
| * boolean bIsActive = false; |
| * <p/> |
| * // Apply Hysteresis : boost RSSI of current configuration before |
| * // looking up the score |
| * if (null != mCurrentConfigurationKey) { |
| * if (a.configKey().equals(mCurrentConfigurationKey)) { |
| * aIsActive = true; |
| * } else if (b.configKey().equals(mCurrentConfigurationKey)) { |
| * bIsActive = true; |
| * } |
| * } |
| * int scoreA = getConfigNetworkScore(a, mScanResultAutoJoinAge, aIsActive); |
| * int scoreB = getConfigNetworkScore(b, mScanResultAutoJoinAge, bIsActive); |
| * <p/> |
| * // Both configurations need to have a score for the scorer to be used |
| * // ...and the scores need to be different:-) |
| * if (scoreA == WifiNetworkScoreCache.INVALID_NETWORK_SCORE |
| * || scoreB == WifiNetworkScoreCache.INVALID_NETWORK_SCORE) { |
| * if (VDBG) { |
| * logDbg(" compareWifiConfigurationsWithScorer no-scores: " |
| * + a.configKey() |
| * + " " |
| * + b.configKey()); |
| * } |
| * return 0; |
| * } |
| * <p/> |
| * if (VDBG) { |
| * String prefer = " = "; |
| * if (scoreA < scoreB) { |
| * prefer = " < "; |
| * } if (scoreA > scoreB) { |
| * prefer = " > "; |
| * } |
| * logDbg(" compareWifiConfigurationsWithScorer " + a.configKey() |
| * + " rssi=(" + a.visibility.rssi24 |
| * + "," + a.visibility.rssi5 |
| * + ") num=(" + a.visibility.num24 |
| * + "," + a.visibility.num5 + ")" |
| * + " sc=" + scoreA |
| * + prefer + b.configKey() |
| * + " rssi=(" + b.visibility.rssi24 |
| * + "," + b.visibility.rssi5 |
| * + ") num=(" + b.visibility.num24 |
| * + "," + b.visibility.num5 + ")" |
| * + " sc=" + scoreB |
| * + " -> " + Integer.toString(scoreB - scoreA)); |
| * } |
| * <p/> |
| * // If scoreA > scoreB, the comparison is descending hence the return value is negative |
| * return scoreB - scoreA; |
| * } |
| */ |
| |
| int getSecurityScore(WifiConfiguration config) { |
| |
| if (TextUtils.isEmpty(config.SSID) == false) { |
| if (config.allowedKeyManagement.get(KeyMgmt.WPA_EAP) |
| || config.allowedKeyManagement.get(KeyMgmt.WPA_PSK) |
| || config.allowedKeyManagement.get(KeyMgmt.WPA2_PSK)) { |
| /* enterprise or PSK networks get highest score */ |
| return 100; |
| } else if (config.allowedKeyManagement.get(KeyMgmt.NONE)) { |
| /* open networks have lowest score */ |
| return 33; |
| } |
| } else if (TextUtils.isEmpty(config.FQDN) == false) { |
| /* passpoint networks have medium preference */ |
| return 66; |
| } |
| |
| /* bad network */ |
| return 0; |
| } |
| |
| int compareWifiConfigurations(WifiConfiguration a, WifiConfiguration b) { |
| int order = 0; |
| boolean linked = false; |
| |
| if ((a.linkedConfigurations != null) && (b.linkedConfigurations != null) |
| && (a.autoJoinStatus == WifiConfiguration.AUTO_JOIN_ENABLED) |
| && (b.autoJoinStatus == WifiConfiguration.AUTO_JOIN_ENABLED)) { |
| if ((a.linkedConfigurations.get(b.configKey(true)) != null) |
| && (b.linkedConfigurations.get(a.configKey(true)) != null)) { |
| linked = true; |
| } |
| } |
| |
| if (a.ephemeral && b.ephemeral == false) { |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations ephemeral and prefers " + b.configKey() |
| + " over " + a.configKey()); |
| } |
| return 1; // b is of higher priority - ascending |
| } |
| if (b.ephemeral && a.ephemeral == false) { |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations ephemeral and prefers " + a.configKey() |
| + " over " + b.configKey()); |
| } |
| return -1; // a is of higher priority - descending |
| } |
| |
| // Apply RSSI, in the range [-5, +5] |
| // after band adjustment, +n difference roughly corresponds to +10xn dBm |
| order = order + compareWifiConfigurationsRSSI(a, b, mCurrentConfigurationKey); |
| |
| // If the configurations are not linked, compare by user's choice, only a |
| // very high RSSI difference can then override the choice |
| if (!linked) { |
| int choice; |
| |
| choice = getConnectChoice(a, b, false); |
| if (choice > 0) { |
| // a is of higher priority - descending |
| order = order - choice; |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations prefers " + a.configKey() |
| + " over " + b.configKey() |
| + " due to user choice of " + choice |
| + " order -> " + Integer.toString(order)); |
| } |
| if (a.visibility != null) { |
| a.visibility.lastChoiceBoost = choice; |
| a.visibility.lastChoiceConfig = b.configKey(); |
| } |
| } |
| |
| choice = getConnectChoice(b, a, false); |
| if (choice > 0) { |
| // a is of lower priority - ascending |
| order = order + choice; |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations prefers " + b.configKey() + " over " |
| + a.configKey() + " due to user choice of " + choice |
| + " order ->" + Integer.toString(order)); |
| } |
| if (b.visibility != null) { |
| b.visibility.lastChoiceBoost = choice; |
| b.visibility.lastChoiceConfig = a.configKey(); |
| } |
| } |
| } |
| |
| if (order == 0) { |
| // We don't know anything - pick the last seen i.e. K behavior |
| // we should do this only for recently picked configurations |
| if (a.priority > b.priority) { |
| // a is of higher priority - descending |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations prefers -1 " + a.configKey() + " over " |
| + b.configKey() + " due to priority"); |
| } |
| |
| order = -1; |
| } else if (a.priority < b.priority) { |
| // a is of lower priority - ascending |
| if (VDBG) { |
| logDbg(" compareWifiConfigurations prefers +1 " + b.configKey() + " over " |
| + a.configKey() + " due to priority"); |
| } |
| order = 1; |
| } |
| } |
| |
| String sorder = " == "; |
| if (order > 0) { |
| sorder = " < "; |
| } else if (order < 0) { |
| sorder = " > "; |
| } |
| |
| if (VDBG) { |
| logDbg("compareWifiConfigurations: " + a.configKey() + sorder |
| + b.configKey() + " order " + Integer.toString(order)); |
| } |
| |
| return order; |
| } |
| |
| boolean isBadCandidate(int rssi5, int rssi24) { |
| return (rssi5 < -80 && rssi24 < -90); |
| } |
| |
| /* |
| int compareWifiConfigurationsTop(WifiConfiguration a, WifiConfiguration b) { |
| int scorerOrder = compareWifiConfigurationsWithScorer(a, b); |
| int order = compareWifiConfigurations(a, b); |
| |
| if (scorerOrder * order < 0) { |
| if (VDBG) { |
| logDbg(" -> compareWifiConfigurationsTop: " + |
| "scorer override " + scorerOrder + " " + order); |
| } |
| // For debugging purpose, remember that an override happened |
| // during that autojoin Attempt |
| didOverride = true; |
| a.numScorerOverride++; |
| b.numScorerOverride++; |
| } |
| |
| if (scorerOrder != 0) { |
| // If the scorer came up with a result then use the scorer's result, else use |
| // the order provided by the base comparison function |
| order = scorerOrder; |
| } |
| return order; |
| } |
| */ |
| |
| public int rssiBoostFrom5GHzRssi(int rssi, String dbg) { |
| if (!mWifiConfigStore.enable5GHzPreference) { |
| return 0; |
| } |
| if (rssi |
| > mWifiConfigStore.bandPreferenceBoostThreshold5.get()) { |
| // Boost by 2 dB for each point |
| // Start boosting at -65 |
| // Boost by 20 if above -55 |
| // Boost by 40 if abore -45 |
| int boost = mWifiConfigStore.bandPreferenceBoostFactor5 |
| * (rssi - mWifiConfigStore.bandPreferenceBoostThreshold5.get()); |
| if (boost > 50) { |
| // 50 dB boost allows jumping from 2.4 to 5GHz |
| // consistently |
| boost = 50; |
| } |
| if (VDBG && dbg != null) { |
| logDbg(" " + dbg + ": rssi5 " + rssi + " 5GHz-boost " + boost); |
| } |
| return boost; |
| } |
| |
| if (rssi |
| < mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) { |
| // penalize if < -75 |
| int boost = mWifiConfigStore.bandPreferencePenaltyFactor5 |
| * (rssi - mWifiConfigStore.bandPreferencePenaltyThreshold5.get()); |
| return boost; |
| } |
| return 0; |
| } |
| |
| /** |
| * attemptRoam() function implements the core of the same SSID switching algorithm |
| * <p/> |
| * Run thru all recent scan result of a WifiConfiguration and select the |
| * best one. |
| */ |
| public ScanResult attemptRoam(ScanResult a, |
| WifiConfiguration current, int age, String currentBSSID) { |
| if (current == null) { |
| if (VDBG) { |
| logDbg("attemptRoam not associated"); |
| } |
| return a; |
| } |
| |
| ScanDetailCache scanDetailCache = |
| mWifiConfigStore.getScanDetailCache(current); |
| |
| if (scanDetailCache == null) { |
| if (VDBG) { |
| logDbg("attemptRoam no scan cache"); |
| } |
| return a; |
| } |
| if (scanDetailCache.size() > 6) { |
| if (VDBG) { |
| logDbg("attemptRoam scan cache size " |
| + scanDetailCache.size() + " --> bail"); |
| } |
| // Implement same SSID roaming only for configurations |
| // that have less than 4 BSSIDs |
| return a; |
| } |
| |
| if (current.BSSID != null && !current.BSSID.equals("any")) { |
| if (DBG) { |
| logDbg("attemptRoam() BSSID is set " |
| + current.BSSID + " -> bail"); |
| } |
| return a; |
| } |
| |
| // Determine which BSSID we want to associate to, taking account |
| // relative strength of 5 and 2.4 GHz BSSIDs |
| long nowMs = System.currentTimeMillis(); |
| |
| for (ScanDetail sd : scanDetailCache.values()) { |
| ScanResult b = sd.getScanResult(); |
| int bRssiBoost5 = 0; |
| int aRssiBoost5 = 0; |
| int bRssiBoost = 0; |
| int aRssiBoost = 0; |
| if ((sd.getSeen() == 0) || (b.BSSID == null) |
| || ((nowMs - sd.getSeen()) > age) |
| || b.autoJoinStatus != ScanResult.ENABLED |
| || b.numIpConfigFailures > 8) { |
| continue; |
| } |
| |
| // Pick first one |
| if (a == null) { |
| a = b; |
| continue; |
| } |
| |
| if (b.numIpConfigFailures < (a.numIpConfigFailures - 1)) { |
| // Prefer a BSSID that doesn't have less number of Ip config failures |
| logDbg("attemptRoam: " |
| + b.BSSID + " rssi=" + b.level + " ipfail=" + b.numIpConfigFailures |
| + " freq=" + b.frequency |
| + " > " |
| + a.BSSID + " rssi=" + a.level + " ipfail=" + a.numIpConfigFailures |
| + " freq=" + a.frequency); |
| a = b; |
| continue; |
| } |
| |
| // Apply hysteresis: we favor the currentBSSID by giving it a boost |
| if (currentBSSID != null && currentBSSID.equals(b.BSSID)) { |
| // Reduce the benefit of hysteresis if RSSI <= -75 |
| if (b.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) { |
| bRssiBoost = mWifiConfigStore.associatedHysteresisLow; |
| } else { |
| bRssiBoost = mWifiConfigStore.associatedHysteresisHigh; |
| } |
| } |
| if (currentBSSID != null && currentBSSID.equals(a.BSSID)) { |
| if (a.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) { |
| // Reduce the benefit of hysteresis if RSSI <= -75 |
| aRssiBoost = mWifiConfigStore.associatedHysteresisLow; |
| } else { |
| aRssiBoost = mWifiConfigStore.associatedHysteresisHigh; |
| } |
| } |
| |
| // Favor 5GHz: give a boost to 5GHz BSSIDs, with a slightly progressive curve |
| // Boost the BSSID if it is on 5GHz, above a threshold |
| // But penalize it if it is on 5GHz and below threshold |
| // |
| // With he current threshold values, 5GHz network with RSSI above -55 |
| // Are given a boost of 30DB which is enough to overcome the current BSSID |
| // hysteresis (+14) plus 2.4/5 GHz signal strength difference on most cases |
| // |
| // The "current BSSID" Boost must be added to the BSSID's level so as to introduce\ |
| // soem amount of hysteresis |
| if (b.is5GHz()) { |
| bRssiBoost5 = rssiBoostFrom5GHzRssi(b.level + bRssiBoost, b.BSSID); |
| } |
| if (a.is5GHz()) { |
| aRssiBoost5 = rssiBoostFrom5GHzRssi(a.level + aRssiBoost, a.BSSID); |
| } |
| |
| if (VDBG) { |
| String comp = " < "; |
| if (b.level + bRssiBoost + bRssiBoost5 > a.level + aRssiBoost + aRssiBoost5) { |
| comp = " > "; |
| } |
| logDbg("attemptRoam: " |
| + b.BSSID + " rssi=" + b.level + " boost=" + Integer.toString(bRssiBoost) |
| + "/" + Integer.toString(bRssiBoost5) + " freq=" + b.frequency |
| + comp |
| + a.BSSID + " rssi=" + a.level + " boost=" + Integer.toString(aRssiBoost) |
| + "/" + Integer.toString(aRssiBoost5) + " freq=" + a.frequency); |
| } |
| |
| // Compare the RSSIs after applying the hysteresis boost and the 5GHz |
| // boost if applicable |
| if (b.level + bRssiBoost + bRssiBoost5 > a.level + aRssiBoost + aRssiBoost5) { |
| // b is the better BSSID |
| a = b; |
| } |
| } |
| if (a != null) { |
| if (VDBG) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("attemptRoam: " + current.configKey() + |
| " Found " + a.BSSID + " rssi=" + a.level + " freq=" + a.frequency); |
| if (currentBSSID != null) { |
| sb.append(" Current: " + currentBSSID); |
| } |
| sb.append("\n"); |
| logDbg(sb.toString()); |
| } |
| } |
| return a; |
| } |
| |
| /** |
| * getNetworkScore() |
| * <p/> |
| * if scorer is present, get the network score of a WifiConfiguration |
| * <p/> |
| * Note: this should be merge with setVisibility |
| * |
| * @param config |
| * @return score |
| */ |
| int getConfigNetworkScore(WifiConfiguration config, int age, boolean isActive) { |
| |
| if (mNetworkScoreCache == null) { |
| if (VDBG) { |
| logDbg(" getConfigNetworkScore for " + config.configKey() |
| + " -> no scorer, hence no scores"); |
| } |
| return WifiNetworkScoreCache.INVALID_NETWORK_SCORE; |
| } |
| |
| if (mWifiConfigStore.getScanDetailCache(config) == null) { |
| if (VDBG) { |
| logDbg(" getConfigNetworkScore for " + config.configKey() |
| + " -> no scan cache"); |
| } |
| return WifiNetworkScoreCache.INVALID_NETWORK_SCORE; |
| } |
| |
| // Get current date |
| long nowMs = System.currentTimeMillis(); |
| |
| int startScore = -10000; |
| |
| // Run thru all cached scan results |
| for (ScanDetail sd : mWifiConfigStore.getScanDetailCache(config).values()) { |
| ScanResult result = sd.getScanResult(); |
| if ((nowMs - sd.getSeen()) < age) { |
| int sc = mNetworkScoreCache.getNetworkScore(result, isActive); |
| if (sc > startScore) { |
| startScore = sc; |
| } |
| } |
| } |
| if (startScore == -10000) { |
| startScore = WifiNetworkScoreCache.INVALID_NETWORK_SCORE; |
| } |
| if (VDBG) { |
| if (startScore == WifiNetworkScoreCache.INVALID_NETWORK_SCORE) { |
| logDbg(" getConfigNetworkScore for " + config.configKey() |
| + " -> no available score"); |
| } else { |
| logDbg(" getConfigNetworkScore for " + config.configKey() |
| + " isActive=" + isActive |
| + " score = " + Integer.toString(startScore)); |
| } |
| } |
| |
| return startScore; |
| } |
| |
| /** |
| * Set whether connections to untrusted connections are allowed. |
| */ |
| void setAllowUntrustedConnections(boolean allow) { |
| boolean changed = mAllowUntrustedConnections != allow; |
| mAllowUntrustedConnections = allow; |
| if (changed) { |
| // Trigger a scan so as to reattempt autojoin |
| mWifiStateMachine.startScanForUntrustedSettingChange(); |
| } |
| } |
| |
| private boolean isOpenNetwork(ScanResult result) { |
| return !result.capabilities.contains("WEP") && |
| !result.capabilities.contains("PSK") && |
| !result.capabilities.contains("EAP"); |
| } |
| |
| private boolean haveRecentlySeenScoredBssid(WifiConfiguration config) { |
| long ephemeralOutOfRangeTimeoutMs = Settings.Global.getLong( |
| mContext.getContentResolver(), |
| Settings.Global.WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS, |
| DEFAULT_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS); |
| |
| // Check whether the currently selected network has a score curve. If |
| // ephemeralOutOfRangeTimeoutMs is <= 0, then this is all we check, and we stop here. |
| // Otherwise, we stop here if the currently selected network has a score. If it doesn't, we |
| // keep going - it could be that another BSSID is in range (has been seen recently) which |
| // has a score, even if the one we're immediately connected to doesn't. |
| ScanResult currentScanResult = mWifiStateMachine.getCurrentScanResult(); |
| boolean currentNetworkHasScoreCurve = currentScanResult != null |
| && mNetworkScoreCache.hasScoreCurve(currentScanResult); |
| if (ephemeralOutOfRangeTimeoutMs <= 0 || currentNetworkHasScoreCurve) { |
| if (DBG) { |
| if (currentNetworkHasScoreCurve) { |
| logDbg("Current network has a score curve, keeping network: " |
| + currentScanResult); |
| } else { |
| logDbg("Current network has no score curve, giving up: " + config.SSID); |
| } |
| } |
| return currentNetworkHasScoreCurve; |
| } |
| |
| if (mWifiConfigStore.getScanDetailCache(config) == null |
| || mWifiConfigStore.getScanDetailCache(config).isEmpty()) { |
| return false; |
| } |
| |
| long currentTimeMs = System.currentTimeMillis(); |
| for (ScanDetail sd : mWifiConfigStore.getScanDetailCache(config).values()) { |
| ScanResult result = sd.getScanResult(); |
| if (currentTimeMs > sd.getSeen() |
| && currentTimeMs - sd.getSeen() < ephemeralOutOfRangeTimeoutMs |
| && mNetworkScoreCache.hasScoreCurve(result)) { |
| if (DBG) { |
| logDbg("Found scored BSSID, keeping network: " + result.BSSID); |
| } |
| return true; |
| } |
| } |
| |
| if (DBG) { |
| logDbg("No recently scored BSSID found, giving up connection: " + config.SSID); |
| } |
| return false; |
| } |
| |
| // After WifiStateMachine ask the supplicant to associate or reconnect |
| // we might still obtain scan results from supplicant |
| // however the supplicant state in the mWifiInfo and supplicant state tracker |
| // are updated when we get the supplicant state change message which can be |
| // processed after the SCAN_RESULT message, so at this point the framework doesn't |
| // know that supplicant is ASSOCIATING. |
| // A good fix for this race condition would be for the WifiStateMachine to add |
| // a new transient state where it expects to get the supplicant message indicating |
| // that it started the association process and within which critical operations |
| // like autojoin should be deleted. |
| |
| // This transient state would remove the need for the roam Wathchdog which |
| // basically does that. |
| |
| // At the moment, we just query the supplicant state synchronously with the |
| // mWifiNative.status() command, which allow us to know that |
| // supplicant has started association process, even though we didnt yet get the |
| // SUPPLICANT_STATE_CHANGE message. |
| |
| private static final List<String> ASSOC_STATES = Arrays.asList( |
| "ASSOCIATING", |
| "ASSOCIATED", |
| "FOUR_WAY_HANDSHAKE", |
| "GROUP_KEY_HANDSHAKE"); |
| |
| private int getNetID(String wpaStatus) { |
| if (VDBG) { |
| logDbg("attemptAutoJoin() status=" + wpaStatus); |
| } |
| |
| try { |
| int id = WifiConfiguration.INVALID_NETWORK_ID; |
| String state = null; |
| BufferedReader br = new BufferedReader(new StringReader(wpaStatus)); |
| String line; |
| while ((line = br.readLine()) != null) { |
| int split = line.indexOf('='); |
| if (split < 0) { |
| continue; |
| } |
| |
| String name = line.substring(0, split); |
| if (name.equals("id")) { |
| try { |
| id = Integer.parseInt(line.substring(split + 1)); |
| if (state != null) { |
| break; |
| } |
| } catch (NumberFormatException nfe) { |
| return WifiConfiguration.INVALID_NETWORK_ID; |
| } |
| } else if (name.equals("wpa_state")) { |
| state = line.substring(split + 1); |
| if (ASSOC_STATES.contains(state)) { |
| return WifiConfiguration.INVALID_NETWORK_ID; |
| } else if (id >= 0) { |
| break; |
| } |
| } |
| } |
| return id; |
| } catch (IOException ioe) { |
| return WifiConfiguration.INVALID_NETWORK_ID; // Won't happen |
| } |
| } |
| |
| private boolean setCurrentConfigurationKey(WifiConfiguration currentConfig, |
| int supplicantNetId) { |
| if (currentConfig != null) { |
| if (supplicantNetId != currentConfig.networkId |
| // https://b.corp.google.com/issue?id=16484607 |
| // mark this condition as an error only if the mismatched networkId are valid |
| && supplicantNetId != WifiConfiguration.INVALID_NETWORK_ID |
| && currentConfig.networkId != WifiConfiguration.INVALID_NETWORK_ID) { |
| logDbg("attemptAutoJoin() ERROR wpa_supplicant out of sync nid=" |
| + Integer.toString(supplicantNetId) + " WifiStateMachine=" |
| + Integer.toString(currentConfig.networkId)); |
| mWifiStateMachine.disconnectCommand(); |
| return false; |
| } else if (currentConfig.ephemeral && (!mAllowUntrustedConnections || |
| !haveRecentlySeenScoredBssid(currentConfig))) { |
| // The current connection is untrusted (the framework added it), but we're either |
| // no longer allowed to connect to such networks, the score has been nullified |
| // since we connected, or the scored BSSID has gone out of range. |
| // Drop the current connection and perform the rest of autojoin. |
| logDbg("attemptAutoJoin() disconnecting from unwanted ephemeral network"); |
| mWifiStateMachine.disconnectCommand(Process.WIFI_UID, |
| mAllowUntrustedConnections ? 1 : 0); |
| return false; |
| } else { |
| mCurrentConfigurationKey = currentConfig.configKey(); |
| return true; |
| } |
| } else { |
| // If not invalid, then maybe in the process of associating, skip this attempt |
| return supplicantNetId == WifiConfiguration.INVALID_NETWORK_ID; |
| } |
| } |
| |
| private void updateBlackListStatus(WifiConfiguration config, long now) { |
| // Wait for 5 minutes before reenabling config that have known, |
| // repeated connection or DHCP failures |
| if (config.disableReason == WifiConfiguration.DISABLED_DHCP_FAILURE |
| || config.disableReason |
| == WifiConfiguration.DISABLED_ASSOCIATION_REJECT |
| || config.disableReason |
| == WifiConfiguration.DISABLED_AUTH_FAILURE) { |
| if (config.blackListTimestamp == 0 |
| || (config.blackListTimestamp > now)) { |
| // Sanitize the timestamp |
| config.blackListTimestamp = now; |
| } |
| if ((now - config.blackListTimestamp) > |
| mWifiConfigStore.wifiConfigBlacklistMinTimeMilli) { |
| // Re-enable the WifiConfiguration |
| config.status = WifiConfiguration.Status.ENABLED; |
| |
| // Reset the blacklist condition |
| config.numConnectionFailures = 0; |
| config.numIpConfigFailures = 0; |
| config.numAuthFailures = 0; |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| |
| config.dirty = true; |
| } else { |
| if (VDBG) { |
| long delay = mWifiConfigStore.wifiConfigBlacklistMinTimeMilli |
| - (now - config.blackListTimestamp); |
| logDbg("attemptautoJoin " + config.configKey() |
| + " dont unblacklist yet, waiting for " |
| + delay + " ms"); |
| } |
| } |
| } |
| // Avoid networks disabled because of AUTH failure altogether |
| if (DBG) { |
| logDbg("attemptAutoJoin skip candidate due to auto join status " |
| + Integer.toString(config.autoJoinStatus) + " key " |
| + config.configKey(true) |
| + " reason " + config.disableReason); |
| } |
| } |
| |
| boolean underSoftThreshold(WifiConfiguration config) { |
| return config.visibility.rssi24 < mWifiConfigStore.thresholdUnblacklistThreshold24Soft.get() |
| && config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Soft.get(); |
| } |
| |
| boolean underHardThreshold(WifiConfiguration config) { |
| return config.visibility.rssi24 < mWifiConfigStore.thresholdUnblacklistThreshold24Hard.get() |
| && config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Hard.get(); |
| } |
| |
| boolean underThreshold(WifiConfiguration config, int rssi24, int rssi5) { |
| return config.visibility.rssi24 < rssi24 && config.visibility.rssi5 < rssi5; |
| } |
| |
| /** |
| * attemptAutoJoin() function implements the core of the a network switching algorithm |
| * Return false if no acceptable networks were found. |
| */ |
| boolean attemptAutoJoin() { |
| boolean found = false; |
| didOverride = false; |
| didBailDueToWeakRssi = false; |
| int networkSwitchType = AUTO_JOIN_IDLE; |
| int age = mScanResultAutoJoinAge; |
| |
| long now = System.currentTimeMillis(); |
| |
| String lastSelectedConfiguration = mWifiConfigStore.getLastSelectedConfiguration(); |
| if (lastSelectedConfiguration != null) { |
| age = 14000; |
| } |
| // Reset the currentConfiguration Key, and set it only if WifiStateMachine and |
| // supplicant agree |
| mCurrentConfigurationKey = null; |
| WifiConfiguration currentConfiguration = mWifiStateMachine.getCurrentWifiConfiguration(); |
| |
| WifiConfiguration candidate = null; |
| // Obtain the subset of recently seen networks |
| List<WifiConfiguration> list = |
| mWifiConfigStore.getRecentConfiguredNetworks(age, false); |
| if (list == null) { |
| if (VDBG) logDbg("attemptAutoJoin nothing known=" + |
| mWifiConfigStore.getConfiguredNetworksSize()); |
| return false; |
| } |
| |
| // Find the currently connected network: ask the supplicant directly |
| int supplicantNetId = getNetID(mWifiNative.status(true)); |
| |
| if (DBG) { |
| String conf = ""; |
| String last = ""; |
| if (currentConfiguration != null) { |
| conf = " current=" + currentConfiguration.configKey(); |
| } |
| if (lastSelectedConfiguration != null) { |
| last = " last=" + lastSelectedConfiguration; |
| } |
| logDbg("attemptAutoJoin() num recent config " + Integer.toString(list.size()) |
| + conf + last |
| + " ---> suppNetId=" + Integer.toString(supplicantNetId)); |
| } |
| |
| if (!setCurrentConfigurationKey(currentConfiguration, supplicantNetId)) { |
| return false; |
| } |
| |
| int currentNetId = -1; |
| if (currentConfiguration != null) { |
| // If we are associated to a configuration, it will |
| // be compared thru the compareNetwork function |
| currentNetId = currentConfiguration.networkId; |
| } |
| |
| /** |
| * Run thru all visible configurations without looking at the one we |
| * are currently associated to |
| * select Best Network candidate from known WifiConfigurations |
| */ |
| for (WifiConfiguration config : list) { |
| if (config.SSID == null) { |
| continue; |
| } |
| |
| if (config.autoJoinStatus >= WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE) { |
| updateBlackListStatus(config, now); |
| continue; |
| } |
| |
| if (config.userApproved == WifiConfiguration.USER_PENDING || |
| config.userApproved == WifiConfiguration.USER_BANNED) { |
| if (DBG) { |
| logDbg("attemptAutoJoin skip candidate due to user approval status " |
| + WifiConfiguration.userApprovedAsString(config.userApproved) + " key " |
| + config.configKey(true)); |
| } |
| continue; |
| } |
| |
| // Try to un-blacklist based on elapsed time |
| if (config.blackListTimestamp > 0) { |
| if (now < config.blackListTimestamp) { |
| /** |
| * looks like there was a change in the system clock since we black listed, and |
| * timestamp is not meaningful anymore, hence lose it. |
| * this event should be rare enough so that we still want to lose the black list |
| */ |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| } else { |
| if ((now - config.blackListTimestamp) > loseBlackListHardMilli) { |
| // Reenable it after 18 hours, i.e. next day |
| config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED); |
| } else if ((now - config.blackListTimestamp) > loseBlackListSoftMilli) { |
| // Lose blacklisting due to bad link |
| config.setAutoJoinStatus(config.autoJoinStatus - 8); |
| } |
| } |
| } |
| |
| if (config.visibility == null) { |
| continue; |
| } |
| |
| // Try to unblacklist based on good visibility |
| if (underSoftThreshold(config)) { |
| if (DBG) { |
| logDbg("attemptAutoJoin do not unblacklist due to low visibility " + |
| config.configKey() + " status=" + config.autoJoinStatus); |
| } |
| } else if (underHardThreshold(config)) { |
| // If the network is simply temporary disabled, don't allow reconnect until |
| // RSSI becomes good enough |
| config.setAutoJoinStatus(config.autoJoinStatus - 1); |
| if (DBG) { |
| logDbg("attemptAutoJoin good candidate seen, bumped soft -> status=" + |
| config.configKey() + " status=" + config.autoJoinStatus); |
| } |
| } else { |
| config.setAutoJoinStatus(config.autoJoinStatus - 3); |
| if (DBG) { |
| logDbg("attemptAutoJoin good candidate seen, bumped hard -> status=" + |
| config.configKey() + " status=" + config.autoJoinStatus); |
| } |
| } |
| |
| if (config.autoJoinStatus >= |
| WifiConfiguration.AUTO_JOIN_TEMPORARY_DISABLED) { |
| // Network is blacklisted, skip |
| if (DBG) { |
| logDbg("attemptAutoJoin skip blacklisted -> status=" + |
| config.configKey() + " status=" + config.autoJoinStatus); |
| } |
| continue; |
| } |
| if (config.networkId == currentNetId) { |
| if (DBG) { |
| logDbg("attemptAutoJoin skip current candidate " |
| + Integer.toString(currentNetId) |
| + " key " + config.configKey(true)); |
| } |
| continue; |
| } |
| |
| boolean isLastSelected = false; |
| if (lastSelectedConfiguration != null && |
| config.configKey().equals(lastSelectedConfiguration)) { |
| isLastSelected = true; |
| } |
| |
| if (config.lastRoamingFailure != 0 |
| && currentConfiguration != null |
| && (lastSelectedConfiguration == null |
| || !config.configKey().equals(lastSelectedConfiguration))) { |
| // Apply blacklisting for roaming to this config if: |
| // - the target config had a recent roaming failure |
| // - we are currently associated |
| // - the target config is not the last selected |
| if (now > config.lastRoamingFailure |
| && (now - config.lastRoamingFailure) |
| < config.roamingFailureBlackListTimeMilli) { |
| if (DBG) { |
| logDbg("compareNetwork not switching to " + config.configKey() |
| + " from current " + currentConfiguration.configKey() |
| + " because it is blacklisted due to roam failure, " |
| + " blacklist remain time = " |
| + (now - config.lastRoamingFailure) + " ms"); |
| } |
| continue; |
| } |
| } |
| |
| int boost = config.autoJoinUseAggressiveJoinAttemptThreshold + weakRssiBailCount; |
| if (underThreshold(config, |
| mWifiConfigStore.thresholdInitialAutoJoinAttemptMin24RSSI.get() - boost, |
| mWifiConfigStore.thresholdInitialAutoJoinAttemptMin5RSSI.get() - boost)) { |
| |
| if (DBG) { |
| logDbg("attemptAutoJoin skip due to low visibility " + config.configKey()); |
| } |
| |
| // Don't try to autojoin a network that is too far but |
| // If that configuration is a user's choice however, try anyway |
| if (!isLastSelected) { |
| config.autoJoinBailedDueToLowRssi = true; |
| didBailDueToWeakRssi = true; |
| continue; |
| } else { |
| // Next time, try to be a bit more aggressive in auto-joining |
| if (config.autoJoinUseAggressiveJoinAttemptThreshold |
| < WifiConfiguration.MAX_INITIAL_AUTO_JOIN_RSSI_BOOST |
| && config.autoJoinBailedDueToLowRssi) { |
| config.autoJoinUseAggressiveJoinAttemptThreshold += 4; |
| } |
| } |
| } |
| // NOTE: If this condition is updated, update NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN. |
| if (config.numNoInternetAccessReports > 0 |
| && !isLastSelected |
| && !config.validatedInternetAccess) { |
| // Avoid autoJoining this network because last time we used it, it didn't |
| // have internet access, and we never manage to validate internet access on this |
| // network configuration |
| if (DBG) { |
| logDbg("attemptAutoJoin skip candidate due to no InternetAccess " |
| + config.configKey(true) |
| + " num reports " + config.numNoInternetAccessReports); |
| } |
| continue; |
| } |
| |
| if (DBG) { |
| String cur = ""; |
| if (candidate != null) { |
| cur = " current candidate " + candidate.configKey(); |
| } |
| logDbg("attemptAutoJoin trying id=" |
| + Integer.toString(config.networkId) + " " |
| + config.configKey(true) |
| + " status=" + config.autoJoinStatus |
| + cur); |
| } |
| |
| if (candidate == null) { |
| candidate = config; |
| } else { |
| if (VDBG) { |
| logDbg("attemptAutoJoin will compare candidate " + candidate.configKey() |
| + " with " + config.configKey()); |
| } |
| |
| int order = compareWifiConfigurations(candidate, config); |
| if (VDBG) { |
| logDbg("attemptAutoJoin compareWifiConfigurations returned " + order); |
| } |
| |
| // The lastSelectedConfiguration is the configuration the user has manually selected |
| // thru WifiPicker, or that a 3rd party app asked us to connect to via the |
| // enableNetwork with disableOthers=true WifiManager API |
| // As this is a direct user choice, we strongly prefer this configuration, |
| // hence give +/-100 |
| if ((lastSelectedConfiguration != null) |
| && candidate.configKey().equals(lastSelectedConfiguration)) { |
| // candidate is the last selected configuration, |
| // so keep it above connect choices (+/-60) and |
| // above RSSI/scorer based selection of linked configuration (+/- 50) |
| // by reducing order by -100 |
| order = order - 100; |
| if (VDBG) { |
| logDbg(" ...and prefers -100 " + candidate.configKey() |
| + " over " + config.configKey() |
| + " because it is the last selected -> " |
| + Integer.toString(order)); |
| } |
| } else if ((lastSelectedConfiguration != null) |
| && config.configKey().equals(lastSelectedConfiguration)) { |
| // config is the last selected configuration, |
| // so keep it above connect choices (+/-60) and |
| // above RSSI/scorer based selection of linked configuration (+/- 50) |
| // by increasing order by +100 |
| order = order + 100; |
| if (VDBG) { |
| logDbg(" ...and prefers +100 " + config.configKey() |
| + " over " + candidate.configKey() |
| + " because it is the last selected -> " |
| + Integer.toString(order)); |
| } |
| } |
| |
| if (order > 0) { |
| // Ascending : candidate < config |
| candidate = config; |
| } |
| } |
| } |
| |
| // Now, go thru scan result to try finding a better untrusted network |
| if (mNetworkScoreCache != null && mAllowUntrustedConnections) { |
| int rssi5 = WifiConfiguration.INVALID_RSSI; |
| int rssi24 = WifiConfiguration.INVALID_RSSI; |
| if (candidate != null) { |
| rssi5 = candidate.visibility.rssi5; |
| rssi24 = candidate.visibility.rssi24; |
| } |
| |
| // Get current date |
| long nowMs = System.currentTimeMillis(); |
| int currentScore = -10000; |
| // The untrusted network with highest score |
| ScanDetail untrustedCandidate = null; |
| // Look for untrusted scored network only if the current candidate is bad |
| if (isBadCandidate(rssi24, rssi5)) { |
| for (ScanDetail scanDetail : scanResultCache.values()) { |
| ScanResult result = scanDetail.getScanResult(); |
| // We look only at untrusted networks with a valid SSID |
| // A trusted result would have been looked at thru it's Wificonfiguration |
| if (TextUtils.isEmpty(result.SSID) || !result.untrusted || |
| !isOpenNetwork(result)) { |
| continue; |
| } |
| String quotedSSID = "\"" + result.SSID + "\""; |
| if (mWifiConfigStore.mDeletedEphemeralSSIDs.contains(quotedSSID)) { |
| // SSID had been Forgotten by user, then don't score it |
| continue; |
| } |
| if ((nowMs - result.seen) < mScanResultAutoJoinAge) { |
| // Increment usage count for the network |
| mWifiConnectionStatistics.incrementOrAddUntrusted(quotedSSID, 0, 1); |
| |
| boolean isActiveNetwork = currentConfiguration != null |
| && currentConfiguration.SSID.equals(quotedSSID); |
| int score = mNetworkScoreCache.getNetworkScore(result, isActiveNetwork); |
| if (score != WifiNetworkScoreCache.INVALID_NETWORK_SCORE |
| && score > currentScore) { |
| // Highest score: Select this candidate |
| currentScore = score; |
| untrustedCandidate = scanDetail; |
| if (VDBG) { |
| logDbg("AutoJoinController: found untrusted candidate " |
| + result.SSID |
| + " RSSI=" + result.level |
| + " freq=" + result.frequency |
| + " score=" + score); |
| } |
| } |
| } |
| } |
| } |
| if (untrustedCandidate != null) { |
| // At this point, we have an untrusted network candidate. |
| // Create the new ephemeral configuration and see if we should switch over |
| candidate = |
| mWifiConfigStore.wifiConfigurationFromScanResult(untrustedCandidate); |
| candidate.allowedKeyManagement.set(KeyMgmt.NONE); |
| candidate.ephemeral = true; |
| candidate.dirty = true; |
| } |
| } |
| |
| long lastUnwanted = |
| System.currentTimeMillis() |
| - mWifiConfigStore.lastUnwantedNetworkDisconnectTimestamp; |
| if (candidate == null |
| && lastSelectedConfiguration == null |
| && currentConfiguration == null |
| && didBailDueToWeakRssi |
| && (mWifiConfigStore.lastUnwantedNetworkDisconnectTimestamp == 0 |
| || lastUnwanted > (1000 * 60 * 60 * 24 * 7)) |
| ) { |
| // We are bailing out of autojoin although we are seeing a weak configuration, and |
| // - we didn't find another valid candidate |
| // - we are not connected |
| // - without a user network selection choice |
| // - ConnectivityService has not triggered an unwanted network disconnect |
| // on this device for a week (hence most likely there is no SIM card or cellular) |
| // If all those conditions are met, then boost the RSSI of the weak networks |
| // that we are seeing so as we will eventually pick one |
| if (weakRssiBailCount < 10) |
| weakRssiBailCount += 1; |
| } else { |
| if (weakRssiBailCount > 0) |
| weakRssiBailCount -= 1; |
| } |
| |
| /** |
| * If candidate is found, check the state of the connection so as |
| * to decide if we should be acting on this candidate and switching over |
| */ |
| int networkDelta = compareNetwork(candidate, lastSelectedConfiguration); |
| if (DBG && candidate != null) { |
| String doSwitch = ""; |
| String current = ""; |
| if (networkDelta < 0) { |
| doSwitch = " -> not switching"; |
| } |
| if (currentConfiguration != null) { |
| current = " with current " + currentConfiguration.configKey(); |
| } |
| logDbg("attemptAutoJoin networkSwitching candidate " |
| + candidate.configKey() |
| + current |
| + " linked=" + (currentConfiguration != null |
| && currentConfiguration.isLinked(candidate)) |
| + " : delta=" |
| + Integer.toString(networkDelta) + " " |
| + doSwitch); |
| } |
| |
| /** |
| * Ask WifiStateMachine permission to switch : |
| * if user is currently streaming voice traffic, |
| * then we should not be allowed to switch regardless of the delta |
| */ |
| if (mWifiStateMachine.shouldSwitchNetwork(networkDelta)) { // !!! JNo: Here! |
| if (mStaStaSupported) { |
| logDbg("mStaStaSupported --> error do nothing now "); |
| } else { |
| if (currentConfiguration != null && currentConfiguration.isLinked(candidate)) { |
| networkSwitchType = AUTO_JOIN_EXTENDED_ROAMING; |
| } else { |
| networkSwitchType = AUTO_JOIN_OUT_OF_NETWORK_ROAMING; |
| } |
| if (DBG) { |
| logDbg("AutoJoin auto connect with netId " |
| + Integer.toString(candidate.networkId) |
| + " to " + candidate.configKey()); |
| } |
| if (didOverride) { |
| candidate.numScorerOverrideAndSwitchedNetwork++; |
| } |
| candidate.numAssociation++; |
| mWifiConnectionStatistics.numAutoJoinAttempt++; |
| |
| if (candidate.ephemeral) { |
| // We found a new candidate that we are going to connect to, then |
| // increase its connection count |
| mWifiConnectionStatistics. |
| incrementOrAddUntrusted(candidate.SSID, 1, 0); |
| } |
| |
| if (candidate.BSSID == null || candidate.BSSID.equals("any")) { |
| // First step we selected the configuration we want to connect to |
| // Second step: Look for the best Scan result for this configuration |
| // TODO this algorithm should really be done in one step |
| String currentBSSID = mWifiStateMachine.getCurrentBSSID(); |
| ScanResult roamCandidate = |
| attemptRoam(null, candidate, mScanResultAutoJoinAge, null); |
| if (roamCandidate != null && currentBSSID != null |
| && currentBSSID.equals(roamCandidate.BSSID)) { |
| // Sanity, we were already asociated to that candidate |
| roamCandidate = null; |
| } |
| if (roamCandidate != null && roamCandidate.is5GHz()) { |
| // If the configuration hasn't a default BSSID selected, and the best |
| // candidate is 5GHZ, then select this candidate so as WifiStateMachine and |
| // supplicant will pick it first |
| candidate.autoJoinBSSID = roamCandidate.BSSID; |
| if (VDBG) { |
| logDbg("AutoJoinController: lock to 5GHz " |
| + candidate.autoJoinBSSID |
| + " RSSI=" + roamCandidate.level |
| + " freq=" + roamCandidate.frequency); |
| } |
| } else { |
| // We couldnt find a roam candidate |
| candidate.autoJoinBSSID = "any"; |
| } |
| } |
| mWifiStateMachine.sendMessage(WifiStateMachine.CMD_AUTO_CONNECT, |
| candidate.networkId, networkSwitchType, candidate); |
| found = true; |
| } |
| } |
| |
| if (networkSwitchType == AUTO_JOIN_IDLE && !mWifiConfigStore.enableHalBasedPno.get()) { |
| String currentBSSID = mWifiStateMachine.getCurrentBSSID(); |
| // Attempt same WifiConfiguration roaming |
| ScanResult roamCandidate = |
| attemptRoam(null, currentConfiguration, mScanResultAutoJoinAge, currentBSSID); |
| if (roamCandidate != null && currentBSSID != null |
| && currentBSSID.equals(roamCandidate.BSSID)) { |
| roamCandidate = null; |
| } |
| if (roamCandidate != null && mWifiStateMachine.shouldSwitchNetwork(999)) { |
| if (DBG) { |
| logDbg("AutoJoin auto roam with netId " |
| + Integer.toString(currentConfiguration.networkId) |
| + " " + currentConfiguration.configKey() + " to BSSID=" |
| + roamCandidate.BSSID + " freq=" + roamCandidate.frequency |
| + " RSSI=" + roamCandidate.level); |
| } |
| networkSwitchType = AUTO_JOIN_ROAMING; |
| mWifiConnectionStatistics.numAutoRoamAttempt++; |
| |
| mWifiStateMachine.sendMessage(WifiStateMachine.CMD_AUTO_ROAM, |
| currentConfiguration.networkId, 1, roamCandidate); |
| found = true; |
| } |
| } |
| if (VDBG) logDbg("Done attemptAutoJoin status=" + Integer.toString(networkSwitchType)); |
| return found; |
| } |
| |
| private void logDenial(String reason, WifiConfiguration config) { |
| if (!DBG) { |
| return; |
| } |
| logDbg(reason + config.toString()); |
| } |
| |
| WifiConfiguration getWifiConfiguration(WifiNative.WifiPnoNetwork network) { |
| if (network.configKey != null) { |
| return mWifiConfigStore.getWifiConfiguration(network.configKey); |
| } |
| return null; |
| } |
| |
| ArrayList<WifiNative.WifiPnoNetwork> getPnoList(WifiConfiguration current) { |
| int size = -1; |
| ArrayList<WifiNative.WifiPnoNetwork> list = new ArrayList<WifiNative.WifiPnoNetwork>(); |
| |
| if (mWifiConfigStore.mCachedPnoList != null) { |
| size = mWifiConfigStore.mCachedPnoList.size(); |
| } |
| |
| if (DBG) { |
| String s = ""; |
| if (current != null) { |
| s = " for: " + current.configKey(); |
| } |
| Log.e(TAG, " get Pno List total size:" + size + s); |
| } |
| if (current != null) { |
| String configKey = current.configKey(); |
| /** |
| * If we are currently associated to a WifiConfiguration then include |
| * only those networks that have a higher priority |
| */ |
| for (WifiNative.WifiPnoNetwork network : mWifiConfigStore.mCachedPnoList) { |
| WifiConfiguration config = getWifiConfiguration(network); |
| if (config == null) { |
| continue; |
| } |
| if (config.autoJoinStatus |
| >= WifiConfiguration.AUTO_JOIN_DISABLED_NO_CREDENTIALS) { |
| continue; |
| } |
| |
| if (!configKey.equals(network.configKey)) { |
| int choice = getConnectChoice(config, current, true); |
| if (choice > 0) { |
| // config is of higher priority |
| if (DBG) { |
| Log.e(TAG, " Pno List adding:" + network.configKey |
| + " choice " + choice); |
| } |
| list.add(network); |
| network.rssi_threshold = mWifiConfigStore.thresholdGoodRssi24.get(); |
| } |
| } |
| } |
| } else { |
| for (WifiNative.WifiPnoNetwork network : mWifiConfigStore.mCachedPnoList) { |
| WifiConfiguration config = getWifiConfiguration(network); |
| if (config == null) { |
| continue; |
| } |
| if (config.autoJoinStatus |
| >= WifiConfiguration.AUTO_JOIN_DISABLED_NO_CREDENTIALS) { |
| continue; |
| } |
| list.add(network); |
| network.rssi_threshold = mWifiConfigStore.thresholdGoodRssi24.get(); |
| } |
| } |
| return list; |
| } |
| } |
| |
