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架构如下：

① 应用框架：
        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打开流程及扫描流程会放到后续章节进行先容）
先贴个图有个团体的概念：

2.0 Wi-Fi 相关进程和服务

        我们可以启动Android模仿器，看下在未打开Wi-Fi的环境下，有哪些wifi相关进程和服务。

1. emulator_x86_64:/ # ps -A | grep wifi                                                                                 
2. wifi           306     1   10837480   5700 binder_ioctl_write_read 0 S android.hardware.wifi-service
3. wifi           416     1   10902620   6536 do_epoll_wait       0 S wificond
4. emulator_x86_64:/ #
5. emulator_x86_64:/ # service list | grep wifi
6. 52        android.hardware.wifi.IWifi/default: [android.hardware.wifi.IWifi]
7. 274        wifi: [android.net.wifi.IWifiManager]
8. 275        wifinl80211: [android.net.wifi.nl80211.IWificond]
9. 276        wifip2p: [android.net.wifi.p2p.IWifiP2pManager]
10. 277        wifiscanner: [android.net.wifi.IWifiScanner]
11. 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相关流程。
使用以下命令生成日志文件：

1. adb logcat | grep -iE "wifi" > wifi.txt

复制代码

下面是我从模仿器抓取的日志，日志很长，这里只生存关键部分：

1. ...
2. //init进程启动 android.hardware.wifi-service 进程：
3. 12-06 09:50:14.203     0     0 I init    : starting service 'vendor.wifi_hal_legacy'...
4. 12-06 09:50:14.214     0     0 I init    : ... started service 'vendor.wifi_hal_legacy' has pid 311
5. 12-06 09:50:14.213   311   311 I android.hardware.wifi-service: Wifi Hal is booting up...
6. 12-06 09:50:14.216   311   311 I android.hardware.wifi-service: Joining RPC thread pool
7. 12-06 09:50:14.272     0     0 I servicemanager: Found android.hardware.wifi.IWifi/default in device VINTF manifest.
9. //init进程启动 wificond 进程：
10. 12-06 09:50:14.820     0     0 I init    : starting service 'wificond'...
11. 12-06 09:50:14.821     0     0 I init    : ... started service 'wificond' has pid 414
12. 12-06 09:50:14.785   414   414 I wificond: wificond is starting up...
13. ...
14. //SystemServer进程启动服务：WifiService
15. 12-06 09:50:20.577   484   484 D SystemServerTiming: StartWifi
16. 12-06 09:50:20.578   484   484 I SystemServiceManager: Starting com.android.server.wifi.WifiService
17. ...
18. 12-06 09:50:20.601   484   484 I WifiHalAidlImpl: Creating the Wifi HAL using the AIDL implementation
19. ...
20. 12-06 09:50:20.632   414   414 I wificond: New wificond event callback registered
21. ...
22. 12-06 09:50:20.645   484   484 I WifiService: Registering wifi
23. 12-06 09:50:20.645   484   484 V SystemServerTiming: StartWifi took to complete: 68ms
25. //SystemServer进程启动服务：WifiScanningService
26. 12-06 09:50:20.645   484   484 D SystemServerTiming: StartWifiScanning
27. 12-06 09:50:20.645   484   484 I SystemServiceManager: Starting com.android.server.wifi.scanner.WifiScanningService
28. 12-06 09:50:20.645   484   484 I WifiScanningService: Creating wifiscanner
29. 12-06 09:50:20.647   484   484 I WifiScanningService: Publishing wifiscanner
30. 12-06 09:50:20.647   484   484 V SystemServerTiming: StartWifiScanning took to complete: 2ms
32. //SystemServer进程启动服务：WifiP2pService
33. 12-06 09:50:20.647   484   484 D SystemServerTiming: StartWifiP2P
34. 12-06 09:50:20.647   484   484 I SystemServiceManager: Starting com.android.server.wifi.p2p.WifiP2pService
35. 12-06 09:50:20.652   484   484 I WifiP2pService: Registering wifip2p
36. 12-06 09:50:20.652   484   484 V SystemServerTiming: StartWifiP2P took to complete: 5ms
37. ...
38. 12-06 09:50:21.246   484   484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.WifiService took to complete: 0ms
39. ...
40. 12-06 09:50:21.246   484   484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.scanner.WifiScanningService took to complete: 0ms
41. ...
42. 12-06 09:50:21.246   484   484 V SystemServerTiming: OnBootPhase_480_com.android.server.wifi.p2p.WifiP2pService took to complete: 0ms
43. ...
44. 12-06 09:50:21.344   484   484 I WifiScanningService: Starting wifiscanner
45. ...
46. 12-06 09:50:21.365   484   609 I WifiInjector: enableVerboseLogging false hal false
47. 12-06 09:50:21.365   484   609 D WifiNative: enableVerboseLogging false hal false
49. //WifiService.java::onBootPhase函数，在系统服务准备好后，调用 WifiServiceImpl.java::checkAndStartWifi，去检查是否需要启动wifi。
50. 12-06 09:50:21.366   484   609 I WifiService: WifiService starting up with Wi-Fi disabled
52. //这里是启动 WifiController状态机：ActiveModeWarden.java$WifiController.start()
53. 12-06 09:50:21.380   484   609 D WifiController: isAirplaneModeOn = false, isWifiEnabled = false, isScanningAvailable = false, isLocationModeActive = true, isSatelliteModeOn = false
54. 12-06 09:50:21.380   484   609 E WifiActiveModeWarden: Something is wrong, no client mode toggles enabled
55. //初始化底层：WifiNative.initialize()
56. 12-06 09:50:21.381   484   609 I WifiHalAidlImpl: Obtained the IWifi binder. Local Version: 1
57. 12-06 09:50:21.382   484   609 I WifiHalAidlImpl: Remote Version: 1
58. 12-06 09:50:21.383   484   609 I WifiHalAidlImpl: Initialization is complete
59. 12-06 09:50:21.383   311   336 W android.hardware.wifi-service: Duplicate death notification registration
60. 12-06 09:50:21.384   484   609 D WifiNl80211Manager: tearing down interfaces in wificond
61. 12-06 09:50:21.438     0     0 I servicemanager: Found android.hardware.wifi.IWifi/default in device VINTF manifest.
62. 12-06 09:50:21.387   484   609 D WifiAdaptConnObserver: Adaptive connectivity status initialized to: true
63. //设置WifiController状态机默认状态为：DisabledState
64. 12-06 09:50:21.388   484   609 D WifiController: DisabledState.enter()
65. ...
66. 12-06 09:50:26.380   484   505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.WifiService took to complete: 1ms
67. ...
68. 12-06 09:50:26.388   484   505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.scanner.WifiScanningService took to complete: 0ms
69. ...
70. 12-06 09:50:26.388   484   505 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.wifi.p2p.WifiP2pService took to complete: 0ms
72. //WifiService.java::onBootPhase函数，在 BOOT_COMPLETED 阶段调用 WifiServiceImpl.java::handleBootCompleted
73. 12-06 09:50:26.396   484   609 D WifiService: Handle boot completed
74. ...

