前言

HI，欢迎来到《每周一博》。今天是十二月第一周，我给大家介绍一下安卓系统WiFi的扫描过程。

一. 痛点

为什么要走读Wifi源码，因为定位离不开Wifi，之前在解答问题的时候，总是会有用户报无法获取Wifi的问题，包括发起Wifi扫描，获取Wifi结果和系统缓存的一系列问题，所以我决定带着这些疑问去看一下Wifi的基本流程到底是什么样的，如何发起了扫描，获得结果什么时候用的是缓存，究竟是否有3分钟清缓存的限制。

二. 状态机

Wifi的工作过程使用了状态机，为了了解Wifi工作过程，我特意先学习了一下状态机，否则真不懂，关于状态机我写了一篇文章《状态机工作原理》来介绍。

这里再简单介绍下帮助理解，状态机主要用到了状态模式，不同的状态行为也不同。状态树有很多节点，子节点继承自父亲节点，状态都有enter，exit，processMessage方法，如果当前状态不处理消息，就会由父状态去处理。状态机有deferMessage，transitTo，sendMessage方法，分别是把消息推迟到下一状态执行，切换到某个状态，发送消息方法。状态机内部是通过Handler来实现发送接收消息的。

在WifiStateMachine里面就有几十个状态机，每个状态机处理的消息类型和处理方法都不一样，这就需要搞清楚当前是什么状态，当前要处理什么消息，如何处理，处理完之后变成了什么状态。

三. Wifi上层架构图

我们和Wifi交互的入口就是WifiManager，它通过Binder机制和WifiService进行跨进程通讯，WifiService的具体实现是WifiServiceImpl，它内部有个重要的状态机WifiStateMachine，还有和底层交互的WifiNative类，这里面封装了一些命令，如doCommand()，和监听函数，如wifi_wait_for_event()。

和WifiNative交互的是wpa_supplicant，它是Linux上的一个开源项目，被谷歌修改后加入Android移动平台，用来支持WEP，WPA/WPA2和WAPI无线协议和加密认证，而实际上的工作内容是通过socket（不管是与上层还是与驱动）与驱动交互上报数据给用户，而用户可以通过socket发送命令给wpa_supplicant调动驱动来对WiFi芯片操作。 简单的说，wpa_supplicant就是WiFi驱动和用户的中转站外加对协议和加密认证的支持。

四. Wifi扫描

Wifi扫描的入口是WifiManager的startScan方法，它代理了mService的startScan方法，它们之间是通过Binder来传递消息的。

public boolean startScan(WorkSource workSource) {  
    try {  
        mService.startScan(workSource);  
        return true;  
    } catch (RemoteException e) {  
        return false;  
    }  
}  

先来看一下安卓4.4的实现，mService的实现是WifiService，它和WifiManger通过IWifiManager接口调用。

WifiService里有2个重要的状态机WifiControl，WifiStateMachine，当调用startScan时先回检查权限，然后执行WifiStateMachine的startScan方法。

public void startScan(WorkSource workSource) {
    enforceChangePermission();
    if (workSource != null) {
        enforceWorkSourcePermission();
        workSource.clearNames();
    }
    mWifiStateMachine.startScan(Binder.getCallingUid(), workSource);
}

在WifiStateMachine的构造函数里，初始化了mWifiNative和mWifiMonitor对象，构建了状态树，设置初始状态并开启状态机；

mWifiNative = new WifiNative(mInterfaceName);
mWifiMonitor = new WifiMonitor(this, mWifiNative);

addState(mDefaultState);
    addState(mInitialState, mDefaultState);
    addState(mSupplicantStartingState, mDefaultState);
    addState(mSupplicantStartedState, mDefaultState);
        addState(mDriverStartingState, mSupplicantStartedState);
        addState(mDriverStartedState, mSupplicantStartedState);
            addState(mScanModeState, mDriverStartedState);
            addState(mConnectModeState, mDriverStartedState);
                addState(mL2ConnectedState, mConnectModeState);
                    addState(mObtainingIpState, mL2ConnectedState);
                    addState(mVerifyingLinkState, mL2ConnectedState);
                    addState(mCaptivePortalCheckState, mL2ConnectedState);
                    addState(mConnectedState, mL2ConnectedState);
                addState(mDisconnectingState, mConnectModeState);
                addState(mDisconnectedState, mConnectModeState);
                addState(mWpsRunningState, mConnectModeState);
        addState(mWaitForP2pDisableState, mSupplicantStartedState);
        addState(mDriverStoppingState, mSupplicantStartedState);
        addState(mDriverStoppedState, mSupplicantStartedState);
    addState(mSupplicantStoppingState, mDefaultState);
    addState(mSoftApStartingState, mDefaultState);
    addState(mSoftApStartedState, mDefaultState);
        addState(mTetheringState, mSoftApStartedState);
        addState(mTetheredState, mSoftApStartedState);
        addState(mUntetheringState, mSoftApStartedState);
