Android4.4（MT8685）源码WIFI--扫描和连接

本章主要介绍用户手动的在Settings中点击Scan和Connect按钮，输入密码后的连接过程，先看整体流程图：

WiFi Scan过程分析

当用户进入Settings点击Scan后，就会调用到WifiManager的startScan()方法，当然在Settings里面有设置Scan的定时器，每隔一段时间就会去scan，在Wifi Framework中也有scan的定时器。对照上面的流程图，来看一下WifiManager的startScan()方法：

[java]  view plain copy

1. public boolean startScan(WorkSource workSource) {  
2.     try {  
3.         mService.startScan(workSource);  
4.         return true;  
5.     } catch (RemoteException e) {  
6.         return false;  
7.     }  
8. }  

[java]  view plain copy

1. WifiService.java  
2.     public void startScan(WorkSource workSource) {  
3.         enforceChangePermission();  
4.         if (workSource != null) {  
5.             enforceWorkSourcePermission();  
6.             // WifiManager currently doesn't use names, so need to clear names out of the  
7.             // supplied WorkSource to allow future WorkSource combining.  
8.             workSource.clearNames();  
9.         }  
10.         mWifiStateMachine.startScan(Binder.getCallingUid(), workSource);  
11.     }  

WiFiStateMachine的startScan方法会给自己发送一个CMD_START_SCAN的message，由前面toggle on wifi的知识，这个消息将由DisconnectedState及其父State来处理，从代码中可以很容易的分析到，CMD_START_SCAN将会被DriverStartedState 来处理，进入到处理的代码中：

[java]  view plain copy