复制代码

 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

1. service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi-service
2.     interface aidl android.hardware.wifi.IWifi/default
3.     class hal
4.     capabilities NET_ADMIN NET_RAW SYS_MODULE
5.     user wifi
6.     group wifi gps

复制代码

Android.bp文件（部分）：hardware/interfaces/wfi/aidl/default/Android.bp

1. cc_binary {
2.     name: "android.hardware.wifi-service",
3.     vintf_fragments: ["android.hardware.wifi-service.xml"],
4.     relative_install_path: "hw",
5.     proprietary: true,
6.     cppflags: [
7.         "-Wall",
8.         "-Werror",
9.         "-Wextra",
10.     ],
11.     srcs: ["service.cpp"],
12.     shared_libs: [
13.         "libbase",
14.         "libbinder_ndk",
15.         "libcutils",
16.         "liblog",
17.         "libnl",
18.         "libutils",
19.         "libwifi-hal",
20.         "libwifi-system-iface",
21.         "libxml2",
22.         "android.hardware.wifi-V1-ndk",
23.     ],
24.     static_libs: ["android.hardware.wifi-service-lib"],
25.     init_rc: ["android.hardware.wifi-service.rc"],
26. }

复制代码

来看下步调的入口 service.cpp：

1. //hardware/interfaces/wifi/aidl/default/service.cpp
2. int main(int /*argc*/, char** argv) {
3.     ...
4.     LOG(INFO) << "Wifi Hal is booting up...";
6.     // 设置线程池最大线程数为1
7.     ABinderProcess_setThreadPoolMaxThreadCount(1);
9.     const auto iface_tool = std::make_shared<::android::wifi_system::InterfaceTool>();
10.     const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
12.     // 实例化 binder 服务
13.     std::shared_ptr<aidl::android::hardware::wifi::Wifi> service =
14.             ndk::SharedRefBase::make<aidl::android::hardware::wifi::Wifi>(
15.                     iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
16.                     std::make_shared<WifiFeatureFlags>());
17.     std::string instance =
18.             std::string() + aidl::android::hardware::wifi::Wifi::descriptor + "/default";
19.     //注册 binder 服务
20.     if (kLazyService) {
21.         auto result =
22.                 AServiceManager_registerLazyService(service->asBinder().get(), instance.c_str());
23.         CHECK_EQ(result, STATUS_OK) << "Failed to register lazy wifi HAL";
24.     } else {
25.         auto result = AServiceManager_addService(service->asBinder().get(), instance.c_str());
26.         CHECK_EQ(result, STATUS_OK) << "Failed to register wifi HAL";
27.     }
29.     //开启 Binder 线程池
30.     ABinderProcess_startThreadPool();
31.     LOG(INFO) << "Joining RPC thread pool";
32.     //加入线程池
33.     ABinderProcess_joinThreadPool();
35.     LOG(INFO) << "Wifi Hal is terminating...";
36.     return 0;
37. }

