Android WiFi Toggle ON/OFF流程分析

转自： http://blog.csdn.net/lilian0118/article/details/22376059

WiFi toggled on流程分析

这一章来分析一下从Settings打开wifi后，framework所有的流程以及状态转换，调用的主要函数就是WiFiMananger的setWifiEnabled(boolean enabled)，这个函数在前面介绍的WifiService启动流程中也有提到，当SystemServer 创建了个WifiService后，就会调用它的checkAndStartWifi，在这个函数里面，也同样会调用到setWifiEnabled(boolean enabled)，这是为了恢复用户在开机之前的wifi状态。下面来详细分析WifiMananger的setWifiEnabled函数。先来看看总体的流程图

对照上面的流程图，我们从WifiMananger的setWifiEnabled来分析一下代码：

[java] view plaincopy

1. public boolean setWifiEnabled(boolean enabled) {  
2.     try {  
3.         return mService.setWifiEnabled(enabled);  
4.     } catch (RemoteException e) {  
5.         return false;  
6.     }  
7. }  

[java] view plaincopy

1. WifiService.java  
2.     public synchronized boolean setWifiEnabled(boolean enable) {  
3.         enforceChangePermission();  
4.         Slog.d(TAG, "setWifiEnabled: " + enable + " pid=" + Binder.getCallingPid()  
5.                     + ", uid=" + Binder.getCallingUid());  
6.         if (DBG) {  
7.             Slog.e(TAG, "Invoking mWifiStateMachine.setWifiEnabled\n");  
8.         }  
9.   
10.         /* 
11.         * Caller might not have WRITE_SECURE_SETTINGS, 
12.         * only CHANGE_WIFI_STATE is enforced 
13.         */  
14.   
15.         long ident = Binder.clearCallingIdentity();  
16.         try {  
17.             if (! mSettingsStore.handleWifiToggled(enable)) {  
18.                 // Nothing to do if wifi cannot be toggled  
19.                 return true;  
20.             }  
21.         } finally {  
22.             Binder.restoreCallingIdentity(ident);  
23.         }  
24.   
25.         mWifiController.sendMessage(CMD_WIFI_TOGGLED);  
26.         return true;  
27.     }  

在WifiService里面，先把传进来的参数写到WifiSettingsStore里面，WifiSettingsStore调用Settings提供的ContentProviders写到Sqlite的DB里面，所以我们看到mWifiController.sendMessage(CMD_WIFI_TOGGLED)是没有把这个参数传递过去的。接着去看WifiController里面如何处理CMD_WIFI_TOGGLED，由前面的WifiService启动流程分析，我们知道CMD_WIFI_TOGGLED将由WifiController的ApStaDisabledState来处理：

[java] view plaincopy