1. public boolean processMessage(Message message) {  
2.     switch(message.what) {  
3.         case CMD_START_SCAN:  
4.             noteScanStart(message.arg1, (WorkSource) message.obj);  
5.             startScanNative(WifiNative.SCAN_WITH_CONNECTION_SETUP);  
6.             break;  

noteScanStart是用于通知电量统计用；startScanNative会向wpa_supplicant发送SCAN的命令，当wpa_suppliant执行完SCAN并成功找到一些AP后，就会给WifiMonitor发送CTRL-EVENT-SCAN-RESULTS的event，WifiMonitor会parse出这个event，并向WifiStateMachine发送SCAN_RESULTS_EVENT消息，WifiStateMachine的SupplicantStartedState会处理这个消息，如下：

[java]  view plain copy

1. case WifiMonitor.SCAN_RESULTS_EVENT:  
2.     setScanResults();  
3.     sendScanResultsAvailableBroadcast();  
4.     mScanResultIsPending = false;  
5.     break;  

这里主要做了两件事，一是去获取scanResults，另外会发送一个广播信息出去，如果有检测这个广播的receive收到这个广播后，就可以调用函数去获取到scanResults并显示到listview上面，例如WifiSettings。进入到setScanResults里面来分析：

[java]  view plain copy

1. private void setScanResults() {  
2.   
3.     while (true) {  
4.         tmpResults = mWifiNative.scanResults(sid);  
5.         if (TextUtils.isEmpty(tmpResults)) break;  
6.         scanResultsBuf.append(tmpResults);  
7.         scanResultsBuf.append("\n");  
8.         String[] lines = tmpResults.split("\n");  
9.         sid = -1;  
10.         for (int i=lines.length - 1; i >= 0; i--) {  
11.             if (lines[i].startsWith(END_STR)) {  
12.                 break;  
13.             } else if (lines[i].startsWith(ID_STR)) {  
14.                 try {  
15.                     sid = Integer.parseInt(lines[i].substring(ID_STR.length())) + 1;  
16.                 } catch (NumberFormatException e) {  
17.                     // Nothing to do  
18.                 }  
19.                 break;  
20.             }  
21.         }  
22.         if (sid == -1) break;  
23.     }  
24.   
25.     scanResults = scanResultsBuf.toString();  
26.     if (TextUtils.isEmpty(scanResults)) {  
27.        return;  
28.     }  
29.   
30.     synchronized(mScanResultCache) {  
31.   
32.         for (String line : lines) {  
33.             if (line.startsWith(BSSID_STR)) {  
34.                 bssid = new String(line.getBytes(), bssidStrLen, line.length() - bssidStrLen);  
35.             } else if (line.startsWith(FREQ_STR)) {  
36.                 try {  
37.                     freq = Integer.parseInt(line.substring(FREQ_STR.length()));  
38.                 } catch (NumberFormatException e) {  
39.                     freq = 0;  
40.                 }  
41.             }  
42.             else if (line.startsWith(SSID_STR)) {  
43.                 wifiSsid = WifiSsid.createFromAsciiEncoded(  
44.                         line.substring(SSID_STR.length()));  
45.             } else if (line.startsWith(DELIMITER_STR) || line.startsWith(END_STR)) {  
46.                 if (bssid != null) {  
47.                     String ssid = (wifiSsid != null) ? wifiSsid.toString() : WifiSsid.NONE;  
48.                     String key = bssid + ssid;  
49.                     ScanResult scanResult = mScanResultCache.get(key);  
50.                     if (scanResult != null) {  
51.                         scanResult.level = level;  
52.                         scanResult.wifiSsid = wifiSsid;  
53.                         // Keep existing API  
54.                         scanResult.SSID = (wifiSsid != null) ? wifiSsid.toString() :  
55.                                 WifiSsid.NONE;  
56.                         scanResult.capabilities = flags;  
57.                         scanResult.frequency = freq;  
58.                         scanResult.timestamp = tsf;  
59.                     } else {  
60.                         scanResult =  
61.                             new ScanResult(  
62.                                     wifiSsid, bssid, flags, level, freq, tsf);  
63.                         mScanResultCache.put(key, scanResult);  
64.                     }  
65.                     mScanResults.add(scanResult);  
66.                 }  

这个函数看起来比较复杂，其实仔细分析，它只是循环的parse从WifiNative获取到AP列表信息，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
    ####

当所有的结果都被parse出来后，会被存到mScanResults这个ArrayList当中，另外会用bssid+ssid做key值，将这个scanResult存到mScanResultCache这个LRU（最近最少使用） cache当中。当然随着wifi driver不断的scan，发现新的AP，mScanResults和mScanResultCache中的数据也在不断的变化。

当应用程序收到sendScanResultsAvailableBroadcast发送的WifiManager.SCAN_RESULTS_AVAILABLE_ACTION这个broadcast后，就可以去获取上面提供的mScanResults信息了，获取过程很简单，直接复制mScanResults这个ArrayList里面的成员，然后返回。，值得注意的是，sendScanResultsAvailableBroadcast设置了Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT这个属性，所以只有动态注册的broadcastReceive才会收到这个broadcast。

连接AP的流程

当用户点击AP列表中一项并输入正确的密码后，就可以开始AP的连接过程了，主要调用的是WifiManager的connect函数，如下：

[java]  view plain copy

1. public void connect(WifiConfiguration config, ActionListener listener) {  
2.     if (config == null) throw new IllegalArgumentException("config cannot be null");  
3.     validateChannel();  
4.     // Use INVALID_NETWORK_ID for arg1 when passing a config object  
5.     // arg1 is used to pass network id when the network already exists  
6.     sAsyncChannel.sendMessage(CONNECT_NETWORK, WifiConfiguration.INVALID_NETWORK_ID,  
7.             putListener(listener), config);  
8. }  

其中第一个参数WifiConfiguration是当前需要连接的AP的配置信息，包括SSID、BSSID、密码以及加密方式等信息；ActionListern作为callback来通知客户程序connect方法是否调用成功，这里的调用成功只是指参数是否正确，并不表示AP是否连接成功。由前面介绍的AsyncChannel的知识，到WifiService中去看看如果处理CONNECT_NETWORK这个消息：

[java]  view plain copy

1. case WifiManager.CONNECT_NETWORK:  
2. case WifiManager.SAVE_NETWORK: {  
3.     WifiConfiguration config = (WifiConfiguration) msg.obj;  
4.     int networkId = msg.arg1;  
5.     if (config != null && config.isValid()) {  
6.         // This is restricted because there is no UI for the user to  
7.         // monitor/control PAC.  
8.         if (config.proxySettings != ProxySettings.PAC) {  
9.             if (DBG) Slog.d(TAG, "Connect with config" + config);  
10.             mWifiStateMachine.sendMessage(Message.obtain(msg));  
11.         } reak;  
12. }  

WifiService将这个消息传递给WifiStateMachine处理，由前面介绍的Scan的知识，这时候WifiStateMachine的ConnectModeState将处理CONNECT_NETWORK这个消息，代码如下：

[java]  view plain copy

1. case WifiManager.CONNECT_NETWORK:  
2.      
3.     int netId = message.arg1;  
4.     config = (WifiConfiguration) message.obj;  
5.   
6.     /* Save the network config */  
7.     if (config != null) {  
8.         NetworkUpdateResult result = mWifiConfigStore.saveNetwork(config);  
9.         netId = result.getNetworkId();  
10.     }  
11.   
12.     if (mWifiConfigStore.selectNetwork(netId) &&  
13.             mWifiNative.reconnect()) {  
14.         /* The state tracker handles enabling networks upon completion/failure */  
15.         mSupplicantStateTracker.sendMessage(WifiManager.CONNECT_NETWORK);  
16.         replyToMessage(message, WifiManager.CONNECT_NETWORK_SUCCEEDED);  
17.         /* Expect a disconnection from the old connection */  
18.         transitionTo(mDisconnectingState);  
19.     }  
20.     break;  

这里主要调用了下面几个函数来进行AP的连接：WifiConfigStore.saveNetwok(config)将AP的配置信息写入到wpa_supplicant.conf中；WifiConfigStore.selectNetwork(netId)用于enable即将要连接的AP，而disable掉其它的AP；WifiNative.reconnect()发起重新连接的请求给wpa_supplicant。接着transition到DisconnectingState中，来看看DisconnectingState，这个状态code比较少：

[java]  view plain copy

1. class DisconnectingState extends State {  
2.     @Override  
3.     public boolean processMessage(Message message) {  
4.         switch (message.what) {  
5.             case CMD_SET_OPERATIONAL_MODE:  
6.                 if (message.arg1 != CONNECT_MODE) {  
7.                     deferMessage(message);  
8.                 }  
9.                 break;  
10.             case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:  
11.                 /* If we get a SUPPLICANT_STATE_CHANGE_EVENT before NETWORK_DISCONNECTION_EVENT 
12.                  * we have missed the network disconnection, transition to mDisconnectedState 
13.                  * and handle the rest of the events there 
14.                  */  
15.                 deferMessage(message);  
16.                 handleNetworkDisconnect();  
17.                 transitionTo(mDisconnectedState);  
18.                 break;  
19.             default:  
20.                 return NOT_HANDLED;  
21.         }  
22.         return HANDLED;  
23.     }  
24. }  

当执行完WifiNative.reconnect()，wpa_supplicant会不断的往WifiMonitor发送包括CTRL-EVENT-STATE-CHANGE、ASSOCIATING、ASSOCIATED、FOUR_WAY_HANDSHARK、GROUP_HANDSHARK等event，WifiMonitor会不断的去parse这些event并向WifiStatemachine发送消息，其中一个比较重要的消息就是当wpa_supplicant的状态改变是会发送WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT，上面的DisconnectiongState 收到这个消息后，会transition到DisconnectedState。

当Wifi和AP之间已经连接成功后，就会收到wpa_supplicant发送上来的CTRL-EVENT-CONNECTED这个event，WifiMonitor收到这个消息后，会向WifiStateMachine发送NETWORK_CONNECTION_EVENT表示已经和AP之间成功的连线，WifiStateMachine的ConnectModeState会来处理这个消息，代码如下：

[java]  view plain copy

1. case WifiMonitor.NETWORK_CONNECTION_EVENT:  
2.     if (DBG) log("Network connection established");  
3.     mLastNetworkId = message.arg1;  
4.     mLastBssid = (String) message.obj;  
5.   
6.     mWifiInfo.setBSSID(mLastBssid);  
7.     mWifiInfo.setNetworkId(mLastNetworkId);  
8.     /* send event to CM & network change broadcast */  
9.     setNetworkDetailedState(DetailedState.OBTAINING_IPADDR);  
10.     sendNetworkStateChangeBroadcast(mLastBssid);  
11.     transitionTo(mObtainingIpState);  
12.     break;  

WifiStateMachine处理完这个消息后，会跳转到ObtainingIpState，进到到ObtainingIpState的enter函数看看：

[java]  view plain copy

1. class ObtainingIpState extends State {  
2.     @Override  
3.     public void enter() {  
4.         if (!mWifiConfigStore.isUsingStaticIp(mLastNetworkId)) {  
5.             // TODO: If we're switching between static IP configuration and DHCP, remove the  
6.             // static configuration first.  
7.             startDhcp();  
8.         } else {  
9.             // stop any running dhcp before assigning static IP  
10.             stopDhcp();  
11.             DhcpResults dhcpResults = new DhcpResults(  
12.                     mWifiConfigStore.getLinkProperties(mLastNetworkId));  
13.             InterfaceConfiguration ifcg = new InterfaceConfiguration();  
14.             Iterator<LinkAddress> addrs =  
15.                     dhcpResults.linkProperties.getLinkAddresses().iterator();  
16.             if (!addrs.hasNext()) {  
17.                 loge("Static IP lacks address");  
18.                 sendMessage(CMD_STATIC_IP_FAILURE);  
19.             } else {  
20.                 ifcg.setLinkAddress(addrs.next());  
21.                 ifcg.setInterfaceUp();  
22.                 try {  
23.                     mNwService.setInterfaceConfig(mInterfaceName, ifcg);  
24.                     if (DBG) log("Static IP configuration succeeded");  
25.                     sendMessage(CMD_STATIC_IP_SUCCESS, dhcpResults);  
26.                 } catch (RemoteException re) {  
27.                     loge("Static IP configuration failed: " + re);  
28.                     sendMessage(CMD_STATIC_IP_FAILURE);  
29.                 } catch (IllegalStateException e) {  
30.                     loge("Static IP configuration failed: " + e);  
31.                     sendMessage(CMD_STATIC_IP_FAILURE);  
32.                 }  
33.             }  
34.         }  
35.     }  

ObtainingIpState就是获取IP的状态，这里分为两种获取IP的方式，一种是用户静态配置的，另一种是通过DHCP动态分配。这里只看动态分配的，进到到startDhcp去分析：

[java]  view plain copy

1. void startDhcp() {  
2.     if (mDhcpStateMachine == null) {  
3.         mDhcpStateMachine = DhcpStateMachine.makeDhcpStateMachine(  
4.                 mContext, WifiStateMachine.this, mInterfaceName);  
5.   
6.     }  
7.     mDhcpStateMachine.registerForPreDhcpNotification();  
8.     mDhcpStateMachine.sendMessage(DhcpStateMachine.CMD_START_DHCP);  
9. }  

首先去创建DhcpStateMachine的实例，然后向它发送一个CMD_START_DHCP的命令，DhcpStateMachine初始化完毕后，收到这个消息就会马上向WifiStateMachine发送CMD_PRE_DHCP_ACTION表示DhcpStateMachine马上就要开始发送discovery或者renew的封包了，来看WifiStateMachine收到这个消息的处理：

[java]  view plain copy

1. public boolean processMessage(Message message) {  
2.     switch (message.what) {  
3.       case DhcpStateMachine.CMD_PRE_DHCP_ACTION:  
4.           handlePreDhcpSetup();  
5.           break;  
6.       case DhcpStateMachine.CMD_POST_DHCP_ACTION:  
7.           handlePostDhcpSetup();  
8.           if (message.arg1 == DhcpStateMachine.DHCP_SUCCESS) {  
9.               if (DBG) log("DHCP successful");  
10.               handleSuccessfulIpConfiguration((DhcpResults) message.obj);  
11.               transitionTo(mVerifyingLinkState);  
12.           } else if (message.arg1 == DhcpStateMachine.DHCP_FAILURE) {  
13.               if (DBG) log("DHCP failed");  
14.               handleFailedIpConfiguration();  
15.               transitionTo(mDisconnectingState);  
16.           }  
17.           break;  

在处理完CMD_PRE_DHCP_ACTION后，WifiStateMachine会向DhcpStateMachine发送CMD_PRE_DHCP_ACTION_COMPLETE，用于指示前期准备工作已经做好了，这是就可以开始dhcp的discovery/reponse了，用于两端来获取IP，当IP成功获取后，DhcpStateMachine会给WifiStateMachine发送CMD_POST_DHCP_ACTION消息，其中arg1表示是成功还是失败，如果成功，就会调用handleSuccessfulIpConfiguration来处理，并transition 到VerifyingLinkState中；如果失败则会transition到DisconectingState中。这里只看成功获取IP的情况，进入到VerifyingLinkState中：

[java]  view plain copy

1. class VerifyingLinkState extends State {  
2.     @Override  
3.     public void enter() {  
4.         log(getName() + " enter");  
5.         setNetworkDetailedState(DetailedState.VERIFYING_POOR_LINK);  
6.         mWifiConfigStore.updateStatus(mLastNetworkId, DetailedState.VERIFYING_POOR_LINK);  
7.         sendNetworkStateChangeBroadcast(mLastBssid);  
8.     }  
9.     @Override  
10.     public boolean processMessage(Message message) {  
11.         switch (message.what) {  
12.             case WifiWatchdogStateMachine.POOR_LINK_DETECTED:  
13.                 //stay here  
14.                 log(getName() + " POOR_LINK_DETECTED: no transition");  
15.                 break;  
16.             case WifiWatchdogStateMachine.GOOD_LINK_DETECTED:  
17.                 log(getName() + " GOOD_LINK_DETECTED: transition to captive portal check");  
18.                 transitionTo(mCaptivePortalCheckState);  
19.                 break;  
20.             default:  
21.                 if (DBG) log(getName() + " what=" + message.what + " NOT_HANDLED");  
22.                 return NOT_HANDLED;  
23.         }  
24.         return HANDLED;  
25.     }  
26. }  

在VerifyingLinkState主要是来验证当前连接状况的，主要方式是通过统计信号强度以及丢包率，这些工作是交给WifiWatchdogStateMachine来做的，当WifiAP的信号强度增强或者变弱，会发送两种消息给WifiStateMachine，一种是WifiWatchdogStateMachine.GOOD_LINK_DETECTED，另一种是WifiWatchdogStateMachine.POOR_LINK_DETECTED。当收到GOOD_LINK_DETECTED消息后，就会跳转到CaptivePortalCheckState中；当收到的是POOR_LINK_DETECTED，则维持原来的状态不变。我们跳转到CaptivePortalCheckState去分析：

[java]  view plain copy

1. class CaptivePortalCheckState extends State {  
2.     @Override  
3.     public void enter() {  
4.         log(getName() + " enter");  
5.         setNetworkDetailedState(DetailedState.CAPTIVE_PORTAL_CHECK);  
6.         mWifiConfigStore.updateStatus(mLastNetworkId, DetailedState.CAPTIVE_PORTAL_CHECK);  
7.         sendNetworkStateChangeBroadcast(mLastBssid);  
8.     }  
9.     @Override  
10.     public boolean processMessage(Message message) {  
11.         switch (message.what) {  
12.             case CMD_CAPTIVE_CHECK_COMPLETE:  
13.                 log(getName() + " CMD_CAPTIVE_CHECK_COMPLETE");  
14.                 try {  
15.                     mNwService.enableIpv6(mInterfaceName);  
16.                 } catch (RemoteException re) {  
17.                     loge("Failed to enable IPv6: " + re);  
18.                 } catch (IllegalStateException e) {  
19.                     loge("Failed to enable IPv6: " + e);  
20.                 }  
21.                 setNetworkDetailedState(DetailedState.CONNECTED);  
22.                 mWifiConfigStore.updateStatus(mLastNetworkId, DetailedState.CONNECTED);  
23.                 sendNetworkStateChangeBroadcast(mLastBssid);  
24.                 transitionTo(mConnectedState);  
25.                 break;  
26.             default:  
27.                 return NOT_HANDLED;  
28.         }  
29.         return HANDLED;  
30.     }  
31. }  

首先会发送CAPTIVE_PORTAL_CHECK的broadcast，这个会被WifiStateTracker接收并处理，然后调用ConnectivityService的接口去处理captive portal相关的内容，与captive portal相关的只是可以参考：http://en.wikipedia.org/wiki/Captive_portal

当ConnectivityService完成captive portal check后，就会给WifiStateMachine发送CMD_CAPTIVE_CHECK_COMPLETE消息，就会跳转到ConnectedState表示连接过程的结束了。