复制代码

此中，wifi hal服务类的界说如下：

1. //hardware/interfaces/wifi/aidl/default/wifi.h
2. namespace aidl {
3. namespace android {
4. namespace hardware {
5. namespace wifi {
7. /**
8. * Root AIDL interface object used to control the Wifi HAL.
9. */
10. class Wifi : public BnWifi {
11.   public:
12.     Wifi(const std::shared_ptr<::android::wifi_system::InterfaceTool> iface_tool,
13.          const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
14.          const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
15.          const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
17.     bool isValid();
19.     // AIDL methods exposed.
20.     ndk::ScopedAStatus registerEventCallback(
21.             const std::shared_ptr<IWifiEventCallback>& in_callback) override;
22.     ndk::ScopedAStatus isStarted(bool* _aidl_return) override;
23.     ndk::ScopedAStatus start() override;
24.     ndk::ScopedAStatus stop() override;
25.     ndk::ScopedAStatus getChipIds(std::vector<int32_t>* _aidl_return) override;
26.     ndk::ScopedAStatus getChip(int32_t in_chipId,
27.                                std::shared_ptr<IWifiChip>* _aidl_return) override;
28.     binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
30.   private:
31.     ...
33.     DISALLOW_COPY_AND_ASSIGN(Wifi);
34. };
36. }  // namespace wifi
37. }  // namespace hardware
38. }  // namespace android
39. }  // namespace aidl

复制代码

相关的aidl文件如下：

1. //hardware/interfaces/wifi/aidl/aidl_api/android.hardware.wifi/current/android/hardware/wifi/IWifi.aidl
2. package android.hardware.wifi;
3. @VintfStability
4. interface IWifi {
5.   @PropagateAllowBlocking android.hardware.wifi.IWifiChip getChip(int chipId);
6.   int[] getChipIds();
7.   boolean isStarted();
8.   void registerEventCallback(in android.hardware.wifi.IWifiEventCallback callback);
9.   void start();
10.   void stop();
11. }

复制代码

 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

1. service wificond /system/bin/wificond
2.     class main
3.     user wifi
4.     group wifi net_raw net_admin
5.     capabilities NET_RAW NET_ADMIN

复制代码

模块对应的Android.bp:（部分）
        路径：system/connectivity/wificond/Android.bp:

1. //
2. // wificond daemon.
3. //
4. cc_binary {
5.     name: "wificond",
6.     defaults: [
7.         "keystore2_use_latest_aidl_ndk_shared",
8.         "wificond_defaults",
9.     ],
10.     init_rc: ["wificond.rc"],
11.     srcs: [
12.         "main.cpp",
13.         "wifi_keystore_hal_connector.cpp"
14.     ],
15.     include_dirs: ["system/security/keystore/include"],
17.     shared_libs: [
18.         "android.hardware.net.nlinterceptor-V1-ndk",
19.         "android.security.legacykeystore-ndk",
20.         "libbinder",
21.         "libbinder_ndk",
22.         "libbase",
23.         "libcrypto",
24.         "libcutils",
25.         "libhidlbase",
26.         "libminijail",
27.         "libssl",
28.         "libutils",
29.         "libwifi-system-iface",
30.         "android.system.wifi.keystore@1.0",
31.     ],
32.     static_libs: [
33.         "libnlinterceptor",
34.         "libwificond", // Wificond daemon
35.         "libwifikeystorehal"  // Wifi Keystore HAL service
36.     ],
37. }

复制代码

2.2.2 main.cpp

接下来看下步调的入口：

1. //system/connectivity/wificond/main.cpp
2. int main(int argc, char** argv) {
3.   android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
4.   LOG(INFO) << "wificond is starting up...";
6.   //1.实例化 event_dispatcher（用于监听和分发事件）
7.   unique_ptr<android::wificond::LooperBackedEventLoop> event_dispatcher(
8.       new android::wificond::LooperBackedEventLoop());
9.   ScopedSignalHandler scoped_signal_handler(event_dispatcher.get());
11.   //2.初始化Binder，并将binder_fd加入event_dispatcher的监听中
12.   int binder_fd = SetupBinderOrCrash();
13.   CHECK(event_dispatcher->WatchFileDescriptor(
14.       binder_fd,
15.       android::wificond::EventLoop::kModeInput,
16.       &OnBinderReadReady)) << "Failed to watch binder FD";
18.   //3.启动netlink通信
19.   android::wificond::NetlinkManager netlink_manager(event_dispatcher.get());
20.   if (!netlink_manager.Start()) {
21.     LOG(ERROR) << "Failed to start netlink manager";
22.   }
23.   实例化NetlinkUtils（netlink通信工具类）
24.   android::wificond::NetlinkUtils netlink_utils(&netlink_manager);
25.   //实例化ScanUtils（扫描工具类）
26.   android::wificond::ScanUtils scan_utils(&netlink_manager);
28.   //4.实例化 Binder 通信服务端
29.   android::sp<android::wificond::Server> server(new android::wificond::Server(
30.       unique_ptr<InterfaceTool>(new InterfaceTool),
31.       &netlink_utils,
32.       &scan_utils));
33.   //向servicemanager注册服务（name为 wifinl80211）
34.   RegisterServiceOrCrash(server);
36.   WifiKeystoreHalConnector keystore_connector;
37.   keystore_connector.start();
39.   //进入休眠等待被唤醒
40.   event_dispatcher->Poll();
41.   LOG(INFO) << "wificond is about to exit";
42.   return 0;
43. }

复制代码

此中，Binder服务Server类继续BnWificond：

1. //system/connectivity/wificond/server.h
2. class Server : public android::net::wifi::nl80211::BnWificond {
3. public:
4.   Server(std::unique_ptr<wifi_system::InterfaceTool> if_tool,
5.          NetlinkUtils* netlink_utils,
6.          ScanUtils* scan_utils);
7.   ~Server() override = default;
9.   android::binder::Status registerWificondEventCallback(
10.       const android::sp<android::net::wifi::nl80211::IWificondEventCallback>&
11.           callback) override;
12.   ...
13. private:
14.   bool SetupInterface(const std::string& iface_name, InterfaceInfo* interface,
15.       uint32_t *wiphy_index);
16.   ...
17. }

复制代码

实现了 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相关特性而启动对应的服务：

1. //frameworks/base/services/java/com/android/server/SystemServer.java
2. public final class SystemServer implements Dumpable {
3.     ...
4.     private static final String WIFI_APEX_SERVICE_JAR_PATH =
5.         "/apex/com.android.wifi/javalib/service-wifi.jar";
6.     private static final String WIFI_SERVICE_CLASS =
7.             "com.android.server.wifi.WifiService";
8.     private static final String WIFI_SCANNING_SERVICE_CLASS =
9.             "com.android.server.wifi.scanner.WifiScanningService";
10.     private static final String WIFI_RTT_SERVICE_CLASS =
11.             "com.android.server.wifi.rtt.RttService";
12.     private static final String WIFI_AWARE_SERVICE_CLASS =
13.             "com.android.server.wifi.aware.WifiAwareService";
14.     private static final String WIFI_P2P_SERVICE_CLASS =
15.             "com.android.server.wifi.p2p.WifiP2pService";
17.     /**
18.      * The main entry point from zygote.
19.      */
20.     public static void main(String[] args) {
21.         new SystemServer().run();
22.     }
24.     private void run() {
25.         // Start services.
26.         try {
27.             t.traceBegin("StartServices");
28.             ...
29.             startOtherServices(t);
30.             ...
31.         } ...
33.     }
35.     private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
36.         ...
37.         //启动Wifi相关服务
38.         if (context.getPackageManager().hasSystemFeature(
39.                 PackageManager.FEATURE_WIFI)) {
40.             // Wifi Service must be started first for wifi-related services.
41.             t.traceBegin("StartWifi");
42.             mSystemServiceManager.startServiceFromJar(
43.                     WIFI_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
44.             t.traceEnd();
45.             t.traceBegin("StartWifiScanning");
46.             mSystemServiceManager.startServiceFromJar(
47.                     WIFI_SCANNING_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
48.             t.traceEnd();
49.         }
50.         
51.         if (context.getPackageManager().hasSystemFeature(
52.                 PackageManager.FEATURE_WIFI_RTT)) {
53.             t.traceBegin("StartRttService");
54.             mSystemServiceManager.startServiceFromJar(
55.                     WIFI_RTT_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
56.             t.traceEnd();
57.         }
58.         
59.         if (context.getPackageManager().hasSystemFeature(
60.                 PackageManager.FEATURE_WIFI_AWARE)) {
61.             t.traceBegin("StartWifiAware");
62.             mSystemServiceManager.startServiceFromJar(
63.                     WIFI_AWARE_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
64.             t.traceEnd();
65.         }
66.         
67.         if (context.getPackageManager().hasSystemFeature(
68.                 PackageManager.FEATURE_WIFI_DIRECT)) {
69.             t.traceBegin("StartWifiP2P");
70.             mSystemServiceManager.startServiceFromJar(
71.                     WIFI_P2P_SERVICE_CLASS, WIFI_APEX_SERVICE_JAR_PATH);
72.             t.traceEnd();
73.         }
74.         ...
75.     }
76. }

复制代码

2.3.2 SystemServiceManager启动系统服务

SystemServiceManager 启动服务的流程大概是：
        1.创建系统服务实例（通过反射）；
        2.注册服务&启动系统服务：
             ①所谓注册，就是将服务对象添加到SystemService列表中；
             ②启动服务：service.onStart()。会向 servicemanager 注册Binder服务的。

1. //frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
2. // Services that should receive lifecycle events.
3. private List<SystemService> mServices;
5. /**
6. * Starts a service by class name and a path that specifies the jar where the service lives.
7. *
8. * @return The service instance.
9. */
10. public SystemService startServiceFromJar(String className, String path) {
11.     PathClassLoader pathClassLoader =
12.             SystemServerClassLoaderFactory.getOrCreateClassLoader(
13.                     path, this.getClass().getClassLoader(), isJarInTestApex(path));
14.     //加载类
15.     final Class<SystemService> serviceClass = loadClassFromLoader(className, pathClassLoader);
16.     //通过反射构造service，并调用它的 onStart 方法
17.     return startService(serviceClass);
18. }
20. private List<SystemService> mServices;
21. public void startService(@NonNull final SystemService service) {
22.     ...
23.     // Register it.
24.     mServices.add(service);
26.     // Start it.
27.     try {
28.         //调用 service 的 onStart方法
29.         service.onStart();
30.     }
31.     ...
32. }

复制代码

下面以 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模块和启动状态机。

1. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiService.java
2. package com.android.server.wifi;
3. ...
4. /**
5. * Service implementing Wi-Fi functionality. Delegates actual interface
6. * implementation to WifiServiceImpl.
7. */
8. public final class WifiService extends SystemService {
10.     private static final String TAG = "WifiService";
11.     ...
12.     private final WifiServiceImpl mImpl;
13.     private final WifiContext mWifiContext;
15.     public WifiService(Context contextBase) {
16.         super(contextBase);
17.         mWifiContext = new WifiContext(contextBase);
18.         //1.创建WifiInjector
19.         WifiInjector injector = new WifiInjector(mWifiContext);
20.         //2.创建WifiServiceImpl（wifi服务的真正实现类）
21.         mImpl = new WifiServiceImpl(mWifiContext, injector);
22.     }
24.     @Override
25.     public void onStart() {
26.         Log.i(TAG, "Registering " + Context.WIFI_SERVICE);
27.         //3.向 servicemanager 注册 wifi 服务(name为 wifi)
28.         publishBinderService(Context.WIFI_SERVICE, mImpl);
29.     }
31.     @Override
32.     public void onBootPhase(int phase) {
33.         if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
34.             //4.在系统服务准备好后，检查是否需要启动wifi
35.             mImpl.checkAndStartWifi();
36.         } else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
37.             //5.在 BOOT_COMPLETED阶段，调用WifiServiceImpl的handleBootCompleted函数
38.             mImpl.handleBootCompleted();
39.         }
40.     }
41.     ...
42. }

复制代码

2.3.3.1 WifiInjector

        WifiInjector是WiFi依靠注入器，通过它可以获取各种WiFi类的实例。在创建WifiInjector时会实例化这些类。

1. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiInjector.java
2. package com.android.server.wifi;
3. /**
4. *  WiFi dependency injector. To be used for accessing various WiFi class instances and as a
5. *  handle for mock injection.
6. *
7. *  Some WiFi class instances currently depend on having a Looper from a HandlerThread that has
8. *  been started. To accommodate this, we have a two-phased approach to initialize and retrieve
9. *  an instance of the WifiInjector.
10. */
11. public class WifiInjector {
12.     private static final String TAG = "WifiInjector";
13.     ...
14.     public WifiInjector(WifiContext context) {
15.         ...
16.         sWifiInjector = this;
17.         ...
18.         // 1.创建和启动 handler 线程
19.         mWifiHandlerThread = new HandlerThread("WifiHandlerThread");
20.         mWifiHandlerThread.start();
21.         Looper wifiLooper = mWifiHandlerThread.getLooper();
22.         ...
23.         mWifiMonitor = new WifiMonitor();
24.         ...
25.         // 2.实例化与 Native 层交互的对象
26.         mHalDeviceManager = new HalDeviceManager(mContext, mClock, this, wifiHandler);
27.         ...
28.         mWifiVendorHal = new WifiVendorHal(mContext, mHalDeviceManager, wifiHandler, mWifiGlobals,
29.                 mSsidTranslator);
30.         mSupplicantStaIfaceHal = new SupplicantStaIfaceHal(
31.                 mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics,
32.                 mWifiGlobals, mSsidTranslator, this);
33.         ...
34.         mWifiNative = new WifiNative(
35.                 mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager,
36.                 mWifiMonitor, mPropertyService, mWifiMetrics,
37.                 wifiHandler, new Random(), mBuildProperties, this);

复制代码

2.3.3.2 WifServiceImpl

WifiServiceImpl 是 wifi 服务的具体实现类，它实现了 IWifiManager 接口，所有的客户端请求（WIFI远程调用请求）都会被它分发给差别的类去进行处置惩罚。
① 类界说

来看下WifiServiceImpl 的构造函数：

1. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiServiceImpl.java
2. package com.android.server.wifi;
3. /**
4. * WifiService handles remote WiFi operation requests by implementing
5. * the IWifiManager interface.
6. */
7. public class WifiServiceImpl extends BaseWifiService {
8.     private static final String TAG = "WifiService";
9.     ...
10.     private final WifiInjector mWifiInjector;
11.    
12.     public WifiServiceImpl(WifiContext context, WifiInjector wifiInjector) {
13.         mContext = context;
14.         mWifiInjector = wifiInjector;
15.         ...
16.         //从 WifiInjector 获取Wifi相关类实例
17.         mWifiThreadRunner = mWifiInjector.getWifiThreadRunner();
18.         mWifiHandlerThread = mWifiInjector.getWifiHandlerThread();
19.         mWifiConfigManager = mWifiInjector.getWifiConfigManager();
20.         mHalDeviceManager = mWifiInjector.getHalDeviceManager();
21.         ...
22.         mWifiConnectivityManager = wifiInjector.getWifiConnectivityManager();
23.         mWifiDataStall = wifiInjector.getWifiDataStall();
24.         mWifiNative = wifiInjector.getWifiNative();
25.         ...
26.     }
27.     ...
28. }
30. //WifiServiceImpl继承BaseWifiService类，来看下BaseWifiService的定义：
31. //packages/modules/Wifi/framework/java/android/net/wifi/BaseWifiService.java
32. package android.net.wifi;
33. ...
34. //根据注释，这个类是空壳，需要被其它类去继承并实现 IWifiManager 的接口。
35. public class BaseWifiService extends IWifiManager.Stub {
36.     ...
37. }
39. //相关的接口声明在 IWifiManager.aidl 文件中：
40. //packages/modules/Wifi/framework/java/android/net/wifi/IWifiManager.aidl
41. package android.net.wifi;
42. ...
43. /**
44. * Interface that allows controlling and querying Wi-Fi connectivity.
45. *
46. * {@hide}
47. */
48. interface IWifiManager
49. {
50.     long getSupportedFeatures();
51.     ...
52.     boolean enableNetwork(int netId, boolean disableOthers, String packageName);
53.     ...
54.     boolean startScan(String packageName, String featureId);
55.     List<ScanResult> getScanResults(String callingPackage, String callingFeatureId);
56.     ...
57.     boolean disconnect(String packageName);
58.     boolean reconnect(String packageName);
59.     ...
60. }

复制代码

② checkAndStartWifi()方法

前面提到，WifiService.onBootPhase() 方法中，会调用 WifiServiceImpl的checkAndStartWifi()方法，去查抄是否必要开启wifi，同时会初始化native模块。下面来看下相关流程：
关键调用链如下：

1. WifiServiceImpl：：checkAndStartWifi
2.   |--ActiveModeWarden::start
3.       |--WifiController.start               
4.           |--setInitialState(mDisabledState)  --判断为不需要开启wifi，设置状态机初始状态为DisabledState
5.           |--WifiNative.initialize            --在启动状态机之前，先初始化native层
6.               |--WifiVendorHal.initialize
7.                   |--HalDeviceManager.initialize
8.                       |--WifiHal.initialize
9.                           |--WifiHalAidlImpl.getWifiServiceMockable  --获取wifi hal服务
10.                       |--registerWifiHalEventCallback
11.                           |--WifiHalAidlImpl.registerEventCallback   --往wifi hal服务注册回调
12.           |--super.start()                    --启动状态机

复制代码

以下是关键源码：

1. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiServiceImpl.java
2. public void checkAndStartWifi() {
3.     mWifiThreadRunner.post(() -> {
4.         ...
5.         // Check if wi-fi needs to be enabled
6.         //判断是否需要启动wifi
7.         boolean wifiEnabled = mSettingsStore.isWifiToggleEnabled();
8.         //这里会打印是否需要启动wifi
9.         Log.i(TAG,
10.                 "WifiService starting up with Wi-Fi " + (wifiEnabled ? "enabled" : "disabled"));
11.         ...
12.         //监听一系列广播
13.         ...
15.         //这里会检查是否需要开启wifi启动，并启动 WifiController 状态机
16.         mActiveModeWarden.start();
17.         registerForCarrierConfigChange();
18.         mWifiInjector.getAdaptiveConnectivityEnabledSettingObserver().initialize();
19.         mIsWifiServiceStarted = true;
20.     });
21. }
23. //packages/modules/Wifi/service/java/com/android/server/wifi/ActiveModeWarden.java
24. /** Begin listening to broadcasts and start the internal state machine. */
25. public void start() {
26.     //监听一系列广播
27.     ...
28.     //启动内部状态机：WifiController
29.     mWifiController.start();
30. }
32. /**
33. * WifiController is the class used to manage wifi state for various operating
34. * modes (normal, airplane, wifi hotspot, etc.).
35. */
36. private class WifiController extends StateMachine {
37.     ...
38.     @Override
39.     public void start() {
40.         ...
41.         //1.这里打印一些关键状态，如：是否打开wifi、是否开启随时扫描等
42.         log("isAirplaneModeOn = " + isAirplaneModeOn
43.                 + ", isWifiEnabled = " + isWifiEnabled
44.                 + ", isScanningAvailable = " + isScanningAlwaysAvailable
45.                 + ", isLocationModeActive = " + isLocationModeActive
46.                 + ", isSatelliteModeOn = " + isSatelliteModeOn);
47.         ...
48.    
49.         //2.获取 ClientRole，以此判断进入什么模式
50.         ActiveModeManager.ClientRole role = getRoleForPrimaryOrScanOnlyClientModeManager();
51.         if (role == ROLE_CLIENT_PRIMARY) {//这个分支是开启wifi
52.             startPrimaryClientModeManager(mLastPrimaryClientModeManagerRequestorWs);
53.             setInitialState(mEnabledState);
54.         } else if (role == ROLE_CLIENT_SCAN_ONLY) {//这个分支是开启scanonly模式
55.             startScanOnlyClientModeManager(mLastScanOnlyClientModeManagerRequestorWs);
56.             setInitialState(mEnabledState);
57.         } else { //如果不需要开启wifi，则设置初始状态为 DisabledState （当前场景进入的是这个分支）
58.             setInitialState(mDisabledState);
59.         }
60.         mWifiMetrics.noteWifiEnabledDuringBoot(mSettingsStore.isWifiToggleEnabled());
61.    
62.         //3.在启动状态机之前，先初始化native层
63.         mWifiNative.initialize();
64.    
65.         //4.启动状态机
66.         super.start();
67.     }
68.    
69. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiNative.java
70. /**
71. * Initialize the native modules.
72. *
73. * @return true on success, false otherwise.
74. */
75. public boolean initialize() {
76.     synchronized (mLock) {
77.         if (!mWifiVendorHal.initialize(new VendorHalDeathHandlerInternal())) {
78.             Log.e(TAG, "Failed to initialize vendor HAL");
79.             return false;
80.         }
81.         ...
82.         return true;
83.     }
84. }
85. //packages/modules/Wifi/service/java/com/android/server/wifi/WifiVendorHal.java
86. /**
87. * Initialize the Hal device manager and register for status callbacks.
88. *
89. * @param handler Handler to notify if the vendor HAL dies.
90. * @return true on success, false otherwise.
91. */
92. public boolean initialize(WifiNative.VendorHalDeathEventHandler handler) {
93.     synchronized (sLock) {
94.         mHalDeviceManager.initialize();
95.         mHalDeviceManager.registerStatusListener(
96.                 mHalDeviceManagerStatusCallbacks, mHalEventHandler);
97.         mDeathEventHandler = handler;
98.         return true;
99.     }
100. }
101. //packages/modules/Wifi/service/java/com/android/server/wifi/HalDeviceManager.java
102. /**
103. * Actually starts the HalDeviceManager: separate from constructor since may want to phase
104. * at a later time.
105. *
106. * TODO: if decide that no need for separating construction from initialization (e.g. both are
107. * done at injector) then move to constructor.
108. */
109. public void initialize() {
110.     initializeInternal();
111.     registerWifiHalEventCallback();
112. }
113. private void initializeInternal() {
114.     mWifiHal.initialize(mIWifiDeathRecipient);
115. }
116. //packages/modules/Wifi/service/java/com/android/server/wifi/hal/WifiHal.java
117. /**
118. * See comments for {@link IWifiHal#initialize(DeathRecipient)}
119. */
120. public void initialize(WifiHal.DeathRecipient deathRecipient) {
121.     if (mWifiHal != null) {
122.         mWifiHal.initialize(deathRecipient);
123.     }
124. }
125. //packages/modules/Wifi/service/java/com/android/server/wifi/hal/WifiHalAidlImpl.java
126. @Override
127. public void initialize(WifiHal.DeathRecipient deathRecipient) {
128.     final String methodStr = "initialize";
129.     synchronized (mLock) {
130.         ...
131.         //1.获取 wifi hal 服务: IWifi
132.         mWifi = getWifiServiceMockable();
133.         ...
134.         Log.i(TAG, "Obtained the IWifi binder. Local Version: "
135.                 + android.hardware.wifi.IWifi.VERSION);
137.         try {
138.             Log.i(TAG, "Remote Version: " + mWifi.getInterfaceVersion());
139.             //转换为IBinder对象
140.             IBinder serviceBinder = getServiceBinderMockable();
141.             ...
142.             //2.注册死亡通知
143.             serviceBinder.linkToDeath(mServiceDeathRecipient, /* flags= */  0);
144.             ...
145.             registerHalCallback();
146.             Log.i(TAG, "Initialization is complete");
147.         } catch (RemoteException e) {
148.             handleRemoteException(e, methodStr);
149.         }
150.     }
151. }

复制代码

2.3.4 SystemServiceRegistry注册服务

       SystemServiceRegistry 类重要用来缓存、注册和获取这些系统服务。当SystemServiceRegistry类被导入内存时，它的static代码块会被实行，而static代码块中大量调用了 registerService() 方法，这样应用层就可以通过 Context.getSystemService 来获取相关的服务了。

1. //frameworks/base/core/java/android/app/SystemServiceRegistry.java
2. /**
3. * Manages all of the system services that can be returned by {@link Context#getSystemService}.
4. * Used by {@link ContextImpl}.
5. *
6. * @hide
7. */
8. @SystemApi
9. public final class SystemServiceRegistry {
10.     ...
11.     static {
12.         ...
13.         //1.
14.         registerService(Context.WIFI_NL80211_SERVICE, WifiNl80211Manager.class,
15.                 new CachedServiceFetcher<WifiNl80211Manager>() {
16.                     @Override
17.                     public WifiNl80211Manager createService(ContextImpl ctx) {
18.                         return new WifiNl80211Manager(ctx.getOuterContext());
19.                     }
20.                 });
21.         ...
22.         try {
23.             ...
24.             //2.注册 wifi framework 服务包装类
25.             WifiFrameworkInitializer.registerServiceWrappers();
26.             ...
27.         }
28. //1
29. /**
30. * Statically registers a system service with the context.
31. * This method must be called during static initialization only.
32. */
33. private static <T> void registerService(@NonNull String serviceName,
34.             @NonNull Class<T> serviceClass, @NonNull ServiceFetcher<T> serviceFetcher) {
35.     SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
36.     SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
37.     SYSTEM_SERVICE_CLASS_NAMES.put(serviceName, serviceClass.getSimpleName());
38. }
40. //2
41. /**
42. * Called by {@link SystemServiceRegistry}'s static initializer and registers all Wifi services
43. * to {@link Context}, so that {@link Context#getSystemService} can return them.
44. *
45. * @throws IllegalStateException if this is called from anywhere besides
46. * {@link SystemServiceRegistry}
47. */
48. public static void registerServiceWrappers() {
49.     SystemServiceRegistry.registerContextAwareService(
50.             Context.WIFI_SERVICE,
51.             WifiManager.class,
52.             (context, serviceBinder) -> {
53.                 if (!context.getPackageManager().hasSystemFeature(
54.                         PackageManager.FEATURE_WIFI)) {
55.                     return null;
56.                 }
57.                 //获取 IWifiManager 对象
58.                 IWifiManager service = IWifiManager.Stub.asInterface(serviceBinder);
59.                 //创建并返回 WifiManager 对象
60.                 return new WifiManager(context, service, getInstanceLooper());
61.             }
62.     );
63.     SystemServiceRegistry.registerContextAwareService(
64.             Context.WIFI_P2P_SERVICE,
65.             WifiP2pManager.class,
66.             (context, serviceBinder) -> {
67.                 if (!context.getPackageManager().hasSystemFeature(
68.                         PackageManager.FEATURE_WIFI_DIRECT)) {
69.                     return null;
70.                 }
71.                 IWifiP2pManager service = IWifiP2pManager.Stub.asInterface(serviceBinder);
72.                 return new WifiP2pManager(service);
73.             }
74.     );
75.     ...

复制代码

参考链接：

Wi-Fi 概览  |  Android Open Source Project


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。