欢迎大家一起学习探讨通信之WLAN。本节重点基于Android11分析讨论WiFi开启流程。用户点击一下“WiFi”开关，WiFi开启了。看似如此简单操作，但系统流程调用还是相当复杂。因Android11版本框架中WiFi打开流程有一部分变化。接下来我们一起分析下Android 11 WiFi的打开流程是怎么样的呢？
【1】系统启动时，system_server进程中会启动Wifiservice服务，启动该服务在SystemServer.java文件。
private static final String WIFI_SERVICE_CLASS ="com.android.server.wifi.WifiService";
if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI)) {
// Wifi Service must be started first for wifi-related services.
mSystemServiceManager.startService(WIFI_SERVICE_CLASS); mSystemServiceManager.startService("com.android.server.wifi.scanner.WifiScanningService");
}
该方法在启动Wifiservice服务时将会被调用到，作用是将服务注册到ServiceManager中。
protected final void publishBinderService(String name, IBinder service,
boolean allowIsolated, int dumpPriority) {
ServiceManager.addService(name, service, allowIsolated, dumpPriority);
}【2】在Wifiservice启动时，创建WifiServiceImpl实例对象，并将WiFiserviceimpl对象注册到servicemanager中。
这个对象很重要，它是整个系统WiFi服务的管理者，所有的用户端操作请求都将由它初步预处理，然后分发给不同的服务处理执行。
android/frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiService.java
public WifiService(Context contextBase) {
super(contextBase);
mWifiContext = new WifiContext(contextBase);
WifiInjector injector = new WifiInjector(mWifiContext);
WifiAsyncChannel channel = new WifiAsyncChannel(TAG);
mImpl = new WifiServiceImpl(mWifiContext, injector, channel);
}
public void onStart() {
Log.i(TAG, "Registering " + Context.WIFI_SERVICE);
publishBinderService(Context.WIFI_SERVICE, mImpl);
}【3】好，接下来到了WifiServiceImpl初始化过程，首先，看下该类的构造函数。
public WifiServiceImpl(Context context, WifiInjector wifiInjector, AsyncChannel asyncChannel) {
mContext = context;
mWifiInjector = wifiInjector;
... ... ... ...
mClientModeImpl = mWifiInjector.getClientModeImpl();
mActiveModeWarden = mWifiInjector.getActiveModeWarden();
... ... ... ...
}
看到WiFiserviceimpl构造函数，基本上做了与WiFi服务管理的相关类的初始化动作。下面简单看下Android11 相对Android9 新增加与Wifi打开相关的几个初始化类：
- ClientModeImpl 作为客户端的模式实现，作为客户端事件处理在这里完成，并所有的连接状态变化在这里初始化。
- ActiveModeWarden 提供WiFi不同操作模式的配置实现。
到这里，系统启动完成，WifiService服务已正常运行，接下来分析用户“打开WiFi”这个简单的操作，Android11 系统背后的运行流程。
【4】用户点击WiFi开关按钮打开WiFi，通过Android提供的WiFiManager的接口类，通过AIDL机制将事件传递至WifiSerivce管理服务，在WifiServiceImpl对象中对其处理。
public synchronized boolean setWifiEnabled(String packageName, boolean enable) {
//权限检查
boolean isPrivileged = isPrivileged(Binder.getCallingPid(), Binder.getCallingUid());
//检查飞行模式是否打开，同时只运行授权的app打开WiFi
if (mSettingsStore.isAirplaneModeOn() && !isPrivileged) {
mLog.err("setWifiEnabled in Airplane mode: only Settings can toggle wifi").flush();
return false;
}
//检查调用客户端是否拥有NETWORK_SETTINGS权限，如有在将事件数据记录。
if (mWifiPermissionsUtil.checkNetworkSettingsPermission(Binder.getCallingUid())) {
mWifiMetrics.logUserActionEvent(enable ? UserActionEvent.EVENT_TOGGLE_WIFI_ON
: UserActionEvent.EVENT_TOGGLE_WIFI_OFF);
}
//记录WiFi切换状态。
mWifiMetrics.incrementNumWifiToggles(isPrivileged, enable);
//触发WiFi打开动作。
mActiveModeWarden.wifiToggled();
}
private boolean isPrivileged(int pid, int uid) {
return checkNetworkSettingsPermission(pid, uid)
|| checkNetworkSetupWizardPermission(pid, uid)
|| checkNetworkStackPermission(pid, uid)
|| checkNetworkManagedProvisioningPermission(pid, uid);
}
【5】接下来将进入“ActiveModeWarden”类中。先看 WifiService服务调用的方法“mActiveModeWarden.wifiToggled()”。
android/frameworks/opt/net/wifi/service/java/com/android/server/wifi/ActiveModeWarden.java
在wifiToggled方法中，发送消息“WifiController.CMD_WIFI_TOGGLED”。
public void wifiToggled() {
mWifiController.sendMessage(WifiController.CMD_WIFI_TOGGLED);
}WifiController是ActiveModeWarden的内部类，继承StateMachine类，在ActiveModeWarden构造函数中对其进行初始化；
WifiService服务启动后，在WifiServiceImpl中，调用mActiveModeWarden.start()对其启动。WifiController状态机状态有三个如下：
状态机启动时，根据WiFi开启状态进行状态机初始化。因WiFi是由关闭切换至打开，因此，状态机初始到“mDisabledState”状态。
public void start() {
if (shouldEnableSta()) {
startClientModeManager();
setInitialState(mEnabledState);
} else {
setInitialState(mDisabledState);
}
}
private boolean shouldEnableSta() {
return mSettingsStore.isWifiToggleEnabled() || checkScanOnlyModeAvailable();
}WifiController接收到CMD_WIFI_TOGGLED消息，将在“mDisabledState”状态进行处理，
public boolean processMessageFiltered(Message msg) {
... ... ... ...
case CMD_WIFI_TOGGLED:
case CMD_SCAN_ALWAYS_MODE_CHANGED:
if (shouldEnableSta()) {
startClientModeManager();
transitionTo(mEnabledState);
}
break;
... ... ... ...
这里调用startClientModeManager()方法，启动一个客户端管理对象。
private boolean startClientModeManager() {
//ClientListener为ActiveModeWarden的内部监听类。
ClientListener listener = new ClientListener();
//获取客户端管理对象，并设置监听。
ClientModeManager manager = mWifiInjector.makeClientModeManager(listener);
listener.setActiveModeManager(manager);
manager.start();
//切换客户端模式
if (!switchClientModeManagerRole(manager)) {
return false;
}
mActiveModeManagers.add(manager);
return true;
}
【6】好！到这里我们跳到ClientModeManager类中。在其构造函数中，实例化了ClientModeStateMachine内部类对象mStateMachine 。start方法中，触发设置Station模式“ROLE_CLIENT_SCAN_ONLY”，并发送
ClientModeStateMachine.CMD_START消息。
ClientModeManager(Context context, @NonNull Looper looper, Clock clock, WifiNative wifiNative,
Listener listener, WifiMetrics wifiMetrics, SarManager sarManager,
WakeupController wakeupController, ClientModeImpl clientModeImpl) {
... ... ... ...
mStateMachine = new ClientModeStateMachine(looper);
mDeferStopHandler = new DeferStopHandler(TAG, looper);
... ... ... ...
}
public void start() {
mTargetRole = ROLE_CLIENT_SCAN_ONLY;
mStateMachine.sendMessage(ClientModeStateMachine.CMD_START);
}ClientModeStateMachine类的状态机状态如下，并初始到“mIdleState”状态和启动状态机。
ClientModeStateMachine(Looper looper) {
super(TAG, looper);
addState(mIdleState);
addState(mStartedState);
addState(mScanOnlyModeState, mStartedState);
addState(mConnectModeState, mStartedState);
setInitialState(mIdleState);
start();
}
接下来在startClientModeManager()调用方法switchClientModeManagerRole(manager)切换客户端设置模式角色。
private boolean switchClientModeManagerRole(@NonNull ClientModeManager modeManager) {
if (mSettingsStore.isWifiToggleEnabled()) {
//打开WiFi将设置角色为“ROLE_CLIENT_PRIMARY”；
modeManager.setRole(ActiveModeManager.ROLE_CLIENT_PRIMARY);
} else if (checkScanOnlyModeAvailable()) {
modeManager.setRole(ActiveModeManager.ROLE_CLIENT_SCAN_ONLY);
}
... ... ... ...
}在setRole()方法中，将role设置的值保存在mTargetRole变量，并发送消息给ClientModeStateMachine状态机。
public void setRole(@Role int role) {
if (role == ROLE_CLIENT_SCAN_ONLY) {
mTargetRole = role;
mStateMachine.sendMessage(ClientModeStateMachine.CMD_SWITCH_TO_SCAN_ONLY_MODE)
} else if (CLIENT_CONNECTIVITY_ROLES.contains(role)) {
mTargetRole = role;
// Switch client mode manager to connect mode
mStateMachine.sendMessage(ClientModeStateMachine.CMD_SWITCH_TO_CONNECT_MODE, role);
}
}程序执行到此，ActiveModeWarden类中WiFicontroller状态机在DisabledState状态处理完了“CMD_WIFI_TOGGLED”这个消息，状态机将跳转至“EnabledState”。通过状态机机制可知，将会执行DisabledState.exit()方法退出DisabledState状态；执行EnabledState.enter()方法进入到EnabledState状态。WiFicontroller状态机在WiFi打开中将停留在该状态。
【7】从上流程可知，“ClientModeStateMachine.CMD_START”和“ClientModeStateMachine.CMD_SWITCH_TO_CONNECT_MODE”两条消息还处于待处理状态。
在ClientModeStateMachine类构造函数可知，状态机初始状态为“IdleState”，此时，将执行IdleState.enter()方法进入该状态，并开始处理CMD_START消息。
private class IdleState extends State {
... ... ... ...
case CMD_START:
// Always start in scan mode first.
mClientInterfaceName =mWifiNative.setupInterfaceForClientInScanMode(
mWifiNativeInterfaceCallback);
if (TextUtils.isEmpty(mClientInterfaceName)) {
Log.e(TAG, "Failed to create ClientInterface. Sit in Idle");
mModeListener.onStartFailure();
break;
}
transitionTo(mScanOnlyModeState);
break;
... ... ... ...在处理CMD_START消息时，将调用WifiNative类中setupInterfaceForClientInScanMode()方法。
【8】好！先看WifiNative类中该方法的实现。
android/frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiNative.java
public String setupInterfaceForClientInScanMode(
@NonNull InterfaceCallback interfaceCallback) {
synchronized (mLock) {
//startwifi 加载WiFi驱动
if (!startHal()) {
Log.e(TAG, "Failed to start Hal");
mWifiMetrics.incrementNumSetupClientInterfaceFailureDueToHal();
return null;
}
//分配对应的接口
Iface iface = mIfaceMgr.allocateIface(Iface.IFACE_TYPE_STA_FOR_SCAN);
if (iface == null) {
Log.e(TAG, "Failed to allocate new STA iface");
return null;
}
iface.externalListener = interfaceCallback;
//创建对应的station接口
iface.name = createStaIface(iface);
if (TextUtils.isEmpty(iface.name)) {
Log.e(TAG, "Failed to create iface in vendor HAL");
mIfaceMgr.removeIface(iface.id);
mWifiMetrics.incrementNumSetupClientInterfaceFailureDueToHal();
return null;
}
//设置客户端接口
if (!mWifiCondManager.setupInterfaceForClientMode(iface.name, Runnable::run,
new NormalScanEventCallback(iface.name),
new PnoScanEventCallback(iface.name))) {
Log.e(TAG, "Failed to setup iface in wificond=" + iface.name);
teardownInterface(iface.name);
mWifiMetrics.incrementNumSetupClientInterfaceFailureDueToWificond();
return null;
}
//设置接口up/down的检测通知
iface.networkObserver = new NetworkObserverInternal(iface.id);
if (!registerNetworkObserver(iface.networkObserver)) {
Log.e(TAG, "Failed to register network observer for iface=" + iface.name);
teardownInterface(iface.name);
return null;
}
//启动wpa_supplicant事件监听
mWifiMonitor.startMonitoring(iface.name);
onInterfaceStateChanged(iface, isInterfaceUp(iface.name));
//获取WiFi支持的feature
iface.featureSet = getSupportedFeatureSetInternal(iface.name);
return iface.name;
}
}（1）startHal方法内部调用
startHal()->startHal()->WifiVendorHal.startVendorHal()->HalDeviceManager.start()->HalDeviceManager.startWifi()
这里看下启动WiFi的方法“HalDeviceManager.startWifi()”。在这个方法中，将加载WiFi驱动。
private boolean startWifi() {
... ... ... ...
synchronized (mLock) {
try {
if (mWifi == null) {
return false;
} else {
int triedCount = 0;
//加载WiFi驱动将尝试4次，START_HAL_RETRY_TIMES=3。
while (triedCount <= START_HAL_RETRY_TIMES) {
WifiStatus status = mWifi.start();
if (status.code == WifiStatusCode.SUCCESS) {
initIWifiChipDebugListeners();
managerStatusListenerDispatch();
if (triedCount != 0) {
}
return true;
} else if (status.code == WifiStatusCode.ERROR_NOT_AVAILABLE) {
try {
Thread.sleep(START_HAL_RETRY_INTERVAL_MS);
} catch (InterruptedException ignore) {
// no-op
}
triedCount++;
} else {
// Should not retry on other failures.
Log.e(TAG, "Cannot start IWifi: " + statusString(status));
return false;
}
}
... ... ... ...在该方法startWifi，mWifi.start()方法是启动实际加载WiFi动作的调用，这里涉及HIDL机制调用。通过获取IWifi接口对象，调用其方法。这里IWifi接口对象是IWifi.hal文件中实现。
android/hardware/interfaces/wifi/1.0/IWifi.hal在编译时，编译器会将IWifi.hal解析为IWifi.java文件,直接看该文件中的start方法实现即可。
android/out/soong//.intermediates/hardware/interfaces/wifi/1.0/android.hardware.wifi-V1.0-java_gen_java/gen/srcs/android/hardware/wifi/V1_0/IWifi.java
public android.hardware.wifi.V1_0.WifiStatus start() throws android.os.RemoteException {
try {
... ... ... ...
mRemote.transact(3 /* start */, _hidl_request, _hidl_reply, 0 /* flags */);
_hidl_reply.verifySuccess();
_hidl_request.releaseTemporaryStorage();
return _hidl_out_status;
} finally {
_hidl_reply.release();
}
}通过binder调用，将调用到wifi.cpp中的start()方法.
android/hardware/interfaces/wifi/1.4/default/wifi.cpp
Return<void> Wifi::start(start_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::startInternal, hidl_status_cb);
}
wifi.cpp->start() ==> wifi.cpp->startInternal() ==> wifi.cpp->initializeModeControllerAndLegacyHal()
==> WifiModeController->initialize() ==> DriverTool->LoadDriver()通过调用DriverTool->LoadDriver将返回到Android framework中。下面是LoadDriver()的实现。
android/frameworks/opt/net/wifi/libwifi_hal/include/wifi_hal/driver_tool.cpp
bool DriverTool::LoadDriver() {
return ::wifi_load_driver() == 0;
}在wifi_load_driver()方法中，将调用系统接口加载WiFi驱动ko。关于系统insmod接口的调用，本文不做分析。到这里，已梳理完在WifiNative类中调用的startHal()方法。
android/frameworks/opt/net/wifi/libwifi_hal/wifi_hal_common.cpp
int wifi_load_driver() {
... ... ... ...
insmod(file,args);
... ... ... ...
}（2）调用WifiNl80211Manager类的setupInterfaceForClientMode()方法。
该类的主要对WiFi 80211nl管理接口的封装，接口在WiFicond守护进程中呈现给WiFi框架。该类提供的接口仅使用与WiFi框架，访问权限受selinux权限保护。
setupInterfaceForClientMode()方法主要为Station模式设置接口。
android/frameworks/base/wifi/java/android/net/wifi/nl80211/WifiNl80211Manager.java
public boolean setupInterfaceForClientMode(@NonNull String ifaceName,
@NonNull @CallbackExecutor Executor executor,
@NonNull ScanEventCallback scanCallback, @NonNull ScanEventCallback pnoScanCallback) {
... ... ... ...
// Refresh Handlers
mClientInterfaces.put(ifaceName, clientInterface);
try {
IWifiScannerImpl wificondScanner = clientInterface.getWifiScannerImpl();
mWificondScanners.put(ifaceName, wificondScanner);
Binder.allowBlocking(wificondScanner.asBinder());
ScanEventHandler scanEventHandler = new ScanEventHandler(executor, scanCallback);
mScanEventHandlers.put(ifaceName, scanEventHandler);
wificondScanner.subscribeScanEvents(scanEventHandler);
PnoScanEventHandler pnoScanEventHandler = new PnoScanEventHandler(executor,
pnoScanCallback);
mPnoScanEventHandlers.put(ifaceName, pnoScanEventHandler);
wificondScanner.subscribePnoScanEvents(pnoScanEventHandler);
... ... ... ...
}
到这里，ClientModeStateMachine状态机在IdleState状态成功处理完了CMD_START消息。状态机将转到“mScanOnlyModeState”状态，将会执行以下调用流程(具体原因可查看状态机机制)。
IdleState.exit()->StartedState.enter()->StartedState.exit()->ScanOnlyModeState.enter()。
在状态转时，在StartedState.exit()中，将调用setOperationalMode方法。
public void exit() {
mClientModeImpl.setOperationalMode(ClientModeImpl.DISABLED_MODE, null);
}【9】这里将触及开篇提到的ClientModeImpl类。首先看下其构造函数，除了其他对象赋值初始化外，又一个状态机将与我们见面。
android/frameworks/opt/net/wifi/service/java/com/android/server/wifi/ClientModeImpl.java
public ClientModeImpl(.......）{
super(TAG, looper);
... ... .... ....
// CHECKSTYLE:OFF IndentationCheck
addState(mDefaultState);
addState(mConnectModeState, mDefaultState);
addState(mL2ConnectedState, mConnectModeState);
addState(mObtainingIpState, mL2ConnectedState);
addState(mConnectedState, mL2ConnectedState);
addState(mRoamingState, mL2ConnectedState);
addState(mDisconnectingState, mConnectModeState);
addState(mDisconnectedState, mConnectModeState);
// CHECKSTYLE:ON IndentationCheck
setInitialState(mDefaultState);
... ... .... ....
}
public void setOperationalMode(int mode, String ifaceName) {
... ... ...
//打开WiFi mode=2，因此状态机进入到mDefaultState状态
if (mode != CONNECT_MODE) {
// we are disabling client mode... need to exit connect mode now
transitionTo(mDefaultState);
} else {
... ... ... ...
}
}
【10】目前，还遗留一个消息“ClientModeStateMachine.CMD_SWITCH_TO_CONNECT_MODE”待处理。此时，轮到该消息要被处理了。
ClientModeStateMachine状态机已处于“ScanOnlyModeState”状态，接收到该消息后，在processMessage方法中并未处理，而抛给父状态“StartedState”处理。在StartedState.processMessage()方法中对该消息进行了处理。
public boolean processMessage(Message message) {
... ... ... ...
case CMD_SWITCH_TO_CONNECT_MODE:
mRole = message.arg1; // could be any one of possible connect mode roles.
//更新WiFi打开状态，发送系统广播通知。
updateConnectModeState(WifiManager.WIFI_STATE_ENABLING,
WifiManager.WIFI_STATE_DISABLED);
//切换设置clinent接口到连接模式。
if (!mWifiNative.switchClientInterfaceToConnectivityMode(
mClientInterfaceName)) {
... ... ... ...
mModeListener.onStartFailure();
break;
}
... ... ... ...
transitionTo(mConnectModeState);
break;
}（1）WifiNative类中，mWifiNative.switchClientInterfaceToConnectivityMode()方法
public boolean switchClientInterfaceToConnectivityMode(@NonNull String ifaceName) {
synchronized (mLock) {
... ... ... ...
//获取设置的接口
final Iface iface = mIfaceMgr.getIface(ifaceName);
if (iface == null) {
return false;
}
if (iface.type == Iface.IFACE_TYPE_STA_FOR_CONNECTIVITY) {
return true;
}
//调用启动wpa_supplicant服务进程
if (!startSupplicant()) {
teardownInterface(iface.name);
mWifiMetrics.incrementNumSetupClientInterfaceFailureDueToSupplicant();
return false;
}
//注册设置接口
if (!mSupplicantStaIfaceHal.setupIface(iface.name)) {
return false;
}
iface.type = Iface.IFACE_TYPE_STA_FOR_CONNECTIVITY;
iface.featureSet = getSupportedFeatureSetInternal(iface.name);
... ... ... ...
return true;
}
}WifiNative.startSupplicant()->WifiNative.startAndWaitForSupplicantConnection()->
SupplicantStaIfaceHal.startDaemon()->SupplicantStaIfaceHal.startDaemon_V1_1()->
SupplicantStaIfaceHal.getSupplicantMockableV1_1()->
SupplicantStaIfaceHal.getSupplicantMockable()
这里看下getSupplicantMockable()方法，将在getService的时候启动wpa_supplicant进程。
通过HIDL调用获取wpa_supplicant服务。ISupplicant.getService(supplicantName)调用到ISupplicant.java。
protected ISupplicant getSupplicantMockable() throws RemoteException, NoSuchElementException {
synchronized (mLock) {
ISupplicant iSupplicant = ISupplicant.getService(supplicantName);
if (iSupplicant == null) {
throw new NoSuchElementException("Cannot get root service.");
}
return iSupplicant;
}
}android/out/soong/intermediates/hardware/interfaces/wifi/supplicant/1.0/android.hardware.wifi.supplicant-V1.0-java_gen_java/gen/srcs/android/hardware/wifi/supplicant/V1_0/ISupplicant.javapublic static ISupplicant getService(String serviceName) throws android.os.RemoteException {
return ISupplicant.asInterface(android.os.HwBinder.getService("android.hardware.wifi.supplicant@1.0::ISupplicant", serviceName));
}
在这个方法中将触发启动wpa_supplicant进程，这里需要注意，在manifest.xml中对其需要进行配置，运行时会将服务名称注册到hwservicemanager中。
wpa_supplicant目录下文件调用：
main.c ==> wpa_supplicant.c->wpa_supplicant_init() ==> notify.c->wpas_notify_supplicant_initialized() ==> hidl.cpp->wpas_hidl_init() ==> Hidl_manager.cpp->registerHidlService()int HidlManager::registerHidlService(struct wpa_global *global)
{
// Create the main hidl service object and register it.
supplicant_object_ = new Supplicant(global);
if (supplicant_object_->registerAsService("wpa_supplicant") != android::NO_ERROR) {
return 1;
}
return 0;
}
【11】将wpa_supplicant添加注册到hwservicemanager，SupplicantStaIfaceHal.getSupplicantMockable()执行完成返回。
这里再深入看下“supplicant_object_->registerAsService("wpa_supplicant")”是如何通过调用注册的呢？
android/out/soong/.intermediates/hardware/interfaces/wifi/supplicant/1.3/android.hardware.wifi.supplicant@1.3_genc++/gen/android/hardware/wifi/supplicant/1.3/SupplicantAll.cpp
android/system/libhidl/transport/ServiceManagement.cpp
android/system/hwservicemanager/ServiceManager.cppsupplicant_object_->registerAsService("wpa_supplicant") ==> ISupplicant.hal
==> ISupplicantAll.cpp->registerAsService()
==> ::android::hardware::details::registerAsServiceInternal(this, serviceName)
==> ServiceManagement.cpp->registerAsServiceInternal()
==> ServiceManager->addWithChain()
==> ServiceManager->addImpl()
【12】wpa_supplicant注册完成后，SupplicantStaIfaceHal类中将收到回调通知信息，
private final IServiceNotification mServiceNotificationCallback =
new IServiceNotification.Stub() {
public void onRegistration(String fqName, String name, boolean preexisting) {
synchronized (mLock) {
if (!initSupplicantService()) {
supplicantServiceDiedHandler(mDeathRecipientCookie);
} else {
}
}
}
};返回通知的调用逻辑。
SupplicantStaIfaceHal.initSupplicantService() -> SupplicantStaIfaceHal.getSupplicantMockable()经过一系列调用，wpa_supplicant进程服务已启动完成。现回到WifiNative类中switchClientInterfaceToConnectivityMode()方法。
在该方法中，wpa_supplicant启动完成后，将调用SupplicantStaIfaceHal.setupIface()方法设置接口。
设置成功将执行完WifiNative.switchClientInterfaceToConnectivityMode()方法并退出。
[关键log打印]：WifiNative: Successfully switched to connectivity mode on iface=Iface:{Name=wlan0,Id=1,Type=STA_CONNECTIVITY}
【13】ClientModeManager类中，状态机ClientModeStateMachine在StartedState状态成功处理完“CMD_SWITCH_TO_CONNECT_MODE”消息。状态将转到“mConnectModeState”，
调用mConnectModeState.enter()方法。
public void enter() {
//设置客户端模式为连接模式
mClientModeImpl.setOperationalMode(ClientModeImpl.CONNECT_MODE,
mClientInterfaceName);
mModeListener.onStarted();
//发送系统广播，通知WiFi已打开。
updateConnectModeState(WifiManager.WIFI_STATE_ENABLED,
WifiManager.WIFI_STATE_ENABLING);
//通知SAR管理着WiFi已打开
mSarManager.setClientWifiState(WifiManager.WIFI_STATE_ENABLED);
}ClientModeImpl.setOperationalMode方法实现如下，设置模式为CONNECT_MODE。因此将走else流程。ClientModeImpl类中状态机将由DefaultState转到“DisconnectedState”状态。
状态机转到DisconnectedState状态，执行流程如下：
ConnectModeState.() ->disconnectedstate.enter()public void setOperationalMode(int mode, String ifaceName) {
mModeChange = true;
if (mode != CONNECT_MODE) {
transitionTo(mDefaultState);
} else {
if (ifaceName != null) {
mInterfaceName = ifaceName;
//更新设置是否支持80211ax。
updateInterfaceCapabilities(ifaceName);
//状态转到DisconnectedState
transitionTo(mDisconnectedState);
mWifiScoreReport.setInterfaceName(ifaceName);
} else {
transitionTo(mDefaultState);
}
}
sendMessageAtFrontOfQueue(CMD_SET_OPERATIONAL_MODE);
}
【14】在此过程中，ActiveModeWarden类中设置的ClientLister将被触发回调。 wifiScaner.setScanningEnabled()发送消息CMD_ENABLE，给到WiFiscanningSerivceimpl类中。
系统调用到这里，WiFi已处于打开状态，并将进行扫描网络，待连接。WiFi打开流程分析完成。
ActiveModeWarden.ClientListener -> ScanRequestProxy.enableScanning() ->
ScanRequestProxy.enableScanningInternal() -> wifiScaner.setScanningEnabled()注：
对以上所述专业知识有修正意见或建议，可随时留言反馈。如感兴趣更多通信知识，可关注“通信之WLAN”微信公众号。
谢谢大家支持~！
28
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
