android wifi扫描间隔,Android 8 wifi 扫描时间间隔

wifi setting界面扫描时间间隔：10s

不在wifi setting界面，扫描时间间隔，最小20s，然后按找2倍的间隔进行递增，40s,60s..., 最大160s

PNO 即Preferred Network Offload，用于系统在休眠的时候连接WiFi

1. wifi setting界面

packages\apps\Settings\src\com\android\settings\wifi\WifiSettings.java

public void onStart() {

mWifiTracker.startTracking();

frameworks\base\packages\SettingsLib\src\com\android\settingslib\wifi\WifiTracker.java

public void startTracking() {

synchronized (mLock) {

registerScoreCache();

// 是否显示wifi评分的UI

mNetworkScoringUiEnabled =

Settings.Global.getInt(

mContext.getContentResolver(),

Settings.Global.NETWORK_SCORING_UI_ENABLED, 0) == 1;

// 是否显示wifi速度

mMaxSpeedLabelScoreCacheAge =

Settings.Global.getLong(

mContext.getContentResolver(),

Settings.Global.SPEED_LABEL_CACHE_EVICTION_AGE_MILLIS,

DEFAULT_MAX_CACHED_SCORE_AGE_MILLIS);

resumeScanning();

if (!mRegistered) {

mContext.registerReceiver(mReceiver, mFilter);

// NetworkCallback objects cannot be reused. http://b/20701525 .

mNetworkCallback = new WifiTrackerNetworkCallback();

mConnectivityManager.registerNetworkCallback(mNetworkRequest, mNetworkCallback);

mRegistered = true;

}

}

}

扫描服务

public void resumeScanning() {

if (mScanner == null) {

mScanner = new Scanner();

}

mWorkHandler.sendEmptyMessage(WorkHandler.MSG_RESUME);

if (mWifiManager.isWifiEnabled()) {

mScanner.resume(); // 发送扫描消息

}

}

//

class Scanner extends Handler {

static final int MSG_SCAN = 0;

private int mRetry = 0;

void resume() {

if (!hasMessages(MSG_SCAN)) {

sendEmptyMessage(MSG_SCAN);

}

}

void forceScan() {

removeMessages(MSG_SCAN);

sendEmptyMessage(MSG_SCAN);

}

void pause() {

mRetry = 0;

removeMessages(MSG_SCAN);

}

@VisibleForTesting

boolean isScanning() {

return hasMessages(MSG_SCAN);

}

@Override

public void handleMessage(Message message) {

if (message.what != MSG_SCAN) return;

if (mWifiManager.startScan()) { // 启动扫描

mRetry = 0;

} else if (++mRetry >= 3) {

mRetry = 0;

if (mContext != null) {

Toast.makeText(mContext, R.string.wifi_fail_to_scan, Toast.LENGTH_LONG).show();

}

return;

}

// 扫描界面扫描间隔。

sendEmptyMessageDelayed(MSG_SCAN, WIFI_RESCAN_INTERVAL_MS);

}

}

//private static final int WIFI_RESCAN_INTERVAL_MS = 10 * 1000;

2. 不在wifisetting界面，亮屏情况下。

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

public void handleScreenStateChanged(boolean screenOn) {

localLog("handleScreenStateChanged: screenOn=" + screenOn);

mScreenOn = screenOn;

mOpenNetworkNotifier.handleScreenStateChanged(screenOn);

startConnectivityScan(SCAN_ON_SCHEDULE);

}

private void startConnectivityScan(boolean scanImmediately) {

localLog("startConnectivityScan: screenOn=" + mScreenOn

+ " wifiState=" + stateToString(mWifiState)

+ " scanImmediately=" + scanImmediately

+ " wifiEnabled=" + mWifiEnabled

+ " wifiConnectivityManagerEnabled="

+ mWifiConnectivityManagerEnabled);

if (!mWifiEnabled || !mWifiConnectivityManagerEnabled) {

return;

}

// Always stop outstanding connecivity scan if there is any

stopConnectivityScan();

// Don't start a connectivity scan while Wifi is in the transition

// between connected and disconnected states.

if (mWifiState != WIFI_STATE_CONNECTED && mWifiState != WIFI_STATE_DISCONNECTED) {

return;

}

if (mScreenOn) {

startPeriodicScan(scanImmediately);

} else {

if (mWifiState == WIFI_STATE_DISCONNECTED && !mPnoScanStarted) {

startDisconnectedPnoScan();

}

}

}

// Start a periodic scan when screen is on

private void startPeriodicScan(boolean scanImmediately) {

// 从新设置PNO扫描的时间间隔。

// 当扫描的网络，Rssi比较低时，将会进行从新扫描

mPnoScanListener.resetLowRssiNetworkRetryDelay();

// 漫游关闭时，不进行扫描

// No connectivity scan if auto roaming is disabled.

if (mWifiState == WIFI_STATE_CONNECTED && !mEnableAutoJoinWhenAssociated) {

return;

}

// Due to b/28020168, timer based single scan will be scheduled

// to provide periodic scan in an exponential backoff fashion.

if (scanImmediately) {

resetLastPeriodicSingleScanTimeStamp();

}

mPeriodicSingleScanInterval = PERIODIC_SCAN_INTERVAL_MS;

startPeriodicSingleScan();

}

@VisibleForTesting

public static final int PERIODIC_SCAN_INTERVAL_MS = 20 * 1000; // 20 seconds

// Start a single scan and set up the interval for next single scan.

private void startPeriodicSingleScan() {

long currentTimeStamp = mClock.getElapsedSinceBootMillis();

if (mLastPeriodicSingleScanTimeStamp != RESET_TIME_STAMP) {

long msSinceLastScan = currentTimeStamp - mLastPeriodicSingleScanTimeStamp;

if (msSinceLastScan < PERIODIC_SCAN_INTERVAL_MS) {

localLog("Last periodic single scan started " + msSinceLastScan

+ "ms ago, defer this new scan request.");

schedulePeriodicScanTimer(PERIODIC_SCAN_INTERVAL_MS - (int) msSinceLastScan);

return;

}

}

boolean isFullBandScan = true;

// 判断wifi使用率是不是比较高，比较高只进行一部分扫描

// 通过发送和接收速率判断

// If the WiFi traffic is heavy, only partial scan is initiated.

if (mWifiState == WIFI_STATE_CONNECTED

&& (mWifiInfo.txSuccessRate > mFullScanMaxTxRate

|| mWifiInfo.rxSuccessRate > mFullScanMaxRxRate)) {

localLog("No full band scan due to ongoing traffic");

isFullBandScan = false;

}

// 再次判断，如果发送接收速率超过最大值，将不进行扫描。

mLastPeriodicSingleScanTimeStamp = currentTimeStamp;

if (mWifiState == WIFI_STATE_CONNECTED

&& (mWifiInfo.txSuccessRate

> MAX_TX_PACKET_FOR_PARTIAL_SCANS

|| mWifiInfo.rxSuccessRate

> MAX_RX_PACKET_FOR_PARTIAL_SCANS)) {

Log.e(TAG,"Ignore scan due to heavy traffic");

} else {

startSingleScan(isFullBandScan, WIFI_WORK_SOURCE);

}

schedulePeriodicScanTimer(mPeriodicSingleScanInterval);

// 设置下一次扫描时间间隔，是当前的2倍。

// 最大扫描时间间隔160s

// public static final int MAX_PERIODIC_SCAN_INTERVAL_MS = 160 * 1000; // 160 seconds

// Set up the next scan interval in an exponential backoff fashion.

mPeriodicSingleScanInterval *= 2;

if (mPeriodicSingleScanInterval > MAX_PERIODIC_SCAN_INTERVAL_MS) {

mPeriodicSingleScanInterval = MAX_PERIODIC_SCAN_INTERVAL_MS;

}

}

3. pno扫描

private void startDisconnectedPnoScan() {

// TODO(b/29503772): Need to change this interface.

// Initialize PNO settings

PnoSettings pnoSettings = new PnoSettings();

ListpnoNetworkList = mConfigManager.retrievePnoNetworkList();

int listSize = pnoNetworkList.size();

if (listSize == 0) {

// No saved network

localLog("No saved network for starting disconnected PNO.");

return;

}

pnoSettings.networkList = new PnoSettings.PnoNetwork[listSize];

pnoSettings.networkList = pnoNetworkList.toArray(pnoSettings.networkList);

pnoSettings.min5GHzRssi = mMin5GHzRssi;

pnoSettings.min24GHzRssi = mMin24GHzRssi;

pnoSettings.initialScoreMax = mInitialScoreMax;

pnoSettings.currentConnectionBonus = mCurrentConnectionBonus;

pnoSettings.sameNetworkBonus = mSameNetworkBonus;

pnoSettings.secureBonus = mSecureBonus;

pnoSettings.band5GHzBonus = mBand5GHzBonus;

// Initialize scan settings

ScanSettings scanSettings = new ScanSettings();

scanSettings.band = getScanBand();

scanSettings.reportEvents = WifiScanner.REPORT_EVENT_NO_BATCH;

scanSettings.numBssidsPerScan = 0;

scanSettings.periodInMs = DISCONNECTED_PNO_SCAN_INTERVAL_MS; // 20s

mPnoScanListener.clearScanDetails();

mScanner.startDisconnectedPnoScan(scanSettings, pnoSettings, mPnoScanListener);

mPnoScanStarted = true;

}

待续。。。