Android Wifi的扫描机制_代码007(未授权)

本文介绍: And roi d Wi fi 的扫描场景分为下面四种情况：1.亮屏情况下，在Wi fi settings 界面，固定扫描，扫描时间为10s。2.亮屏情况下，在非Wi fi settings界面，二进制指数退避扫描，退避：interval*(2^n), 最小间隔 min=20s, 最大间隔 max=160s.3.灭屏情况下，有保存网络时，若已连接，不扫描，否则，PNO扫描，即只扫描已保存的网络。最小间隔 min=20s，最大间隔 max=20s*3=60s。

And roi d Wifi 的扫描场景分为下面四种情况：

1.亮屏情况下，在Wifi settings界面，固定扫描，扫描时间为10s。

2.亮屏情况下，在非Wifi settings界面，二进制指数退避扫描，退避：interval*(2^n), 最小间隔 min=20s, 最大间隔 max=160s.

3.灭屏情况下，有保存网络时，若已连接，不扫描，否则，PNO扫描，即只扫描已保存的网络。最小间隔 min=20s，最大间隔max=20s*3=60s。

4.无保存网络情况下，固定扫描，间隔为5分钟，用于通知用户周围存在可用开放网络。

从 wifi扫描流程梳理可以看到 wifi扫描流程会走到WifiTrac k e r的h andleMe ssa g e 函数中，我们看sendEmp t yMessa geDel a yed，会发送一条扫描的信息，其中包含了WIFI_RESCAN_INTERVAL_MS，WIFI_RESCAN_INTERVAL_MS就是默认的扫描周期，可以看到系统设置的默认周期是10 * 1000，也就是10秒。

public void handleMessage(Message message) {
            if (message.what != MSG_SCAN) return;
            if (mWifiManager.startScan()) {
                mRetry = 0;
            } else if (++mRetry &gt;= 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 void startConnectivityScan(boolean scanImmediately) {
        
        // Always stop outstanding connecivity scan if there is any
        stopConnectivityScan();

        if (mWifiState != WIFI_STATE_CONNECTED &amp;&amp; mWifiState != WIFI_STATE_DISCONNECTED) {
            return;
        }

        if (mScreenOn) {
            startPeriodicScan(scanImmediately);
        } else {
            if (mWifiState == WIFI_STATE_DISCONNECTED &amp;&amp; !mPnoScanStarted) {
                startDisconnectedPnoScan();
            }
        }

    }

private void startPeriodicScan(boolean scanImmediately) {
        mPnoScanListener.resetLowRssiNetworkRetryDelay();

        if (scanImmediately) {
            resetLastPeriodicSingleScanTimeStamp();
        }
        mPeriodicSingleScanInterval = PERIODIC_SCAN_INTERVAL_MS;
        startPeriodicSingleScan();
    }

// 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;
            }
    ...............
    
        if (isScanNeeded) {
            mLastPeriodicSingleScanTimeStamp = currentTimeStamp;
            startSingleScan(isFullBandScan, WIFI_WORK_SOURCE);
            schedulePeriodicScanTimer(mPeriodicSingleScanInterval);

            // 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;
            }
        } else {
            // Since we already skipped this scan, keep the same scan interval for next scan.
            schedulePeriodicScanTimer(mPeriodicSingleScanInterval);
        }
    }

    // Periodic scan interval in milli-seconds. This is the scan
    // performed when screen is on.
    public static final int PERIODIC_SCAN_INTERVAL_MS = 20 * 1000; // 20 seconds
    // When screen is on and WiFi traffic is heavy, exponential backoff
    // connectivity scans are scheduled. This constant defines the maximum
    // scan interval in this scenario.
    @VisibleForTesting
    public static final int MAX_PERIODIC_SCAN_INTERVAL_MS = 160 * 1000; // 160 seconds

class DisconnectedState extends State {
    @Override
    public void enter() {
        Log.i(TAG, "disconnectedstate enter");
        // We dont scan frequently if this is a temporary disconnect
        // due to p2p
        if (mTemporarilyDisconnectWifi) {
            p2pSendMessage(WifiP2pServiceImpl.DISCONNECT_WIFI_RESPONSE);
            return;
        }
        /** clear the roaming state, if we were roaming, we failed */
        mIsAutoRoaming = false;

        mWifiConnectivityManager.handleConnectionStateChanged(
                WifiConnectivityManager.WIFI_STATE_DISCONNECTED);

        /**
         * If we have no networks saved, the supplicant stops doing the periodic scan.
         * The scans are useful to notify the user of the presence of an open network.
         * Note that these are not wake up scans.
         */
        if (mNoNetworksPeriodicScan != 0 && !mP2pConnected.get()
                && mWifiConfigManager.getSavedNetworks().size() == 0) {
            sendMessageDelayed(obtainMessage(CMD_NO_NETWORKS_PERIODIC_SCAN,
                    ++mPeriodicScanToken, 0), mNoNetworksPeriodicScan);
        }

        mDisconnectedTimeStamp = mClock.getWallClockMillis();
        mWifiStateTracker.updateState(WifiStateTracker.DISCONNECTED);
    }

mNoNetworksPeriodicScan = mContext.getResources().getInteger(
                R.integer.config_wifi_no_network_periodic_scan_interval);

<!-- Integer indicating the framework no networks periodic scan interval in milliseconds. -->
<integer translatable="false" name="config_wifi_no_network_periodic_scan_interval">300000</integer>