setInitialState(mInitialState);
start();

WifiStateMachine构建的状态机是这样的，每一个状态要切换到另一状态都需要走过该树上的所有相关节点，而不能直接跨越。比如从mInitialState状态切换到mDriverStartedState需要经历mDefaultState，mSupplicantStartedState，mDriverStartedState三个状态，接下来我们看WifiStateMachine的startScan方法。

 sendMessage(CMD_START_SCAN, callingUid, 0, workSource);

只是发送了一个指令CMD_START_SCAN，那我们看一下不同状态对该指令的行为是什么；
DefaultState：break（不执行）
DriverStartingState：deferMessage(推迟到下一状态)
ObtainingIpState：deferMessage(推迟到下一状态)
在DriverStartedState中处理该消息

noteScanStart(message.arg1, (WorkSource) message.obj);
startScanNative(WifiNative.SCAN_WITH_CONNECTION_SETUP);

在ScanModeState中处理该消息

noteScanStart(message.arg1, (WorkSource) message.obj);      
startScanNative(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP);

都是调用startScanNative方法，只是参数不同而已，noteScanStart用于通知电量统计，startScanNative会调用 mWifiNative.scan(type)，向wpa_supplicant发送SCAN的命令，至此一条发起wifi扫描的请求就走完了，那么扫描完后得到结果如何通知的呢？

可以想象这个过程是异步的，不是一发起扫描就会立刻得到结果，所以需要有一个监听器不断的去监听事件。在WifiMonitor里面有一个MonitorThread线程在不断的监听WifiNative上报的事件，这是个无限循环，当接收到事件时会做解析，然后根据不同的类型去调用dispatchEvent(eventStr)来分发事件。

for (;;) {
       String eventStr = mWifiNative.waitForEvent();
}

当事件类型是扫描结果时，会执行handleEvent方法，在这里把消息发出去；

   case SCAN_RESULTS:
        mStateMachine.sendMessage(SCAN_RESULTS_EVENT);
        break;

WifiStateMachine的SupplicantStartedState会处理SCAN_RESULTS_EVENT这个消息，它会做两件事，一是去获取scanResults，二是发送一个广播消息；

setScanResults();
sendScanResultsAvailableBroadcast();

setScanResult主要就是把从WifiNative获取到AP列表信息进行循环解析，然后赋值给系统缓存mScanResultCache和结果列表mScanResults， mScanResultCache使用了LRUCache，它以bssid+ssid做key值。

    private void setScanResults() {
        while (true) {
            tmpResults = mWifiNative.scanResults(sid);
            if (TextUtils.isEmpty(tmpResults)) break;
            scanResultsBuf.append(tmpResults);
            scanResultsBuf.append("\n");
            String[] lines = tmpResults.split("\n");
            sid = -1;
            for (int i=lines.length - 1; i >= 0; i--) {
                if (lines[i].startsWith(END_STR)) {
                    break;
                } else if (lines[i].startsWith(ID_STR)) {
                    try {
                        sid = Integer.parseInt(lines[i].substring(ID_STR.length())) + 1;
                    } catch (NumberFormatException e) {
                        // Nothing to do
                    }
                    break;
               }
           }
            if (sid == -1) break;
        }
        synchronized(mScanResultCache) {
            mScanResults = new ArrayList<ScanResult>();
            String[] lines = scanResults.split("\n");
            final int bssidStrLen = BSSID_STR.length();
            final int flagLen = FLAGS_STR.length();

            for (String line : lines) {
                if (line.startsWith(BSSID_STR)) {
                    bssid = new String(line.getBytes(), bssidStrLen, line.length() - bssidStrLen);
                } else if (line.startsWith(FREQ_STR)) {
                    try {
                        freq = Integer.parseInt(line.substring(FREQ_STR.length()));
                    } catch (NumberFormatException e) {
                        freq = 0;
                    }
                    ……………………………………
                } else if (line.startsWith(SSID_STR)) {
                    wifiSsid = WifiSsid.createFromAsciiEncoded(
                            line.substring(SSID_STR.length()));
                } else if (line.startsWith(DELIMITER_STR) || line.startsWith(END_STR)) {
                    if (bssid != null) {
                        String ssid = (wifiSsid != null) ? wifiSsid.toString() : WifiSsid.NONE;
                        String key = bssid + ssid;
                        ScanResult scanResult = mScanResultCache.get(key);
                        if (scanResult != null) {
                            scanResult.level = level;
                            scanResult.wifiSsid = wifiSsid;
                            // Keep existing API
                            scanResult.SSID = (wifiSsid != null) ? wifiSsid.toString() :
                                    WifiSsid.NONE;
                            scanResult.capabilities = flags;
                            scanResult.frequency = freq;
                            scanResult.timestamp = tsf;
                        } else {
                            scanResult =
                                new ScanResult(
                                        wifiSsid, bssid, flags, level, freq, tsf);
                            mScanResultCache.put(key, scanResult);
                        }
                        mScanResults.add(scanResult);
                    }
                }
            }
        }
    }

