Android14 WiFi 架构及开机过程wifi相关的初始化
目次1. Android14 WLAN架构
2.系统开机过程中wifi相关流程
2.0 Wi-Fi 相关进程和服务
2.1 android.hardware.wifi-service进程的启动
2.2 wificond进程的启动
2.2.1 wificond.rc 和 Android.bp
2.2.2 main.cpp
2.3 Wi-Fi服务的启动
2.3.1 SystemServer触发系统服务的启动
2.3.2 SystemServiceManager启动系统服务
2.3.3 WifiService的创建与启动
2.3.3.1 WifiInjector
2.3.3.2 WifServiceImpl
① 类界说
② checkAndStartWifi()方法
2.3.4 SystemServiceRegistry注册服务
参考链接：
1. Android14 WLAN架构
Android14 WLAN架构如下：
https://i-blog.csdnimg.cn/direct/c0b129337d49432591d9fbcf8fb9e25b.png
① 应用框架：
App应用使用框架提供的各种 API（android.net.wifi）调用 Wi-Fi 相关功能，代码内部是通过Binder IPC 机制（AIDL）调用到 Wi-Fi 系统服务。
② Wi-Fi 服务：
在Android系统开机过程中，SystemServer进程会启动 Wi-Fi 系统服务； Wi-Fi 服务通过 AIDL 与 Wi-Fi HAL 进行通信。
Wi-Fi 服务有多种：
[*]WifiService：用于控制 WLAN 基础架构模式（STA和AP）；
[*]WifiScanningService：扫描相关；
[*]WifiP2pService：用于管理 WLAN 直连模式；
[*]WifiAwareService：管理 WLAN 感知模式；
[*]RttService：管理 IEEE 80211mc FTM 功能。
③ wificond进程：
wificond(wifi connectivity daemon)是一个守护进程，重要实现 Wi-Fi 的扫描功能，它通过尺度的 nl80211 命令与 Wi-Fi 驱动进程通信。
④ Wi-Fi HAL：
Wi-Fi 框架提供了三个 Wi-Fi HAL接口：
[*]供应商HAL：提供加载wifi驱动的接口、Android 专用命令（对于基础架构模式STA和AP的正常运行而言不是必须的）。
[*]客户端HAL：为 wpa_supplicant 守护进程向上提供接口。
[*]Hostapd HAL：为 hostapd 守护进程向上提供接口。
2.系统开机过程中wifi相关流程
接下来先容下开机过程中wifi相关的初始化，基于的场景是：默认不打开wifi，且位置服务中的wifi扫描已关闭。（关于wifi打开流程及扫描流程会放到后续章节进行先容）
先贴个图有个团体的概念：
https://i-blog.csdnimg.cn/direct/f88398b3eb274e05be277f45b072b2f9.png
2.0 Wi-Fi 相关进程和服务
我们可以启动Android模仿器，看下在未打开Wi-Fi的环境下，有哪些wifi相关进程和服务。
emulator_x86_64:/ # ps -A | grep wifi
wifi 306 1 10837480 5700 binder_ioctl_write_read 0 S android.hardware.wifi-service
wifi 416 1 10902620 6536 do_epoll_wait 0 S wificond
emulator_x86_64:/ #
emulator_x86_64:/ # service list | grep wifi
52 android.hardware.wifi.IWifi/default:
274 wifi:
275 wifinl80211:
276 wifip2p:
277 wifiscanner:
emulator_x86_64:/ #
可以看到有两个进程：
① android.hardware.wifi-service
它是 wifi hal 服务，是一个native 守护进程，源码路径在 hardware/interfaces/wfi/aidl/default/ 下。wifiservice 通过它创建与 wpa_supplicant 、hostapd的通信。
② wificond
是wifi的一个守护进程，重要实现wifi的扫描功能。源码路径在 system/connectivity/wificond 下。
可以看到，启动了五个wifi相关服务，除了上面提到的两个独立进程对应的服务外，其它三个服务wifi、wifip2p、wifiscanner 是运行在SystemServer进程中。
别的，可以从 logcat 日志看开机过程中wifi相关流程。
使用以下命令生成日志文件：
adb logcat | grep -iE "wifi" > wifi.txt 下面是我从模仿器抓取的日志，日志很长，这里只生存关键部分：
...
//init进程启动 android.hardware.wifi-service 进程：
12-06 09:50:14.203 0 0 I init : starting service 'vendor.wifi_hal_legacy'...
12-06 09:50:14.214 0 0 I init : ... started service 'vendor.wifi_hal_legacy' has pid 311
12-06 09:50:14.213 311 311 I android.hardware.wifi-service: Wifi Hal is booting up...
12-06 09:50:14.216 311 311 I android.hardware.wifi-service: Joining RPC thread pool
12-06 09:50:14.272 0 0 I servicemanager: Found android.hardware.wifi.IWifi/default in device VINTF manifest.
//init进程启动 wificond 进程：
12-06 09:50:14.820 0 0 I init : starting service 'wificond'...
12-06 09:50:14.821 0 0 I init : ... started service 'wificond' has pid 414
12-06 09:50:14.785 414 414 I wificond: wificond is starting up...
...
//SystemServer进程启动服务：WifiService
12-06 09:50:20.577 484 484 D SystemServerTiming: StartWifi
12-06 09:50:20.578 484 484 I SystemServiceManager: Starting com.android.server.wifi.WifiService
...
12-06 09:50:20.601 484 484 I WifiHalAidlImpl: Creating the Wifi HAL using the AIDL implementation
...
12-06 09:50:20.632 414 414 I wificond: New wificond event callback registered
...
12-06 09:50:20.645 484 484 I WifiService: Registering wifi
12-06 09:50:20.645 484 484 V SystemServerTiming: StartWifi took to complete: 68ms
//SystemServer进程启动服务：WifiScanningService
12-06 09:50:20.645 484 484 D SystemServerTiming: StartWifiScanning
12-06 09:50:20.645 484 484 I SystemServiceManager: Starting com.android.server.wifi.scanner.WifiScanningService
12-06 09:50:20.645 484 484 I WifiScanningService: Creating wifiscanner
12-06 09:50:20.647 484 484 I WifiScanningService: Publishing wifiscanner
12-06 09:50:20.647 484 484 V SystemServerTiming: StartWifiScanning took to complete: 2ms
//SystemServer进程启动服务：WifiP2pService
12-06 09:50:20.647 484 484 D SystemServerTiming: StartWifiP2P
12-06 09:50:20.647 484 484 I SystemServiceManager: Starting com.android.server.wifi.p2p.WifiP2pService
12-06 09:50:20.652 484 484 I WifiP2pService: Registering wifip2p
12-06 09:50:20.652 484 484 V SystemServerTiming: StartWifiP2P took to complete: 5ms
...
12-06 09:50:21.246 484 484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.WifiService took to complete: 0ms
...
12-06 09:50:21.246 484 484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.scanner.WifiScanningService took to complete: 0ms
...
12-06 09:50:21.246 484 484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.p2p.WifiP2pService took to complete: 0ms
...
12-06 09:50:21.344 484 484 I WifiScanningService: Starting wifiscanner
...
12-06 09:50:21.365 484 609 I WifiInjector: enableVerboseLogging false hal false
12-06 09:50:21.365 484 609 D WifiNative: enableVerboseLogging false hal false
//WifiService.java::onBootPhase函数，在系统服务准备好后，调用 WifiServiceImpl.java::checkAndStartWifi，去检查是否需要启动wifi。
12-06 09:50:21.366 484 609 I WifiService: WifiService starting up with Wi-Fi disabled
//这里是启动 WifiController状态机：ActiveModeWarden.java$WifiController.start()
12-06 09:50:21.380 484 609 D WifiController: isAirplaneModeOn = false, isWifiEnabled = false, isScanningAvailable = false, isLocationModeActive = true, isSatelliteModeOn = false
12-06 09:50:21.380 484 609 E WifiActiveModeWarden: Something is wrong, no client mode toggles enabled
//初始化底层：WifiNative.initialize()
12-06 09:50:21.381 484 609 I WifiHalAidlImpl: Obtained the IWifi binder. Local Version: 1
12-06 09:50:21.382 484 609 I WifiHalAidlImpl: Remote Version: 1
12-06 09:50:21.383 484 609 I WifiHalAidlImpl: Initialization is complete
12-06 09:50:21.383 311 336 W android.hardware.wifi-service: Duplicate death notification registration
12-06 09:50:21.384 484 609 D WifiNl80211Manager: tearing down interfaces in wificond
12-06 09:50:21.438 0 0 I servicemanager: Found android.hardware.wifi.IWifi/default in device VINTF manifest.
12-06 09:50:21.387 484 609 D WifiAdaptConnObserver: Adaptive connectivity status initialized to: true
//设置WifiController状态机默认状态为：DisabledState
12-06 09:50:21.388 484 609 D WifiController: DisabledState.enter()
...
12-06 09:50:26.380 484 505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.WifiService took to complete: 1ms
...
12-06 09:50:26.388 484 505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.scanner.WifiScanningService took to complete: 0ms
...
12-06 09:50:26.388 484 505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.p2p.WifiP2pService took to complete: 0ms
//WifiService.java::onBootPhase函数，在 BOOT_COMPLETED 阶段调用 WifiServiceImpl.java::handleBootCompleted
12-06 09:50:26.396 484 609 D WifiService: Handle boot completed
...
2.1 android.hardware.wifi-service进程的启动
前面提到，android.hardware.wifi-service进程是负责 wifiservice 与 wpa_supplicant、hostapd之间通信的进程。它是在Android系统开机过程中，由 init 进程启动的。
来看下它对应的 rc 文件：hardware/interfaces/wfi/aidl/default/android.hardware.wifi-service.rc
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service
interface aidl android.hardware.wifi.IWifi/default
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps Android.bp文件（部分）：hardware/interfaces/wfi/aidl/default/Android.bp
cc_binary {
name: "android.hardware.wifi-service",
vintf_fragments: ["android.hardware.wifi-service.xml"],
relative_install_path: "hw",
proprietary: true,
cppflags: [
"-Wall",
"-Werror",
"-Wextra",
],
srcs: ["service.cpp"],
shared_libs: [
"libbase",
"libbinder_ndk",
"libcutils",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi-V1-ndk",
],
static_libs: ["android.hardware.wifi-service-lib"],
init_rc: ["android.hardware.wifi-service.rc"],
} 来看下步调的入口 service.cpp：
//hardware/interfaces/wifi/aidl/default/service.cpp
int main(int /*argc*/, char** argv) {
...
LOG(INFO) << "Wifi Hal is booting up...";
// 设置线程池最大线程数为1
ABinderProcess_setThreadPoolMaxThreadCount(1);
const auto iface_tool = std::make_shared<::android::wifi_system::InterfaceTool>();
const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
// 实例化 binder 服务
std::shared_ptr<aidl::android::hardware::wifi::Wifi> service =
ndk::SharedRefBase::make<aidl::android::hardware::wifi::Wifi>(
iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
std::make_shared<WifiFeatureFlags>());
std::string instance =
std::string() + aidl::android::hardware::wifi::Wifi::descriptor + "/default";
//注册 binder 服务
if (kLazyService) {
auto result =
AServiceManager_registerLazyService(service->asBinder().get(), instance.c_str());
CHECK_EQ(result, STATUS_OK) << "Failed to register lazy wifi HAL";
} else {
auto result = AServiceManager_addService(service->asBinder().get(), instance.c_str());
CHECK_EQ(result, STATUS_OK) << "Failed to register wifi HAL";
}
//开启 Binder 线程池
ABinderProcess_startThreadPool();
LOG(INFO) << "Joining RPC thread pool";
//加入线程池
ABinderProcess_joinThreadPool();
LOG(INFO) << "Wifi Hal is terminating...";
return 0;
} 此中，wifi hal服务类的界说如下：
//hardware/interfaces/wifi/aidl/default/wifi.h
namespace aidl {
namespace android {
namespace hardware {
namespace wifi {
/**
* Root AIDL interface object used to control the Wifi HAL.
*/
class Wifi : public BnWifi {
public:
Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
bool isValid();
// AIDL methods exposed.
ndk::ScopedAStatus registerEventCallback(
const std::shared_ptr<IWifiEventCallback>& in_callback) override;
ndk::ScopedAStatus isStarted(bool* _aidl_return) override;
ndk::ScopedAStatus start() override;
ndk::ScopedAStatus stop() override;
ndk::ScopedAStatus getChipIds(std::vector<int32_t>* _aidl_return) override;
ndk::ScopedAStatus getChip(int32_t in_chipId,
std::shared_ptr<IWifiChip>* _aidl_return) override;
binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
private:
...
DISALLOW_COPY_AND_ASSIGN(Wifi);
};
}// namespace wifi
}// namespace hardware
}// namespace android
}// namespace aidl 相关的aidl文件如下：
//hardware/interfaces/wifi/aidl/aidl_api/android.hardware.wifi/current/android/hardware/wifi/IWifi.aidl
package android.hardware.wifi;
@VintfStability
interface IWifi {
@PropagateAllowBlocking android.hardware.wifi.IWifiChip getChip(int chipId);
int[] getChipIds();
boolean isStarted();
void registerEventCallback(in android.hardware.wifi.IWifiEventCallback callback);
void start();
void stop();
}
2.2 wificond进程的启动
前面提到， wificond是一个独立的进程，重要负责wifi扫描相关功能，通过尺度的 nl80211 命令（基于netlink）与 wifi驱动进行通信。相关代码位于 system/connectivity/wificond 中。
2.2.1 wificond.rc 和 Android.bp
wificond 是在开机过程中由init进程拉起的，先来看下对应的rc文件：
路径：system/connectivity/wificond/wificond.rc
service wificond /system/bin/wificond
class main
user wifi
group wifi net_raw net_admin
capabilities NET_RAW NET_ADMIN 模块对应的Android.bp:（部分）
路径：system/connectivity/wificond/Android.bp:
//
// wificond daemon.
//
cc_binary {
name: "wificond",
defaults: [
"keystore2_use_latest_aidl_ndk_shared",
"wificond_defaults",
],
init_rc: ["wificond.rc"],
srcs: [
"main.cpp",
"wifi_keystore_hal_connector.cpp"
],
include_dirs: ["system/security/keystore/include"],
shared_libs: [
"android.hardware.net.nlinterceptor-V1-ndk",
"android.security.legacykeystore-ndk",
"libbinder",
"libbinder_ndk",
"libbase",
"libcrypto",
"libcutils",
"libhidlbase",
"libminijail",
"libssl",
"libutils",
"libwifi-system-iface",
"android.system.wifi.keystore@1.0",
],
static_libs: [
"libnlinterceptor",
"libwificond", // Wificond daemon
"libwifikeystorehal"// Wifi Keystore HAL service
],
} 2.2.2 main.cpp
接下来看下步调的入口：
//system/connectivity/wificond/main.cpp
int main(int argc, char** argv) {
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
LOG(INFO) << "wificond is starting up...";
//1.实例化 event_dispatcher（用于监听和分发事件）
unique_ptr<android::wificond::LooperBackedEventLoop> event_dispatcher(
new android::wificond::LooperBackedEventLoop());
ScopedSignalHandler scoped_signal_handler(event_dispatcher.get());
//2.初始化Binder，并将binder_fd加入event_dispatcher的监听中
int binder_fd = SetupBinderOrCrash();
CHECK(event_dispatcher->WatchFileDescriptor(
binder_fd,
android::wificond::EventLoop::kModeInput,
&OnBinderReadReady)) << "Failed to watch binder FD";
//3.启动netlink通信
android::wificond::NetlinkManager netlink_manager(event_dispatcher.get());
if (!netlink_manager.Start()) {
LOG(ERROR) << "Failed to start netlink manager";
}
实例化NetlinkUtils（netlink通信工具类）
android::wificond::NetlinkUtils netlink_utils(&netlink_manager);
//实例化ScanUtils（扫描工具类）
android::wificond::ScanUtils scan_utils(&netlink_manager);
//4.实例化 Binder 通信服务端
android::sp<android::wificond::Server> server(new android::wificond::Server(
unique_ptr<InterfaceTool>(new InterfaceTool),
&netlink_utils,
&scan_utils));
//向servicemanager注册服务（name为 wifinl80211）
RegisterServiceOrCrash(server);
WifiKeystoreHalConnector keystore_connector;
keystore_connector.start();
//进入休眠等待被唤醒
event_dispatcher->Poll();
LOG(INFO) << "wificond is about to exit";
return 0;
}
此中，Binder服务Server类继续BnWificond：
//system/connectivity/wificond/server.h
class Server : public android::net::wifi::nl80211::BnWificond {
public:
Server(std::unique_ptr<wifi_system::InterfaceTool> if_tool,
NetlinkUtils* netlink_utils,
ScanUtils* scan_utils);
~Server() override = default;
android::binder::Status registerWificondEventCallback(
const android::sp<android::net::wifi::nl80211::IWificondEventCallback>&
callback) override;
...
private:
bool SetupInterface(const std::string& iface_name, InterfaceInfo* interface,
uint32_t *wiphy_index);
...
} 实现了 system/connectivity/wificond/aidl/android/net/wifi/nl80211/IWificond.aidl 中声明的接口。
2.3 Wi-Fi服务的启动
Android系统启动过程中，SystemServer会启动很多系统服务，包括Wi-Fi相关的服务。接下来看一下这些服务的启动流程。
2.3.1 SystemServer触发系统服务的启动
SystemServer会在startOtherServices()方法中，根据系统是否支持wifi相关特性而启动对应的服务：
//frameworks/base/services/java/com/android/server/SystemServer.java
public final class SystemServer implements Dumpable {
...
private static final String WIFI_APEX_SERVICE_JAR_PATH =
"/apex/com.android.wifi/javalib/service-wifi.jar";
private static final String WIFI_SERVICE_CLASS =
"com.android.server.wifi.WifiService";
private static final String WIFI_SCANNING_SERVICE_CLASS =
"com.android.server.wifi.scanner.WifiScanningService";
private static final String WIFI_RTT_SERVICE_CLASS =
"com.android.server.wifi.rtt.RttService";
private static final String WIFI_AWARE_SERVICE_CLASS =
"com.android.server.wifi.aware.WifiAwareService";
private static final String WIFI_P2P_SERVICE_CLASS =
"com.android.server.wifi.p2p.WifiP2pService";
/**
* The main entry point from zygote.
*/
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
// Start services.
try {
t.traceBegin("StartServices");
...
startOtherServices(t);
...
} ...
}
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
...
//启动Wifi相关服务
if (context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI)) {
// Wifi Service must be started first for wifi-related services.
t.traceBegin("StartWifi");
mSystemServiceManager.startServiceFromJar(
WIFI_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
t.traceEnd();
t.traceBegin("StartWifiScanning");
mSystemServiceManager.startServiceFromJar(
WIFI_SCANNING_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
t.traceEnd();
}
if (context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI_RTT)) {
t.traceBegin("StartRttService");
mSystemServiceManager.startServiceFromJar(
WIFI_RTT_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
t.traceEnd();
}
if (context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI_AWARE)) {
t.traceBegin("StartWifiAware");
mSystemServiceManager.startServiceFromJar(
WIFI_AWARE_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
t.traceEnd();
}
if (context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI_DIRECT)) {
t.traceBegin("StartWifiP2P");
mSystemServiceManager.startServiceFromJar(
WIFI_P2P_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
t.traceEnd();
}
...
}
}
2.3.2 SystemServiceManager启动系统服务
SystemServiceManager 启动服务的流程大概是：
1.创建系统服务实例（通过反射）；
2.注册服务&启动系统服务：
①所谓注册，就是将服务对象添加到SystemService列表中；
②启动服务：service.onStart()。会向 servicemanager 注册Binder服务的。
//frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
// Services that should receive lifecycle events.
private List<SystemService> mServices;
/**
* Starts a service by class name and a path that specifies the jar where the service lives.
*
* @return The service instance.
*/
public SystemService startServiceFromJar(String className, String path) {
PathClassLoader pathClassLoader =
SystemServerClassLoaderFactory.getOrCreateClassLoader(
path, this.getClass().getClassLoader(), isJarInTestApex(path));
//加载类
final Class<SystemService> serviceClass = loadClassFromLoader(className, pathClassLoader);
//通过反射构造service，并调用它的 onStart 方法
return startService(serviceClass);
}
private List<SystemService> mServices;
public void startService(@NonNull final SystemService service) {
...
// Register it.
mServices.add(service);
// Start it.
try {
//调用 service 的 onStart方法
service.onStart();
}
...
}
下面以 WifiService 的启动为例，看下它的启动流程。
2.3.3 WifiService的创建与启动
首先，WifiService类继续SystemService类。被SystemServer进程启动的服务都必要继续 SystemService类。它不对外暴露，对接的是SystemServer，真正的实现是在 WifServiceImpl。WifiService 内部持有 WifServiceImpl 对象，在服务启动时，会注册 WifServiceImpl 服务。
对于 WifiService类我们目前关注一下三点：
①在创建WifiService 时，会创建一个WifiInjector和WifServiceImpl对象；
②在WifiService.onStart() 方法中，会将 wifi 服务注册到ServiceManager（通过 ServiceManager.addService, 让 ServiceManager接管Binder服务的实现类）。
③在WifiService.onBootPhase() 方法中，会调用 WifiServiceImpl的checkAndStartWifi()，去判定是否必要开启wifi，同时会初始化native模块和启动状态机。
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiService.java
package com.android.server.wifi;
...
/**
* Service implementing Wi-Fi functionality. Delegates actual interface
* implementation to WifiServiceImpl.
*/
public final class WifiService extends SystemService {
private static final String TAG = "WifiService";
...
private final WifiServiceImpl mImpl;
private final WifiContext mWifiContext;
public WifiService(Context contextBase) {
super(contextBase);
mWifiContext = new WifiContext(contextBase);
//1.创建WifiInjector
WifiInjector injector = new WifiInjector(mWifiContext);
//2.创建WifiServiceImpl（wifi服务的真正实现类）
mImpl = new WifiServiceImpl(mWifiContext, injector);
}
@Override
public void onStart() {
Log.i(TAG, "Registering " + Context.WIFI_SERVICE);
//3.向 servicemanager 注册 wifi 服务(name为 wifi)
publishBinderService(Context.WIFI_SERVICE, mImpl);
}
@Override
public void onBootPhase(int phase) {
if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
//4.在系统服务准备好后，检查是否需要启动wifi
mImpl.checkAndStartWifi();
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
//5.在 BOOT_COMPLETED阶段，调用WifiServiceImpl的handleBootCompleted函数
mImpl.handleBootCompleted();
}
}
...
} 2.3.3.1 WifiInjector
WifiInjector是WiFi依靠注入器，通过它可以获取各种WiFi类的实例。在创建WifiInjector时会实例化这些类。
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiInjector.java
package com.android.server.wifi;
/**
*WiFi dependency injector. To be used for accessing various WiFi class instances and as a
*handle for mock injection.
*
*Some WiFi class instances currently depend on having a Looper from a HandlerThread that has
*been started. To accommodate this, we have a two-phased approach to initialize and retrieve
*an instance of the WifiInjector.
*/
public class WifiInjector {
private static final String TAG = "WifiInjector";
...
public WifiInjector(WifiContext context) {
...
sWifiInjector = this;
...
// 1.创建和启动 handler 线程
mWifiHandlerThread = new HandlerThread("WifiHandlerThread");
mWifiHandlerThread.start();
Looper wifiLooper = mWifiHandlerThread.getLooper();
...
mWifiMonitor = new WifiMonitor();
...
// 2.实例化与 Native 层交互的对象
mHalDeviceManager = new HalDeviceManager(mContext, mClock, this, wifiHandler);
...
mWifiVendorHal = new WifiVendorHal(mContext, mHalDeviceManager, wifiHandler, mWifiGlobals,
mSsidTranslator);
mSupplicantStaIfaceHal = new SupplicantStaIfaceHal(
mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics,
mWifiGlobals, mSsidTranslator, this);
...
mWifiNative = new WifiNative(
mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager,
mWifiMonitor, mPropertyService, mWifiMetrics,
wifiHandler, new Random(), mBuildProperties, this);
2.3.3.2 WifServiceImpl
WifiServiceImpl 是 wifi 服务的具体实现类，它实现了 IWifiManager 接口，所有的客户端请求（WIFI远程调用请求）都会被它分发给差别的类去进行处置惩罚。
① 类界说
来看下WifiServiceImpl 的构造函数：
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiServiceImpl.java
package com.android.server.wifi;
/**
* WifiService handles remote WiFi operation requests by implementing
* the IWifiManager interface.
*/
public class WifiServiceImpl extends BaseWifiService {
private static final String TAG = "WifiService";
...
private final WifiInjector mWifiInjector;
public WifiServiceImpl(WifiContext context, WifiInjector wifiInjector) {
mContext = context;
mWifiInjector = wifiInjector;
...
//从 WifiInjector 获取Wifi相关类实例
mWifiThreadRunner = mWifiInjector.getWifiThreadRunner();
mWifiHandlerThread = mWifiInjector.getWifiHandlerThread();
mWifiConfigManager = mWifiInjector.getWifiConfigManager();
mHalDeviceManager = mWifiInjector.getHalDeviceManager();
...
mWifiConnectivityManager = wifiInjector.getWifiConnectivityManager();
mWifiDataStall = wifiInjector.getWifiDataStall();
mWifiNative = wifiInjector.getWifiNative();
...
}
...
}
//WifiServiceImpl继承BaseWifiService类，来看下BaseWifiService的定义：
//packages/modules/Wifi/framework/java/android/net/wifi/BaseWifiService.java
package android.net.wifi;
...
//根据注释，这个类是空壳，需要被其它类去继承并实现 IWifiManager 的接口。
public class BaseWifiService extends IWifiManager.Stub {
...
}
//相关的接口声明在 IWifiManager.aidl 文件中：
//packages/modules/Wifi/framework/java/android/net/wifi/IWifiManager.aidl
package android.net.wifi;
...
/**
* Interface that allows controlling and querying Wi-Fi connectivity.
*
* {@hide}
*/
interface IWifiManager
{
long getSupportedFeatures();
...
boolean enableNetwork(int netId, boolean disableOthers, String packageName);
...
boolean startScan(String packageName, String featureId);
List<ScanResult> getScanResults(String callingPackage, String callingFeatureId);
...
boolean disconnect(String packageName);
boolean reconnect(String packageName);
...
} ② checkAndStartWifi()方法
前面提到，WifiService.onBootPhase() 方法中，会调用 WifiServiceImpl的checkAndStartWifi()方法，去查抄是否必要开启wifi，同时会初始化native模块。下面来看下相关流程：
关键调用链如下：
WifiServiceImpl：：checkAndStartWifi
|--ActiveModeWarden::start
|--WifiController.start
|--setInitialState(mDisabledState)--判断为不需要开启wifi，设置状态机初始状态为DisabledState
|--WifiNative.initialize --在启动状态机之前，先初始化native层
|--WifiVendorHal.initialize
|--HalDeviceManager.initialize
|--WifiHal.initialize
|--WifiHalAidlImpl.getWifiServiceMockable--获取wifi hal服务
|--registerWifiHalEventCallback
|--WifiHalAidlImpl.registerEventCallback --往wifi hal服务注册回调
|--super.start() --启动状态机 以下是关键源码：
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiServiceImpl.java
public void checkAndStartWifi() {
mWifiThreadRunner.post(() -> {
...
// Check if wi-fi needs to be enabled
//判断是否需要启动wifi
boolean wifiEnabled = mSettingsStore.isWifiToggleEnabled();
//这里会打印是否需要启动wifi
Log.i(TAG,
"WifiService starting up with Wi-Fi " + (wifiEnabled ? "enabled" : "disabled"));
...
//监听一系列广播
...
//这里会检查是否需要开启wifi启动，并启动 WifiController 状态机
mActiveModeWarden.start();
registerForCarrierConfigChange();
mWifiInjector.getAdaptiveConnectivityEnabledSettingObserver().initialize();
mIsWifiServiceStarted = true;
});
}
//packages/modules/Wifi/service/java/com/android/server/wifi/ActiveModeWarden.java
/** Begin listening to broadcasts and start the internal state machine. */
public void start() {
//监听一系列广播
...
//启动内部状态机：WifiController
mWifiController.start();
}
/**
* WifiController is the class used to manage wifi state for various operating
* modes (normal, airplane, wifi hotspot, etc.).
*/
private class WifiController extends StateMachine {
...
@Override
public void start() {
...
//1.这里打印一些关键状态，如：是否打开wifi、是否开启随时扫描等
log("isAirplaneModeOn = " + isAirplaneModeOn
+ ", isWifiEnabled = " + isWifiEnabled
+ ", isScanningAvailable = " + isScanningAlwaysAvailable
+ ", isLocationModeActive = " + isLocationModeActive
+ ", isSatelliteModeOn = " + isSatelliteModeOn);
...
//2.获取 ClientRole，以此判断进入什么模式
ActiveModeManager.ClientRole role = getRoleForPrimaryOrScanOnlyClientModeManager();
if (role == ROLE_CLIENT_PRIMARY) {//这个分支是开启wifi
startPrimaryClientModeManager(mLastPrimaryClientModeManagerRequestorWs);
setInitialState(mEnabledState);
} else if (role == ROLE_CLIENT_SCAN_ONLY) {//这个分支是开启scanonly模式
startScanOnlyClientModeManager(mLastScanOnlyClientModeManagerRequestorWs);
setInitialState(mEnabledState);
} else { //如果不需要开启wifi，则设置初始状态为 DisabledState （当前场景进入的是这个分支）
setInitialState(mDisabledState);
}
mWifiMetrics.noteWifiEnabledDuringBoot(mSettingsStore.isWifiToggleEnabled());
//3.在启动状态机之前，先初始化native层
mWifiNative.initialize();
//4.启动状态机
super.start();
}
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiNative.java
/**
* Initialize the native modules.
*
* @return true on success, false otherwise.
*/
public boolean initialize() {
synchronized (mLock) {
if (!mWifiVendorHal.initialize(new VendorHalDeathHandlerInternal())) {
Log.e(TAG, "Failed to initialize vendor HAL");
return false;
}
...
return true;
}
}
//packages/modules/Wifi/service/java/com/android/server/wifi/WifiVendorHal.java
/**
* Initialize the Hal device manager and register for status callbacks.
*
* @param handler Handler to notify if the vendor HAL dies.
* @return true on success, false otherwise.
*/
public boolean initialize(WifiNative.VendorHalDeathEventHandler handler) {
synchronized (sLock) {
mHalDeviceManager.initialize();
mHalDeviceManager.registerStatusListener(
mHalDeviceManagerStatusCallbacks, mHalEventHandler);
mDeathEventHandler = handler;
return true;
}
}
//packages/modules/Wifi/service/java/com/android/server/wifi/HalDeviceManager.java
/**
* Actually starts the HalDeviceManager: separate from constructor since may want to phase
* at a later time.
*
* TODO: if decide that no need for separating construction from initialization (e.g. both are
* done at injector) then move to constructor.
*/
public void initialize() {
initializeInternal();
registerWifiHalEventCallback();
}
private void initializeInternal() {
mWifiHal.initialize(mIWifiDeathRecipient);
}
//packages/modules/Wifi/service/java/com/android/server/wifi/hal/WifiHal.java
/**
* See comments for {@link IWifiHal#initialize(DeathRecipient)}
*/
public void initialize(WifiHal.DeathRecipient deathRecipient) {
if (mWifiHal != null) {
mWifiHal.initialize(deathRecipient);
}
}
//packages/modules/Wifi/service/java/com/android/server/wifi/hal/WifiHalAidlImpl.java
@Override
public void initialize(WifiHal.DeathRecipient deathRecipient) {
final String methodStr = "initialize";
synchronized (mLock) {
...
//1.获取 wifi hal 服务: IWifi
mWifi = getWifiServiceMockable();
...
Log.i(TAG, "Obtained the IWifi binder. Local Version: "
+ android.hardware.wifi.IWifi.VERSION);
try {
Log.i(TAG, "Remote Version: " + mWifi.getInterfaceVersion());
//转换为IBinder对象
IBinder serviceBinder = getServiceBinderMockable();
...
//2.注册死亡通知
serviceBinder.linkToDeath(mServiceDeathRecipient, /* flags= */0);
...
registerHalCallback();
Log.i(TAG, "Initialization is complete");
} catch (RemoteException e) {
handleRemoteException(e, methodStr);
}
}
} 2.3.4 SystemServiceRegistry注册服务
SystemServiceRegistry 类重要用来缓存、注册和获取这些系统服务。当SystemServiceRegistry类被导入内存时，它的static代码块会被实行，而static代码块中大量调用了 registerService() 方法，这样应用层就可以通过 Context.getSystemService 来获取相关的服务了。
//frameworks/base/core/java/android/app/SystemServiceRegistry.java
/**
* Manages all of the system services that can be returned by {@link Context#getSystemService}.
* Used by {@link ContextImpl}.
*
* @hide
*/
@SystemApi
public final class SystemServiceRegistry {
...
static {
...
//1.
registerService(Context.WIFI_NL80211_SERVICE, WifiNl80211Manager.class,
new CachedServiceFetcher<WifiNl80211Manager>() {
@Override
public WifiNl80211Manager createService(ContextImpl ctx) {
return new WifiNl80211Manager(ctx.getOuterContext());
}
});
...
try {
...
//2.注册 wifi framework 服务包装类
WifiFrameworkInitializer.registerServiceWrappers();
...
}
//1
/**
* Statically registers a system service with the context.
* This method must be called during static initialization only.
*/
private static <T> void registerService(@NonNull String serviceName,
@NonNull Class<T> serviceClass, @NonNull ServiceFetcher<T> serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
SYSTEM_SERVICE_CLASS_NAMES.put(serviceName, serviceClass.getSimpleName());
}
//2
/**
* Called by {@link SystemServiceRegistry}'s static initializer and registers all Wifi services
* to {@link Context}, so that {@link Context#getSystemService} can return them.
*
* @throws IllegalStateException if this is called from anywhere besides
* {@link SystemServiceRegistry}
*/
public static void registerServiceWrappers() {
SystemServiceRegistry.registerContextAwareService(
Context.WIFI_SERVICE,
WifiManager.class,
(context, serviceBinder) -> {
if (!context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI)) {
return null;
}
//获取 IWifiManager 对象
IWifiManager service = IWifiManager.Stub.asInterface(serviceBinder);
//创建并返回 WifiManager 对象
return new WifiManager(context, service, getInstanceLooper());
}
);
SystemServiceRegistry.registerContextAwareService(
Context.WIFI_P2P_SERVICE,
WifiP2pManager.class,
(context, serviceBinder) -> {
if (!context.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_WIFI_DIRECT)) {
return null;
}
IWifiP2pManager service = IWifiP2pManager.Stub.asInterface(serviceBinder);
return new WifiP2pManager(service);
}
);
...
参考链接：
Wi-Fi 概览 | Android Open Source Project
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]