系列文章目录
第一章 国内下载AOSP最新源码的方法
第二章 下载AOSP WiFi相关的代码
第三章 将源码导入Android Studio（无需编译idegen）
提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
Android系统服务都是运行在system_server进程，Wi-Fi服务是众多系统服务中的一个，也是在system_server进程启动时初始化好后应用通过bin der IPC机制调用Wi-Fi服务。本篇简介绍一下Wi-Fi服务启动的流程。
一、Wi-Fi服务是什么？
简单来讲就是com.android.server.wifi.WifiService这个类，它继承自SystemService，所以是一个系统服务类，这个类负责初始化WifiServiceImpl类，并将WifiServiceImpl对象以wifi服务名注册到ServiceManager，让其他应用可以获取到binder代理来调用WifiServiceImpl类中实现的函数。
二、Wi-Fi服务启动流程
SystemServer类从service-wifi.jar启动Wi-Fi服务。
// frameworks/base/services/java/com/android/server/
public final class SystemServer {
....
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";
....
/**
* Starts a miscellaneous grab bag of stuff that has yet to be refactored and organized.
*/
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
....
t.traceBegin("InitConnectivityModuleConnector");
try {
ConnectivityModuleConnector.getInstance().init(context);
} catch (Throwable e) {
reportWtf("initializing ConnectivityModuleConnector", e);
}
t.traceEnd();
t.traceBegin("InitNetworkStackClient");
try {
NetworkStackClient.getInstance().init();
} catch (Throwable e) {
reportWtf("initializing NetworkStackClient", e);
}
t.traceEnd();
t.traceBegin("StartNetworkManagementService");
try {
networkManagement = NetworkManagementService.create(context);
ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
} catch (Throwable e) {
reportWtf("starting NetworkManagement Service", e);
}
t.traceEnd();
t.traceBegin("StartIpSecService");
try {
ipSecService = IpSecService.create(context, networkManagement);
ServiceManager.addService(Context.IPSEC_SERVICE, ipSecService);
} catch (Throwable e) {
reportWtf("starting IpSec Service", e);
}
t.traceEnd();
....
t.traceBegin("StartNetworkScoreService");
mSystemServiceManager.startService(NetworkScoreService.Lifecycle.class);
t.traceEnd();
t.traceBegin("StartNetworkStatsService");
try {
networkStats = NetworkStatsService.create(context, networkManagement);
ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
} catch (Throwable e) {
reportWtf("starting NetworkStats Service", e);
}
t.traceEnd();
t.traceBegin("StartNetworkPolicyManagerService");
try {
networkPolicy = new NetworkPolicyManagerService(context, mActivityManagerService,
networkManagement);
ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
} catch (Throwable e) {
reportWtf("starting NetworkPolicy Service", e);
}
t.traceEnd();
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();
}
....
t.traceBegin("StartConnectivityService");
try {
connectivity = new ConnectivityService(
context, networkManagement, networkStats, networkPolicy);
ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity,
/* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
networkPolicy.bindConnectivityManager(connectivity);
} catch (Throwable e) {
reportWtf("starting Connectivity Service", e);
}
t.traceEnd();
....
Wifi Service must be started first for wifi-related services
这个注释很重要，Wi-Fi基础服务必须在其他Wi-Fi相关服务前启动。
在启动了Wi-Fi服务后，接着启动了WIFI扫描，Wi-Fi RTT，Wi-Fi AWare，Wi-Fi P2P等服务。
SystemServiceManager.startServiceFromJar()这个函数先new传人SystemService类的对象，接着调用对象onStart()方法，下面看一下WifiService：
// frameworks/opt/net/wifi/service/java/com/android/server/wifi/
public final class WifiService extends SystemService {
private static final String TAG = "WifiService";
// Notification channels used by the wifi service.
public static final String NOTIFICATION_NETWORK_STATUS = "NETWORK_STATUS";
public static final String NOTIFICATION_NETWORK_ALERTS = "NETWORK_ALERTS";
public static final String NOTIFICATION_NETWORK_AVAILABLE = "NETWORK_AVAILABLE";
private final WifiServiceImpl mImpl;
private final WifiContext mWifiContext;
public WifiService(Context contextBase) {
super(contextBase);
mWifiContext = new WifiContext(contextBase);
WifiInjector injector = new WifiInjector(mWifiContext); // 工具类，里面初始化了Wi-Fi相关的很多类实例
WifiAsyncChannel channel = new WifiAsyncChannel(TAG); // 对AsyncChannel简单的封装，在消息处理过程中增加了一些log，方便调试
mImpl = new WifiServiceImpl(mWifiContext, injector, channel); // 初始化Wi-Fi服务
}
@Override
public void onStart() {
Log.i(TAG, "Registering " + Context.WIFI_SERVICE);
publishBinderService(Context.WIFI_SERVICE, mImpl); // 发布Wi-Fi服务
}
@Override
public void onBootPhase(int phase) {
if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
createNotificationChannels(mWifiContext);
mImpl.checkAndStartWifi();
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
mImpl.handleBootCompleted(); // 等SystemServer执行到PHASE_BOOT_COMPLETED时，由SystemServer统一调用
}
}
WifiInjector初始化：
// frameworks/opt/net/wifi/service/java/com/android/server/wifi/
public class WifiInjector {
...
private static final String BOOT_DEFAULT_WIFI_COUNTRY_CODE = "ro.boot.wificountrycode"; // 从这个属性读取默认Wi-Fi国家码
static WifiInjector sWifiInjector = null;
...
public WifiInjector(WifiContext context) {
if (context == null) {
throw new IllegalStateException(
"WifiInjector should not be initialized with a null Context.");
}
if (sWifiInjector != null) {
throw new IllegalStateException(
"WifiInjector was already created, use getInstance instead.");
}
sWifiInjector = this; // 单例模式时返回这个对象
// 一定要搞清楚这些handler到底将消息发送到哪个线程的looper了，不然后面代码会看不太懂，不清楚handler机制的建议先搞懂再来看
// Now create and start handler threads
mAsyncChannelHandlerThread = new HandlerThread("AsyncChannelHandlerThread");
mAsyncChannelHandlerThread.start();
mWifiHandlerThread = new HandlerThread("WifiHandlerThread");
mWifiHandlerThread.start();
Looper wifiLooper = mWifiHandlerThread.getLooper();
Handler wifiHandler = new Handler(wifiLooper);
...
mNetworkScoreManager = mContext.getSystemService(NetworkScoreManager.class);
mWifiNetworkScoreCache = new WifiNetworkScoreCache(mContext);
mNetworkScoreManager.registerNetworkScoreCallback(NetworkKey.TYPE_WIFI,
NetworkScoreManager.SCORE_FILTER_NONE,
new HandlerExecutor(wifiHandler), mWifiNetworkScoreCache);
...
mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil);
mSoftApBackupRestore = new SoftApBackupRestore(mContext, mSettingsMigrationDataHolder);
mWifiStateTracker = new WifiStateTracker(mBatteryStats);
mWifiThreadRunner = new WifiThreadRunner(wifiHandler);
mWifiP2pServiceHandlerThread = new HandlerThread("WifiP2pService");
mWifiP2pServiceHandlerThread.start();
mPasspointProvisionerHandlerThread =
new HandlerThread("PasspointProvisionerHandlerThread");
mPasspointProvisionerHandlerThread.start();
...
// Modules interacting with Native.
mWifiMonitor = new WifiMonitor(this);
mHalDeviceManager = new HalDeviceManager(mClock, wifiHandler);
mWifiVendorHal = new WifiVendorHal(mHalDeviceManager, wifiHandler);
mSupplicantStaIfaceHal = new SupplicantStaIfaceHal(
mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics);
mHostapdHal = new HostapdHal(mContext, wifiHandler);
mWifiCondManager = (WifiNl80211Manager) mContext.getSystemService(
Context.WIFI_NL80211_SERVICE);
mWifiNative = new WifiNative(
mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager,
mWifiMonitor, mPropertyService, mWifiMetrics,
wifiHandler, new Random(), this);
mWifiP2pMonitor = new WifiP2pMonitor(this);
mSupplicantP2pIfaceHal = new SupplicantP2pIfaceHal(mWifiP2pMonitor);
mWifiP2pNative = new WifiP2pNative(this,
mWifiVendorHal, mSupplicantP2pIfaceHal, mHalDeviceManager,
mPropertyService);
// Now get instances of all the objects that depend on the HandlerThreads
mWifiTrafficPoller = new WifiTrafficPoller(wifiHandler);
mCountryCode = new WifiCountryCode(mContext, wifiHandler, mWifiNative,
SystemProperties.get(BOOT_DEFAULT_WIFI_COUNTRY_CODE));
...
mWifiScoreCard = new WifiScoreCard(mClock, l2KeySeed, mDeviceConfigFacade);
...
// Config Manager
mWifiConfigManager = new WifiConfigManager(mContext, mClock,
mUserManager, mWifiCarrierInfoManager,
mWifiKeyStore, mWifiConfigStore, mWifiPermissionsUtil,
mWifiPermissionsWrapper, this,
new NetworkListSharedStoreData(mContext),
new NetworkListUserStoreData(mContext),
new RandomizedMacStoreData(), mFrameworkFacade, wifiHandler, mDeviceConfigFacade,
mWifiScoreCard, mLruConnectionTracker);
mSettingsConfigStore = new WifiSettingsConfigStore(context, wifiHandler,
mSettingsMigrationDataHolder, mWifiConfigManager, mWifiConfigStore);
mSettingsStore = new WifiSettingsStore(mContext, mSettingsConfigStore);
...
mWifiNetworkSelector = new WifiNetworkSelector(mContext, mWifiScoreCard, mScoringParams,
mWifiConfigManager, mClock, mConnectivityLocalLog, mWifiMetrics, mWifiNative,
mThroughputPredictor);
CompatibilityScorer compatibilityScorer = new CompatibilityScorer(mScoringParams);
mWifiNetworkSelector.registerCandidateScorer(compatibilityScorer);
ScoreCardBasedScorer scoreCardBasedScorer = new ScoreCardBasedScorer(mScoringParams);
mWifiNetworkSelector.registerCandidateScorer(scoreCardBasedScorer);
BubbleFunScorer bubbleFunScorer = new BubbleFunScorer(mScoringParams);
mWifiNetworkSelector.registerCandidateScorer(bubbleFunScorer);
ThroughputScorer throughputScorer = new ThroughputScorer(mScoringParams);
mWifiNetworkSelector.registerCandidateScorer(throughputScorer);
mWifiMetrics.setWifiNetworkSelector(mWifiNetworkSelector);
mWifiNetworkSuggestionsManager = new WifiNetworkSuggestionsManager(mContext, wifiHandler,
this, mWifiPermissionsUtil, mWifiConfigManager, mWifiConfigStore, mWifiMetrics,
mWifiCarrierInfoManager, mWifiKeyStore, mLruConnectionTracker);
mPasspointManager = new PasspointManager(mContext, this,
wifiHandler, mWifiNative, mWifiKeyStore, mClock, new PasspointObjectFactory(),
mWifiConfigManager, mWifiConfigStore, mWifiMetrics, mWifiCarrierInfoManager);
PasspointNetworkNominateHelper nominateHelper =
new PasspointNetworkNominateHelper(mPasspointManager, mWifiConfigManager,
mConnectivityLocalLog);
mSavedNetworkNominator = new SavedNetworkNominator(
mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager,
mWifiPermissionsUtil, mWifiNetworkSuggestionsManager);
mNetworkSuggestionNominator = new NetworkSuggestionNominator(mWifiNetworkSuggestionsManager,
mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager);
mScoredNetworkNominator = new ScoredNetworkNominator(mContext, wifiHandler,
mFrameworkFacade, mNetworkScoreManager, mContext.getPackageManager(),
mWifiConfigManager, mConnectivityLocalLog,
mWifiNetworkScoreCache, mWifiPermissionsUtil);
...
mScanRequestProxy = new ScanRequestProxy(mContext,
(AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE),
(ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE),
this, mWifiConfigManager,
mWifiPermissionsUtil, mWifiMetrics, mClock, wifiHandler, mSettingsConfigStore);
mSarManager = new SarManager(mContext, makeTelephonyManager(), wifiLooper,
mWifiNative);
...
mWifiDataStall = new WifiDataStall(mFrameworkFacade, mWifiMetrics, mContext,
mDeviceConfigFacade, mWifiChannelUtilizationConnected, mClock, wifiHandler,
mThroughputPredictor);
...
mLinkProbeManager = new LinkProbeManager(mClock, mWifiNative, mWifiMetrics,
mFrameworkFacade, wifiHandler, mContext);
SupplicantStateTracker supplicantStateTracker = new SupplicantStateTracker(
mContext, mWifiConfigManager, mBatteryStats, wifiHandler);
mMboOceController = new MboOceController(makeTelephonyManager(), mWifiNative);
mWifiHealthMonitor = new WifiHealthMonitor(mContext, this, mClock, mWifiConfigManager,
mWifiScoreCard, wifiHandler, mWifiNative, l2KeySeed, mDeviceConfigFacade);
...
// ClientModeImpl是用来取代Oreo之前的WifiStateMachine，这个里面管理Client(STA)模式时的状态
mClientModeImpl = new ClientModeImpl(mContext, mFrameworkFacade,
wifiLooper, mUserManager,
this, mBackupManagerProxy, mCountryCode, mWifiNative,
new WrongPasswordNotifier(mContext, mFrameworkFacade),
mSarManager, mWifiTrafficPoller, mLinkProbeManager, mBatteryStats,
supplicantStateTracker, mMboOceController, mWifiCarrierInfoManager,
new EapFailureNotifier(mContext, mFrameworkFacade, mWifiCarrierInfoManager),
new SimRequiredNotifier(mContext, mFrameworkFacade));
mActiveModeWarden = new ActiveModeWarden(this, wifiLooper,
mWifiNative, new DefaultModeManager(mContext), mBatteryStats, mWifiDiagnostics,
mContext, mClientModeImpl, mSettingsStore, mFrameworkFacade, mWifiPermissionsUtil);
mWifiScanAlwaysAvailableSettingsCompatibility =
new WifiScanAlwaysAvailableSettingsCompatibility(mContext, wifiHandler,
mSettingsStore, mActiveModeWarden, mFrameworkFacade);
mWifiApConfigStore = new WifiApConfigStore(
mContext, this, wifiHandler, mBackupManagerProxy,
mWifiConfigStore, mWifiConfigManager, mActiveModeWarden, mWifiMetrics);
...
mSelfRecovery = new SelfRecovery(mContext, mActiveModeWarden, mClock);
...
// Register the various network Nominators with the network selector.
mWifiNetworkSelector.registerNetworkNominator(mSavedNetworkNominator);
mWifiNetworkSelector.registerNetworkNominator(mNetworkSuggestionNominator);
mWifiNetworkSelector.registerNetworkNominator(mScoredNetworkNominator);
// 最后启动Client模式状态机
mClientModeImpl.start();
接下来看一下WifiServiceImpl的初始化：
// frameworks/opt/net/wifi/service/java/com/android/server/wifi/
public class WifiServiceImpl extends BaseWifiService {
private static final String TAG = "WifiService";
...
// 主要就是从WifiInjector将一些对象赋值给自己的成员变量，然后注册一些本类实现的回调函数
public WifiServiceImpl(Context context, WifiInjector wifiInjector, AsyncChannel asyncChannel) {
mContext = context;
mWifiInjector = wifiInjector;
mClock = wifiInjector.getClock();
mFacade = mWifiInjector.getFrameworkFacade();
mWifiMetrics = mWifiInjector.getWifiMetrics();
mWifiTrafficPoller = mWifiInjector.getWifiTrafficPoller();
mUserManager = mWifiInjector.getUserManager();
mCountryCode = mWifiInjector.getWifiCountryCode();
mClientModeImpl = mWifiInjector.getClientModeImpl();
mActiveModeWarden = mWifiInjector.getActiveModeWarden();
mScanRequestProxy = mWifiInjector.getScanRequestProxy();
mSettingsStore = mWifiInjector.getWifiSettingsStore();
mPowerManager = mContext.getSystemService(PowerManager.class);
mAppOps = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
mWifiLockManager = mWifiInjector.getWifiLockManager();
mWifiMulticastLockManager = mWifiInjector.getWifiMulticastLockManager();
// 重点：这里要注意，这个handler类存在的意义，是作为mClientModeImplChannel的两个handler中的一个，
// 另一个handler是ClientModeImpl所在的Handler，在mClientModeImplChannel连上这两个handler后就可以通过
// AsyncChannel机制在不同线程甚至不同进程间进行消息传递，这里主要是用来在WifiServiceImpl所在的线程与
// ClientModeImpl所在的线程WifiHandlerThread之间进行消息传递，后面可以看到WifiServiceImpl里面
// 很多函数都是类似mClientModeImpl.syncGetCurrentNetwork(mClientModeImplChannel)这样的，要明白这个调用的意义。
mClientModeImplHandler = new ClientModeImplHandler(TAG,
mWifiInjector.getAsyncChannelHandlerThread().getLooper(), asyncChannel);
mWifiBackupRestore = mWifiInjector.getWifiBackupRestore();
mSoftApBackupRestore = mWifiInjector.getSoftApBackupRestore();
mWifiApConfigStore = mWifiInjector.getWifiApConfigStore();
mWifiPermissionsUtil = mWifiInjector.getWifiPermissionsUtil();
mLog = mWifiInjector.makeLog(TAG);
mFrameworkFacade = wifiInjector.getFrameworkFacade();
mTetheredSoftApTracker = new TetheredSoftApTracker();
mActiveModeWarden.registerSoftApCallback(mTetheredSoftApTracker);
mLohsSoftApTracker = new LohsSoftApTracker();
mActiveModeWarden.registerLohsCallback(mLohsSoftApTracker);
mWifiNetworkSuggestionsManager = mWifiInjector.getWifiNetworkSuggestionsManager();
mDppManager = mWifiInjector.getDppManager();
mWifiThreadRunner = mWifiInjector.getWifiThreadRunner();
mWifiConfigManager = mWifiInjector.getWifiConfigManager();
mPasspointManager = mWifiInjector.getPasspointManager();
mWifiScoreCard = mWifiInjector.getWifiScoreCard();
mMemoryStoreImpl = new MemoryStoreImpl(mContext, mWifiInjector,
mWifiScoreCard, mWifiInjector.getWifiHealthMonitor());
}
在WifiServiceImpl这个类里面要注意checkAndStartWifi()，如果想让系统开机默认打开或关闭Wi-Fi，可以在这个地方修改，这个函数是在WifiService类里面当SystemServer类回调onBootPhase()时会被调用：
// frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiService.java
@Override
public void onBootPhase(int phase) {
if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
createNotificationChannels(mWifiContext);
mImpl.checkAndStartWifi();
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
mImpl.handleBootCompleted();
}
}
下面看一下checkAndStartWifi()的实现：
/**
* Check if we are ready to start wifi.
*
* First check if we will be restarting system services to decrypt the device. If the device is
* not encrypted, check if Wi-Fi needs to be enabled and start if needed
*
* This function is used only at boot time.
*/
public void checkAndStartWifi() {
mWifiThreadRunner.post(() -> {
// 首先，从/data/misc/wifi/WifiConfigStore.xml加载配置
if (!mWifiConfigManager.loadFromStore()) {
Log.e(TAG, "Failed to load from config store");
}
// config store is read, check if verbose logging is enabled.
enableVerboseLoggingInternal(getVerboseLoggingLevel());
// Check if wi-fi needs to be enabled
// 从SettingsProvider检查Wi-Fi开关状态
boolean wifiEnabled = mSettingsStore.isWifiToggleEnabled();
Log.i(TAG,
"WifiService starting up with Wi-Fi " + (wifiEnabled ? "enabled" : "disabled"));
// 开始监听SettingsProvider中ScanAlwaysAvailable字段
mWifiInjector.getWifiScanAlwaysAvailableSettingsCompatibility().initialize();
// 下面几个监听SIM卡状态的都是为了更新Passpoint网络永久/临时鉴权信息的
mContext.registerReceiver(
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (mSettingsStore.handleAirplaneModeToggled()) {
mActiveModeWarden.airplaneModeToggled();
}
}
},
new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED));
mContext.registerReceiver(
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
int state = intent.getIntExtra(TelephonyManager.EXTRA_SIM_STATE,
TelephonyManager.SIM_STATE_UNKNOWN);
if (TelephonyManager.SIM_STATE_ABSENT == state) {
Log.d(TAG, "resetting networks because SIM was removed");
mClientModeImpl.resetSimAuthNetworks(
ClientModeImpl.RESET_SIM_REASON_SIM_REMOVED);
}
}
},
new IntentFilter(TelephonyManager.ACTION_SIM_CARD_STATE_CHANGED));
mContext.registerReceiver(
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
int state = intent.getIntExtra(TelephonyManager.EXTRA_SIM_STATE,
TelephonyManager.SIM_STATE_UNKNOWN);
if (TelephonyManager.SIM_STATE_LOADED == state) {
Log.d(TAG, "resetting networks because SIM was loaded");
mClientModeImpl.resetSimAuthNetworks(
ClientModeImpl.RESET_SIM_REASON_SIM_INSERTED);
}
}
},
new IntentFilter(TelephonyManager.ACTION_SIM_APPLICATION_STATE_CHANGED));
mContext.registerReceiver(
new BroadcastReceiver() {
private int mLastSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
@Override
public void onReceive(Context context, Intent intent) {
final int subId = intent.getIntExtra("subscription",
SubscriptionManager.INVALID_SUBSCRIPTION_ID);
if (subId != mLastSubId) {
Log.d(TAG, "resetting networks as default data SIM is changed");
mClientModeImpl.resetSimAuthNetworks(
ClientModeImpl.RESET_SIM_REASON_DEFAULT_DATA_SIM_CHANGED);
mLastSubId = subId;
}
}
},
new IntentFilter(TelephonyManager.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED));
// Adding optimizations of only receiving broadcasts when wifi is enabled
// can result in race conditions when apps toggle wifi in the background
// without active user involvement. Always receive broadcasts.
registerForBroadcasts();
mInIdleMode = mPowerManager.isDeviceIdleMode();
// 初始化WifiNative, HAL Service等
mClientModeImpl.initialize();
// 启动ClientModeManager和WifiController，注意在R上面WifiController变成了ActiveModeWarden的内部类了
mActiveModeWarden.start();
registerForCarrierConfigChange();
});
}
到这里，Wi-Fi服务，WifiNative, Wifi HAL Service, wpa_supplicant, wlan driver，wlan firmware, ConnectivityServcie, NetworkStack, DNSResolver都初始化好了，剩下的就是等待客户端调用。
总结
以上就是今天要讲的内容，本文介绍了Wi-Fi服务的启动过程。
512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