1. class ApStaDisabledState extends State {  
2.     private int mDeferredEnableSerialNumber = 0;  
3.     private boolean mHaveDeferredEnable = false;  
4.     private long mDisabledTimestamp;  
5.   
6.     @Override  
7.     public void enter() {  
8.         mWifiStateMachine.setSupplicantRunning(false);  
9.         // Supplicant can't restart right away, so not the time we switched off  
10.         mDisabledTimestamp = SystemClock.elapsedRealtime();  
11.         mDeferredEnableSerialNumber++;  
12.         mHaveDeferredEnable = false;  
13.     }  
14.     @Override  
15.     public boolean processMessage(Message msg) {  
16.         switch (msg.what) {  
17.             case CMD_WIFI_TOGGLED:  
18.             case CMD_AIRPLANE_TOGGLED:  
19.                 if (mSettingsStore.isWifiToggleEnabled()) {  
20.                     if (doDeferEnable(msg)) {  
21.                         if (mHaveDeferredEnable) {  
22.                             //  have 2 toggles now, inc serial number an ignore both  
23.                             mDeferredEnableSerialNumber++;  
24.                         }  
25.                         mHaveDeferredEnable = !mHaveDeferredEnable;  
26.                         break;  
27.                     }  
28.                     if (mDeviceIdle == false) {  
29.                         transitionTo(mDeviceActiveState);  
30.                     } else {  
31.                         checkLocksAndTransitionWhenDeviceIdle();  
32.                     }  
33.                 }  
34.                 break;  

WifiController的ApStaDisabledState的处理很简单，只是简单的transition到DeviceActiveState，因为DeviceActiveState的父State是StaEnabledState，由StateMachine的知识，我们先到StaEnabledState和DeviceActiveState的enter()函数来看看：

[java] view plaincopy

1. class StaEnabledState extends State {  
2.     @Override  
3.     public void enter() {  
4.         mWifiStateMachine.setSupplicantRunning(true);  
5.     }  
6.   
7. class DeviceActiveState extends State {  
8.     @Override  
9.     public void enter() {  
10.         mWifiStateMachine.setOperationalMode(WifiStateMachine.CONNECT_MODE);  
11.         mWifiStateMachine.setDriverStart(true);  
12.         mWifiStateMachine.setHighPerfModeEnabled(false);  
13.     }  

上面分别是调用WifiStateMachine的四个函数，这四个函数都是给WifiStateMachine发送四个消息，分别是CMD_START_SUPPLICANT、SET_OPERATIONAL_MODE、CMD_START_DRIVER和SET_HTGH_PERF_MODE，如上图中的Figure 1所示。接着我们到WifiStateMachine的InitialState中去看看如何处理CMD_START_SUPPLICANT：

[java] view plaincopy

1. public boolean processMessage(Message message) {  
2.     switch (message.what) {  
3.         case CMD_START_SUPPLICANT:  
4.             if (mWifiNative.loadDriver()) {  
5.                 try {  
6.                     mNwService.wifiFirmwareReload(mInterfaceName, "STA");  
7.                 } catch (Exception e) {  
8.                     loge("Failed to reload STA firmware " + e);  
9.                     // continue  
10.                 }  
11.   
12.                 try {  
13.                     mNwService.disableIpv6(mInterfaceName);  
14.                 } catch (RemoteException re) {  
15.                     loge("Unable to change interface settings: " + re);  
16.                 } catch (IllegalStateException ie) {  
17.                     loge("Unable to change interface settings: " + ie);  
18.                 }  
19.   
20.                 mWifiMonitor.killSupplicant(mP2pSupported);  
21.                 if(mWifiNative.startSupplicant(mP2pSupported)) {  
22.                     setWifiState(WIFI_STATE_ENABLING);  
23.                     if (DBG) log("Supplicant start successful");  
24.                     mWifiMonitor.startMonitoring();  
25.                     transitionTo(mSupplicantStartingState);  
26.                 } else {  
27.                     loge("Failed to start supplicant!");  
28.                 }  
29.             } else {  
30.                 loge("Failed to load driver");  
31.             }  
32.             break;  

这里主要调用WifiNative的loadDriver和startSupplicant两个函数去加载wifi driver和启动wpa_supplicant，当启动成功wpa_supplicant后，就会调用WifiMonitor的startMonitoring去和wpa_supplicant建立socket连接，并不断的从wpa_supplicant收event。wpa_supplicant是一个独立的运行程序，它和应用程序之间通过socket来通信，主要存在两个socket连接，一个用来向wpa_supplicant发送命令，另一个是wpa_supplicant用来向应用程序通知event，应用程序在收到event后可以知道当前的连接状态来进行下一步动作。我们进入到WifiMonitor.startMonitoring这个函数看看：

[java] view plaincopy

1. public synchronized void startMonitoring(String iface) {  
2.     WifiMonitor m = mIfaceMap.get(iface);  
3.     if (m == null) {  
4.         Log.e(TAG, "startMonitor called with unknown iface=" + iface);  
5.         return;  
6.     }  
7.   
8.     Log.d(TAG, "startMonitoring(" + iface + ") with mConnected = " + mConnected);  
9.   
10.     if (mConnected) {  
11.         m.mMonitoring = true;  
12.         m.mWifiStateMachine.sendMessage(SUP_CONNECTION_EVENT);  
13.     } else {  
14.         if (DBG) Log.d(TAG, "connecting to supplicant");  
15.         int connectTries = 0;  
16.         while (true) {  
17.             if (mWifiNative.connectToSupplicant()) {  
18.                 m.mMonitoring = true;  
19.                 m.mWifiStateMachine.sendMessage(SUP_CONNECTION_EVENT);  
20.                 new MonitorThread(mWifiNative, this).start();  
21.                 mConnected = true;  
22.                 break;  
23.             }  
24.             if (connectTries++ < 5) {  
25.                 try {  
26.                     Thread.sleep(1000);  
27.                 } catch (InterruptedException ignore) {  
28.                 }  
29.             } else {  
30.                 mIfaceMap.remove(iface);  
31.                 m.mWifiStateMachine.sendMessage(SUP_DISCONNECTION_EVENT);  
32.                 Log.e(TAG, "startMonitoring(" + iface + ") failed!");  
33.                 break;  
34.             }  
35.         }  
36.     }  
37. }  

这个方法里面主要调用WifiNative的connenctToSupplicant去和wpa_supplicant建立socket连接，然后给WifiStateMachine发送一个SUP_CONNECTION_EVENT消息，最后新建一个MonitorThread运行，MonitorThread就是一个循环，不断的从wpa_supplicant收event，然后进行解析，并dispatch到不同的函数去处理，后面我们再来分析MonitorThread的流程。回到WifiStateMachine的InitialState中去看看如何处理CMD_START_SUPPLICANT的流程中来，当startMonitoring结束后，WifiStateMachine就跳转到SupplicantStartingState，这时的WifiStateMachine和MessageQueue里面的消息队列上图中的Figure 2。

接着来看当WifiStateMachine处理完SUP_CONNECTION_EVENT消息后，马上会收到SET_OPERATIONAL_MODE和CMD_START_DRIVER消息，这两个消息都会被SupplicantStartingState延迟处理，SET_HTGH_PERF_MODE会被DefaultState处理。接着SupplicantStartingState会收到SUP_CONNECTION_EVENT，处理代码如下：

[java] view plaincopy

1. public boolean processMessage(Message message) {  
2.     switch(message.what) {  
3.         case WifiMonitor.SUP_CONNECTION_EVENT:  
4.             if (DBG) log("Supplicant connection established");  
5.             setWifiState(WIFI_STATE_ENABLED);  
6.             mSupplicantRestartCount = 0;  
7.             /* Reset the supplicant state to indicate the supplicant 
8.              * state is not known at this time */  
9.             mSupplicantStateTracker.sendMessage(CMD_RESET_SUPPLICANT_STATE);  
10.             /* Initialize data structures */  
11.             mLastBssid = null;  
12.             mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;  
13.             mLastSignalLevel = -1;  
14.   
15.             mWifiInfo.setMacAddress(mWifiNative.getMacAddress());  
16.             mWifiConfigStore.loadAndEnableAllNetworks();  
17.             initializeWpsDetails();  
18.   
19.             sendSupplicantConnectionChangedBroadcast(true);  
20.             transitionTo(mDriverStartedState);  
21.             break;  

在SUP_CONNECTION_EVENT的处理流程中，主要是调用WifiConfigStore的loadAndEnableAllNetworks函数来加载并enable用户之前连接过并保存的AP，然后会初始化一些Wps相关的信息，最后transition到DriverStartedState上，如上图的Figure 3。再来看DriverStartedState的enter函数，这里面有一些重要的流程：

[java] view plaincopy

1. class DriverStartedState extends State {  
2.     @Override  
3.     public void enter() {  
4.   
5.         /* set country code */  
6.         setCountryCode();  
7.         /* set frequency band of operation */  
8.         setFrequencyBand();  
9.         /* initialize network state */  
10.         setNetworkDetailedState(DetailedState.DISCONNECTED);  
11.   
12.         mDhcpActive = false;  
13.   
14.         startBatchedScan();  
15.   
16.         if (mOperationalMode != CONNECT_MODE) {  
17.             mWifiNative.disconnect();  
18.             mWifiConfigStore.disableAllNetworks();  
19.             if (mOperationalMode == SCAN_ONLY_WITH_WIFI_OFF_MODE) {  
20.                 setWifiState(WIFI_STATE_DISABLED);  
21.             }  
22.             transitionTo(mScanModeState);  
23.         } else {  
24.             /* Driver stop may have disabled networks, enable right after start */  
25.             mWifiConfigStore.enableAllNetworks();  
26.   
27.             if (DBG) log("Attempting to reconnect to wifi network ..");  
28.             mWifiNative.reconnect();  
29.   
30.             // Status pulls in the current supplicant state and network connection state  
31.             // events over the monitor connection. This helps framework sync up with  
32.             // current supplicant state  
33.             mWifiNative.status();  
34.             transitionTo(mDisconnectedState);  
35.         }  

[java] view plaincopy

1.   

[java] view plaincopy

1.             if (mP2pSupported) {  
2.                 if (mOperationalMode == CONNECT_MODE) {  
3.                     mWifiP2pChannel.sendMessage(WifiStateMachine.CMD_ENABLE_P2P);  
4.                 } else {  
5.                     // P2P statemachine starts in disabled state, and is not enabled until  
6.                     // CMD_ENABLE_P2P is sent from here; so, nothing needs to be done to  
7.                     // keep it disabled.  
8.                 }  
9.             }  
10.   
11.         }  

enter函数的代码比较多，上面是精简后的代码，上面主要分为两条分支，一是OperationalMode != CONNECT_MODE，一种是OperationalMode = CONNECT_MODE，根据官方的解释，OperationalMode一共有三种，分别如下：

1.CONNECT_MODE，这种模式下，STA可以scan并连接热点

2.SCAN_ONLY_MODE，这种模式下，STA只能扫描热点

3.SCAN_ONLY_WIFI_OFF_MODE，在这种模式下，当wifi是toggle off的情况下，也可以进行scan

这三种模式默认的是CONNECT_MODE，后面两种模式现在用到的不多，但按照Google的设计，后面可能会有很多的app会用到，比如利用热点来进行点位，这个应用其实这需要能够scan，并不需要链接热点。那我们接看这OperationalMode = CONNECT_MODE的流程，它直接transition 到DisconnectedState，如上图中的Figure 4，在transition到DisconnectedState之前，还会向WifiNative下reconnect的命令，用于重新连接上次连接但没有forget的AP，即开机后自动连上AP。如平台支持P2P，这里还将会给WifiP2pService发送CMD_ENABLE_P2P的消息，以后在学习P2P模块的时候再来分析。

到这里，Wifi toggle on的流程就分析完了。

WiFi toggled off流程分析

和Wifi toggle on的流程一样，当用户从Settings关闭wifi时，会调用WiFiMananger的setWifiEnabled(false)，接着WifiService会给WifiController发送一个CMD_WIFI_TOGGLED消息，由前面启动Wifi的流程来看，StaEabledState会处理这个消息，先看看整体的流程图：

进入到StaEabledState的processMessage来看看代码流程：

[java] view plaincopy

1. public boolean processMessage(Message msg) {  
2.     switch (msg.what) {  
3.         case CMD_WIFI_TOGGLED:  
4.             if (! mSettingsStore.isWifiToggleEnabled()) {  
5.                 if (mSettingsStore.isScanAlwaysAvailable()) {  
6.                     transitionTo(mStaDisabledWithScanState);  
7.                 } else {  
8.                     transitionTo(mApStaDisabledState);  
9.                 }  
10.             }  
11.             break;  

WifiController会transition 到ApStaDisabledState中，这样WifiController这个状态机就回到的最开始的初始状态了，进到ApStaDisabledState的enter函数分析如何对WifiStateMachine这个状态机做处理：

[java] view plaincopy

1. class ApStaDisabledState extends State {  
2.     private int mDeferredEnableSerialNumber = 0;  
3.     private boolean mHaveDeferredEnable = false;  
4.     private long mDisabledTimestamp;  
5.   
6.     @Override  
7.     public void enter() {  
8.         mWifiStateMachine.setSupplicantRunning(false);  
9.         // Supplicant can't restart right away, so not the time we switched off  
10.         mDisabledTimestamp = SystemClock.elapsedRealtime();  
11.         mDeferredEnableSerialNumber++;  
12.         mHaveDeferredEnable = false;  
13.     }  

这里主要调用WifiStateMachine的setSupplicantRunning(false)，这个函数直接给WifiStateMachine发送一个CMD_STOP_SUPPLICAN消息，由前面的知识，我们知道SupplicantStartedState会处理这个消息，进到具体代码中分析：

[java] view plaincopy

1. public boolean processMessage(Message message) {  
2.     switch(message.what) {  
3.         case CMD_STOP_SUPPLICANT:   /* Supplicant stopped by user */  
4.             if (mP2pSupported) {  
5.                 transitionTo(mWaitForP2pDisableState);  
6.             } else {  
7.                 transitionTo(mSupplicantStoppingState);  
8.             }  
9.             break;  

如果平台支持P2P，这里会跳转到WaitForP2pDisableState中，如果不支持则会跳转到SupplicantStoppingState中。这里我们看mP2pSupported为true的情况，因为现在大多数平台都应该支持P2P了，另外，在WaitForP2pDisableState中处理完P2P相关的内容后，也会跳转到SupplicantStoppingState中来。我们来分析WaitForP2pDisableState的enter函数：

[java] view plaincopy

1. class WaitForP2pDisableState extends State {  
2.     private State mTransitionToState;  
3.     @Override  
4.     public void enter() {  
5.         switch (getCurrentMessage().what) {  
6.             case WifiMonitor.SUP_DISCONNECTION_EVENT:  
7.                 mTransitionToState = mInitialState;  
8.                 break;  
9.             case CMD_DELAYED_STOP_DRIVER:  
10.                 mTransitionToState = mDriverStoppingState;  
11.                 break;  
12.             case CMD_STOP_SUPPLICANT:  
13.                 mTransitionToState = mSupplicantStoppingState;  
14.                 break;  
15.             default:  
16.                 mTransitionToState = mDriverStoppingState;  
17.                 break;  
18.         }  
19.         mWifiP2pChannel.sendMessage(WifiStateMachine.CMD_DISABLE_P2P_REQ);  
20.     }  
21.     @Override  
22.     public boolean processMessage(Message message) {  
23.         switch(message.what) {  
24.             case WifiStateMachine.CMD_DISABLE_P2P_RSP:  
25.                 transitionTo(mTransitionToState);  
26.                 break;  

mTransitionToState根据当前处理消息的不同种类，记录下次将要跳转到的State信息，然后给WifiP2pService发送一个CMD_DISABLE_P2P_REQ消息，P2P的内容后面再来分析，当P2P处理完CMD_DISABLE_P2P_REQ后，就会给WifiStateMachine发送一个CMD_DISABLE_P2P_RSP消息，在WaitForP2pDisableState收到这个消息后，就会跳转到SupplicantStoppingState中，再到这个函数的enter去看看：

[java] view plaincopy

1. class SupplicantStoppingState extends State {  
2.     @Override  
3.     public void enter() {  
4.         /* Send any reset commands to supplicant before shutting it down */  
5.         handleNetworkDisconnect();  
6.         if (mDhcpStateMachine != null) {  
7.             mDhcpStateMachine.doQuit();  
8.         }  
9.   
10.         if (DBG) log("stopping supplicant");  
11.         mWifiMonitor.stopSupplicant();  
12.   
13.         /* Send ourselves a delayed message to indicate failure after a wait time */  
14.         sendMessageDelayed(obtainMessage(CMD_STOP_SUPPLICANT_FAILED,  
15.                 ++mSupplicantStopFailureToken, 0), SUPPLICANT_RESTART_INTERVAL_MSECS);  
16.         setWifiState(WIFI_STATE_DISABLING);  
17.         mSupplicantStateTracker.sendMessage(CMD_RESET_SUPPLICANT_STATE);  
18.     }  
19.     @Override  
20.     public boolean processMessage(Message message) {  
21.         switch(message.what) {  
22.             case WifiMonitor.SUP_CONNECTION_EVENT:  
23.                 loge("Supplicant connection received while stopping");  
24.                 break;  
25.             case WifiMonitor.SUP_DISCONNECTION_EVENT:  
26.                 if (DBG) log("Supplicant connection lost");  
27.                 handleSupplicantConnectionLoss();  
28.                 transitionTo(mInitialState);  
29.                 break;  
30.             case CMD_STOP_SUPPLICANT_FAILED:  
31.                 if (message.arg1 == mSupplicantStopFailureToken) {  
32.                     loge("Timed out on a supplicant stop, kill and proceed");  
33.                     handleSupplicantConnectionLoss();  
34.                     transitionTo(mInitialState);  
35.                 }  
36.                 break;  

在SupplicantStoppingState主要调用handleNetworkDisconnect和stopSupplicant函数，handleNetworkDisconnect主要工作是停掉stopDhcp和clear一些状态信息；WifiMonitor的stopSupplicant用于停掉wpa_supplicant，就是向wpa_supplicant发送一个TERMINATE命令，当wpa_supplicant收到TERMINATE命令会，就会给调用者发送CTRL-EVENT-TERMINATING这个event，当WifiMonitor收到这个event后，又会给WifiStateMachine发送SUP_DISCONNECTION_EVENT消息。回到SupplicantStoppingState收到这个消息后，就可以去结束掉wpa_supplicant进程并断开与它的socket连接，并且transition到InitialState，这样WifiStateMachine也恢复到最初的状态了。另外，从上面enter函数可以看到，还会发送一个CMD_STOP_SUPPLICANT_FAILED消息给自己，如果调用stopSupplicant不成功，间隔SUPPLICANT_RESTART_INTERVAL_MSECS毫秒后，也会走到和SUP_DISCONNECTION_EVENT消息处理一样的流程中来。