WifiNative.scanResut的返回结果格式如下，每个AP之间用"===="分割，末尾以“####”来表示结束。

id=1
bssid=68:7f:76:d7:1a:6e
freq=2412
level=-44
tsf=1344626243700342
flags=[WPA2-PSK-CCMP][WPS][ESS]
ssid=zfdy
====
id=2
bssid=68:5f:74:d7:1a:6f
req=5180
level=-73
tsf=1344626243700373
flags=[WPA2-PSK-CCMP][WPS][ESS]
ssid=zuby
####

这里对结果ScanResult做个说明，它描述了AP的信息，具体包含以下字段；
A. String SSID：网络名称
B. String BSSID：WiFi的mac地址，也是唯一id
C. String capabilities：描述认证、密钥管理以及加密方式
D. int level：信号等级，单位是dBm，也被称作RSSI，一般是个负数，越大信号越强，比如-50强过-100
E. int frequency：客户端与WiFi通信的频率，单位MHz，如果频率值在2400-2500之间是2.4GHz，如果频率值在4900-5900之间是5GHz
F. long timestamp：从启动开始到该扫描记录最后一次被发现经过的微秒数。

接下来就是去发广播了，广播的Action是WifiManager.SCAN_RESULTS_AVAILABLE_ACTION，然后通过getScanResults去取mScanResults信息就可以了，需要注意的是这里的广播设置了Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT这个属性，所以只有动态注册的broadcastReceive才会收到广播。

    private void sendScanResultsAvailableBroadcast() {
        noteScanEnd();
        Intent intent = new Intent(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
    }

至此一个发起wifi扫描的流程就算是走完了，从6.0开始发送结果的广播增加了EXTRA_RESULTS_UPDATED新字段，如果是true表示结果可用。

private void sendScanResultBroadcast(boolean scanSucceeded) {
    Intent intent = new Intent(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
    intent.putExtra(WifiManager.EXTRA_RESULTS_UPDATED, scanSucceeded);
    mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
}  

所以我们在监听广播的时候先判断下系统版本，如果高于M，取出EXTRA_RESULTS_UPDATED字段，如果为true，再取结果。

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            boolean hasResult=intent.getBooleanExtra(WifiManager.EXTRA_RESULTS_UPDATED, false);
            if (hasResult){
                List<ScanResult> results = wifiManager.getScanResults();
            }
        }

一个安卓4.4发起wifi扫描的流程如下图；

另外8.0的扫描流程有了很大的变化，主要功能都是由WifiScanner来完成的，它的具体实现是WifiScanningServiceImpl，当调用WifiStateMachine的startScanNative时会走到WifiScanner的startScan方法。

   private boolean startScanNative(final Set<Integer> freqs,
        List<WifiScanner.ScanSettings.HiddenNetwork> hiddenNetworkList,
        WorkSource workSource) {
    WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
    if (freqs == null) {
        settings.band = WifiScanner.WIFI_BAND_BOTH_WITH_DFS;
    } else {
        settings.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
        int index = 0;
        settings.channels = new WifiScanner.ChannelSpec[freqs.size()];
        for (Integer freq : freqs) {
            settings.channels[index++] = new WifiScanner.ChannelSpec(freq);
        }
    }
    settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN
            | WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT;

    settings.hiddenNetworks =
            hiddenNetworkList.toArray(
                    new WifiScanner.ScanSettings.HiddenNetwork[hiddenNetworkList.size()]);

    WifiScanner.ScanListener nativeScanListener = new WifiScanner.ScanListener() {
            // ignore all events since WifiStateMachine is registered for the supplicant events
            @Override
            public void onSuccess() {
            }
            @Override
            public void onFailure(int reason, String description) {
                mIsScanOngoing = false;
                mIsFullScanOngoing = false;
            }
            @Override
            public void onResults(WifiScanner.ScanData[] results) {
            }
            @Override
            public void onFullResult(ScanResult fullScanResult) {
            }
            @Override
            public void onPeriodChanged(int periodInMs) {
            }
        };
    mWifiScanner.startScan(settings, nativeScanListener, workSource);
    mIsScanOngoing = true;
    mIsFullScanOngoing = (freqs == null);
    lastScanFreqs = freqs;
    return true;
}

WifiScanner的startScan方法里会通过mAsyncChannel发送了一个CMD_START_SINGLE_SCAN的消息；

public void startScan(ScanSettings settings, ScanListener listener, WorkSource workSource) {
    Preconditions.checkNotNull(listener, "listener cannot be null");
    int key = addListener(listener);
    if (key == INVALID_KEY) return;
    validateChannel();
    Bundle scanParams = new Bundle();
    scanParams.putParcelable(SCAN_PARAMS_SCAN_SETTINGS_KEY, settings);
    scanParams.putParcelable(SCAN_PARAMS_WORK_SOURCE_KEY, workSource);
    mAsyncChannel.sendMessage(CMD_START_SINGLE_SCAN, 0, key, scanParams);
}

WifiScanningServiceImpl的ClientHandler接受到该消息后会调用状态机发消息的方法。

mSingleScanStateMachine.sendMessage(Message.obtain(msg));

WifiSingleScanStateMachine状态接收到消息后，会执行关键的方法tryToStartNewScan；

case WifiScanner.CMD_START_SINGLE_SCAN:
    mWifiMetrics.incrementOneshotScanCount();
    int handler = msg.arg2;
    Bundle scanParams = (Bundle) msg.obj;
    if (scanParams == null) {
        logCallback("singleScanInvalidRequest",  ci, handler, "null params");
        replyFailed(msg, WifiScanner.REASON_INVALID_REQUEST, "params null");
        return HANDLED;
    }
    scanParams.setDefusable(true);
    ScanSettings scanSettings =
            scanParams.getParcelable(WifiScanner.SCAN_PARAMS_SCAN_SETTINGS_KEY);
    WorkSource workSource =
            scanParams.getParcelable(WifiScanner.SCAN_PARAMS_WORK_SOURCE_KEY);
    if (validateScanRequest(ci, handler, scanSettings, workSource)) {
        logScanRequest("addSingleScanRequest", ci, handler, workSource,
                scanSettings, null);
        replySucceeded(msg);

        // If there is an active scan that will fulfill the scan request then
        // mark this request as an active scan, otherwise mark it pending.
        // If were not currently scanning then try to start a scan. Otherwise
        // this scan will be scheduled when transitioning back to IdleState
        // after finishing the current scan.
        if (getCurrentState() == mScanningState) {
            if (activeScanSatisfies(scanSettings)) {
                mActiveScans.addRequest(ci, handler, workSource, scanSettings);
            } else {
                mPendingScans.addRequest(ci, handler, workSource, scanSettings);
            }
        } else {
            mPendingScans.addRequest(ci, handler, workSource, scanSettings);
            tryToStartNewScan();
        }
    } else {
        logCallback("singleScanInvalidRequest",  ci, handler, "bad request");
        replyFailed(msg, WifiScanner.REASON_INVALID_REQUEST, "bad request");
        mWifiMetrics.incrementScanReturnEntry(
                WifiMetricsProto.WifiLog.SCAN_FAILURE_INVALID_CONFIGURATION, 1);
    }
    return HANDLED;

而它又会调用startSingleScan，最终调到了WifiNative的scan方法，一个安卓8.0的wifi扫描流程图如下。

五. 获取Wifi结果

获取WiFi结果需要调用WifiManager的getScanResults方法，这个实现在8.0上也有所不同，我们先来看4.4的实现。

它最终会走到WifiStateMachine的syncGetScanResultsList方法，它的实现如下；

public List<ScanResult> syncGetScanResultsList() {
    synchronized (mScanResultCache) {
        List<ScanResult> scanList = new ArrayList<ScanResult>();
        for(ScanResult result: mScanResults) {
            scanList.add(new ScanResult(result));
        }
        return scanList;
    }
}

上面说到扫描到wifi结果后会把结果存到全局变mScanResults中，所以这里直接把该变量里的值返回去，比较简单。

在8.0上调用getScanResults时，它调用的是WifiScanner的getSingleScanResults方法，它是用mAsyncChannel发送了一个CMD_GET_SINGLE_SCAN_RESULTS的消息；

public List<ScanResult> getSingleScanResults() {
    validateChannel();
    Message reply = mAsyncChannel.sendMessageSynchronously(CMD_GET_SINGLE_SCAN_RESULTS, 0);
    if (reply.what == WifiScanner.CMD_OP_SUCCEEDED) {
        return Arrays.asList(((ParcelableScanResults) reply.obj).getResults());
    }
    OperationResult result = (OperationResult) reply.obj;
    Log.e(TAG, "Error retrieving SingleScan results reason: " + result.reason
            + " description: " + result.description);
    return new ArrayList<ScanResult>();
}

WifiScanningServiceImpl的ClientHandler接受到该消息后会用状态机发消息，mSingleScanStateMachine.sendMessage(Message.obtain(msg))，接着WifiSingleScanStateMachine状态接收到消息后，执行filterCachedScanResultsByAge这个方法来填充数据;

case WifiScanner.CMD_GET_SINGLE_SCAN_RESULTS:
    msg.obj = new WifiScanner.ParcelableScanResults(
        filterCachedScanResultsByAge());
    replySucceeded(msg);
    return HANDLED;

我们来看一下filterCachedScanResultsByAge这个方法；

private ScanResult[] filterCachedScanResultsByAge() {
    // Using ScanResult.timestamp here to ensure that we use the same fields 
    // as WificondScannerImpl for filtering stale results.
    long currentTimeInMillis = mClock.getElapsedSinceBootMillis();
    return mCachedScanResults.stream()
            .filter(scanResult
                    -> ((currentTimeInMillis - (scanResult.timestamp / 1000))
                            < CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS))
            .toArray(ScanResult[]::new);
}

mCachedScanResults存了每一次获得到扫描结果的数据，在每次发广播前进行赋值。CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS是180秒，也就是3分钟，所以3分钟后不发起wifi扫描直接取结果的话得到的是空。

if (results.isAllChannelsScanned()) {
    mCachedScanResults.clear();
    mCachedScanResults.addAll(Arrays.asList(results.getResults()));
    sendScanResultBroadcast(true);
}

接下来就是返回结果了

void replySucceeded(Message msg) {
    if (msg.replyTo != null) {
        Message reply = Message.obtain();
        reply.what = WifiScanner.CMD_OP_SUCCEEDED;
        reply.arg2 = msg.arg2;
        if (msg.obj != null) {
            reply.obj = msg.obj;
        }
        try {
            msg.replyTo.send(reply);
            mLog.trace("replySucceeded recvdMessage=%").c(msg.what).flush();
        } catch (RemoteException e) {
            // There's not much we can do if reply can't be sent!
        }
    } else {
        // locally generated message; doesn't need a reply!
    }
}

会发送一个CMD_OP_SUCCEEDED的消息，WifiScanner接收到该消息后会继续上抛，直到返给WifiManger。

所以8.0新加了一个3分钟的时间限制，即只返回3分钟内的缓存结果，这点在定制Wifi策略的时候需要考虑一下。

六. 总结

本文介绍了wifi扫描和获得结果的流程，我觉得wifi源码要比网络定位复杂一些，网络定位主要是两层client-server调用，而wifi主要是先得搞懂状态模式，状态机这些东西，这样才能知道wifi各种状态是如何切换的，发送了一个消息该由哪个状态去执行。走读源码是深入学习的必经之路，阅读安卓源码的过程，也是学习设计模式的过程，比如谷歌为什么这么设计，为什么需要这么多的类，它是如何做到面向抽象，保持类的功能单一的，这些都值得我们去掌握。感谢大家的阅读，我们下周再见。