1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.wifi; 18 19 import android.annotation.NonNull; 20 import android.app.ActivityManager; 21 import android.app.AlarmManager; 22 import android.app.AppOpsManager; 23 import android.app.NotificationManager; 24 import android.content.Context; 25 import android.net.IpMemoryStore; 26 import android.net.NetworkCapabilities; 27 import android.net.NetworkKey; 28 import android.net.NetworkScoreManager; 29 import android.net.wifi.WifiManager; 30 import android.net.wifi.WifiScanner; 31 import android.net.wifi.nl80211.WifiNl80211Manager; 32 import android.os.BatteryStatsManager; 33 import android.os.Handler; 34 import android.os.HandlerExecutor; 35 import android.os.HandlerThread; 36 import android.os.Looper; 37 import android.os.Process; 38 import android.os.SystemProperties; 39 import android.os.UserManager; 40 import android.provider.Settings.Secure; 41 import android.security.keystore.AndroidKeyStoreProvider; 42 import android.telephony.SubscriptionManager; 43 import android.telephony.TelephonyManager; 44 import android.util.LocalLog; 45 import android.util.Log; 46 47 import com.android.server.wifi.aware.WifiAwareMetrics; 48 import com.android.server.wifi.hotspot2.PasspointManager; 49 import com.android.server.wifi.hotspot2.PasspointNetworkNominateHelper; 50 import com.android.server.wifi.hotspot2.PasspointObjectFactory; 51 import com.android.server.wifi.p2p.SupplicantP2pIfaceHal; 52 import com.android.server.wifi.p2p.WifiP2pMetrics; 53 import com.android.server.wifi.p2p.WifiP2pMonitor; 54 import com.android.server.wifi.p2p.WifiP2pNative; 55 import com.android.server.wifi.rtt.RttMetrics; 56 import com.android.server.wifi.util.LruConnectionTracker; 57 import com.android.server.wifi.util.NetdWrapper; 58 import com.android.server.wifi.util.SettingsMigrationDataHolder; 59 import com.android.server.wifi.util.WifiPermissionsUtil; 60 import com.android.server.wifi.util.WifiPermissionsWrapper; 61 62 import java.security.KeyStore; 63 import java.security.KeyStoreException; 64 import java.security.NoSuchProviderException; 65 import java.util.Random; 66 67 /** 68 * WiFi dependency injector. To be used for accessing various WiFi class instances and as a 69 * handle for mock injection. 70 * 71 * Some WiFi class instances currently depend on having a Looper from a HandlerThread that has 72 * been started. To accommodate this, we have a two-phased approach to initialize and retrieve 73 * an instance of the WifiInjector. 74 */ 75 public class WifiInjector { 76 private static final String TAG = "WifiInjector"; 77 private static final String BOOT_DEFAULT_WIFI_COUNTRY_CODE = "ro.boot.wificountrycode"; 78 /** 79 * Maximum number in-memory store network connection order; 80 */ 81 private static final int MAX_RECENTLY_CONNECTED_NETWORK = 100; 82 83 static WifiInjector sWifiInjector = null; 84 85 private final WifiContext mContext; 86 private final BatteryStatsManager mBatteryStats; 87 private final FrameworkFacade mFrameworkFacade; 88 private final DeviceConfigFacade mDeviceConfigFacade; 89 private final UserManager mUserManager; 90 private final HandlerThread mAsyncChannelHandlerThread; 91 private final HandlerThread mWifiHandlerThread; 92 private final HandlerThread mWifiP2pServiceHandlerThread; 93 private final HandlerThread mPasspointProvisionerHandlerThread; 94 private final WifiTrafficPoller mWifiTrafficPoller; 95 private final WifiCountryCode mCountryCode; 96 private final BackupManagerProxy mBackupManagerProxy = new BackupManagerProxy(); 97 private final WifiApConfigStore mWifiApConfigStore; 98 private final WifiNative mWifiNative; 99 private final WifiMonitor mWifiMonitor; 100 private final WifiP2pNative mWifiP2pNative; 101 private final WifiP2pMonitor mWifiP2pMonitor; 102 private final SupplicantStaIfaceHal mSupplicantStaIfaceHal; 103 private final SupplicantP2pIfaceHal mSupplicantP2pIfaceHal; 104 private final HostapdHal mHostapdHal; 105 private final WifiVendorHal mWifiVendorHal; 106 private final ScoringParams mScoringParams; 107 private final ClientModeImpl mClientModeImpl; 108 private final ActiveModeWarden mActiveModeWarden; 109 private final WifiSettingsStore mSettingsStore; 110 private OpenNetworkNotifier mOpenNetworkNotifier; 111 private final WifiLockManager mLockManager; 112 private final WifiNl80211Manager mWifiCondManager; 113 private final Clock mClock = new Clock(); 114 private final WifiMetrics mWifiMetrics; 115 private final WifiP2pMetrics mWifiP2pMetrics; 116 private WifiLastResortWatchdog mWifiLastResortWatchdog; 117 private final PropertyService mPropertyService = new SystemPropertyService(); 118 private final BuildProperties mBuildProperties = new SystemBuildProperties(); 119 private final WifiBackupRestore mWifiBackupRestore; 120 private final SoftApBackupRestore mSoftApBackupRestore; 121 private final WifiMulticastLockManager mWifiMulticastLockManager; 122 private final WifiConfigStore mWifiConfigStore; 123 private final WifiKeyStore mWifiKeyStore; 124 private final WifiConfigManager mWifiConfigManager; 125 private final WifiConnectivityHelper mWifiConnectivityHelper; 126 private final LocalLog mConnectivityLocalLog; 127 private final WifiNetworkSelector mWifiNetworkSelector; 128 private final SavedNetworkNominator mSavedNetworkNominator; 129 private final NetworkSuggestionNominator mNetworkSuggestionNominator; 130 private final ScoredNetworkNominator mScoredNetworkNominator; 131 private final WifiNetworkScoreCache mWifiNetworkScoreCache; 132 private final NetworkScoreManager mNetworkScoreManager; 133 private WifiScanner mWifiScanner; 134 private final WifiPermissionsWrapper mWifiPermissionsWrapper; 135 private final WifiPermissionsUtil mWifiPermissionsUtil; 136 private final PasspointManager mPasspointManager; 137 private HandlerThread mWifiAwareHandlerThread; 138 private HandlerThread mRttHandlerThread; 139 private HalDeviceManager mHalDeviceManager; 140 private final WifiStateTracker mWifiStateTracker; 141 private final SelfRecovery mSelfRecovery; 142 private final WakeupController mWakeupController; 143 private final ScanRequestProxy mScanRequestProxy; 144 private final SarManager mSarManager; 145 private final BaseWifiDiagnostics mWifiDiagnostics; 146 private final WifiDataStall mWifiDataStall; 147 private final WifiScoreCard mWifiScoreCard; 148 private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager; 149 private final DppMetrics mDppMetrics; 150 private final DppManager mDppManager; 151 private final LinkProbeManager mLinkProbeManager; 152 private IpMemoryStore mIpMemoryStore; 153 private final WifiThreadRunner mWifiThreadRunner; 154 private BssidBlocklistMonitor mBssidBlocklistMonitor; 155 private final MacAddressUtil mMacAddressUtil; 156 private final MboOceController mMboOceController; 157 private final WifiCarrierInfoManager mWifiCarrierInfoManager; 158 private WifiChannelUtilization mWifiChannelUtilizationScan; 159 private WifiChannelUtilization mWifiChannelUtilizationConnected; 160 private final KeyStore mKeyStore; 161 private final ConnectionFailureNotificationBuilder mConnectionFailureNotificationBuilder; 162 private final ThroughputPredictor mThroughputPredictor; 163 private NetdWrapper mNetdWrapper; 164 private final WifiHealthMonitor mWifiHealthMonitor; 165 private final WifiSettingsConfigStore mSettingsConfigStore; 166 private final WifiScanAlwaysAvailableSettingsCompatibility 167 mWifiScanAlwaysAvailableSettingsCompatibility; 168 private final SettingsMigrationDataHolder mSettingsMigrationDataHolder; 169 private final LruConnectionTracker mLruConnectionTracker; 170 WifiInjector(WifiContext context)171 public WifiInjector(WifiContext context) { 172 if (context == null) { 173 throw new IllegalStateException( 174 "WifiInjector should not be initialized with a null Context."); 175 } 176 177 if (sWifiInjector != null) { 178 throw new IllegalStateException( 179 "WifiInjector was already created, use getInstance instead."); 180 } 181 182 sWifiInjector = this; 183 184 // Now create and start handler threads 185 mAsyncChannelHandlerThread = new HandlerThread("AsyncChannelHandlerThread"); 186 mAsyncChannelHandlerThread.start(); 187 mWifiHandlerThread = new HandlerThread("WifiHandlerThread"); 188 mWifiHandlerThread.start(); 189 Looper wifiLooper = mWifiHandlerThread.getLooper(); 190 Handler wifiHandler = new Handler(wifiLooper); 191 192 mFrameworkFacade = new FrameworkFacade(); 193 mMacAddressUtil = new MacAddressUtil(); 194 mContext = context; 195 mScoringParams = new ScoringParams(mContext); 196 mSettingsMigrationDataHolder = new SettingsMigrationDataHolder(mContext); 197 mConnectionFailureNotificationBuilder = new ConnectionFailureNotificationBuilder( 198 mContext, getWifiStackPackageName(), mFrameworkFacade); 199 mBatteryStats = context.getSystemService(BatteryStatsManager.class); 200 mWifiPermissionsWrapper = new WifiPermissionsWrapper(mContext); 201 mNetworkScoreManager = mContext.getSystemService(NetworkScoreManager.class); 202 mWifiNetworkScoreCache = new WifiNetworkScoreCache(mContext); 203 mNetworkScoreManager.registerNetworkScoreCallback(NetworkKey.TYPE_WIFI, 204 NetworkScoreManager.SCORE_FILTER_NONE, 205 new HandlerExecutor(wifiHandler), mWifiNetworkScoreCache); 206 mUserManager = mContext.getSystemService(UserManager.class); 207 mWifiPermissionsUtil = new WifiPermissionsUtil(mWifiPermissionsWrapper, mContext, 208 mUserManager, this); 209 mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil); 210 mSoftApBackupRestore = new SoftApBackupRestore(mContext, mSettingsMigrationDataHolder); 211 mWifiStateTracker = new WifiStateTracker(mBatteryStats); 212 mWifiThreadRunner = new WifiThreadRunner(wifiHandler); 213 mWifiP2pServiceHandlerThread = new HandlerThread("WifiP2pService"); 214 mWifiP2pServiceHandlerThread.start(); 215 mPasspointProvisionerHandlerThread = 216 new HandlerThread("PasspointProvisionerHandlerThread"); 217 mPasspointProvisionerHandlerThread.start(); 218 WifiAwareMetrics awareMetrics = new WifiAwareMetrics(mClock); 219 RttMetrics rttMetrics = new RttMetrics(mClock); 220 mWifiP2pMetrics = new WifiP2pMetrics(mClock); 221 mDppMetrics = new DppMetrics(); 222 mWifiMetrics = new WifiMetrics(mContext, mFrameworkFacade, mClock, wifiLooper, 223 awareMetrics, rttMetrics, new WifiPowerMetrics(mBatteryStats), mWifiP2pMetrics, 224 mDppMetrics); 225 mDeviceConfigFacade = new DeviceConfigFacade(mContext, wifiHandler, mWifiMetrics); 226 // Modules interacting with Native. 227 mWifiMonitor = new WifiMonitor(this); 228 mHalDeviceManager = new HalDeviceManager(mClock, wifiHandler); 229 mWifiVendorHal = new WifiVendorHal(mHalDeviceManager, wifiHandler); 230 mSupplicantStaIfaceHal = new SupplicantStaIfaceHal( 231 mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics); 232 mHostapdHal = new HostapdHal(mContext, wifiHandler); 233 mWifiCondManager = (WifiNl80211Manager) mContext.getSystemService( 234 Context.WIFI_NL80211_SERVICE); 235 mWifiNative = new WifiNative( 236 mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager, 237 mWifiMonitor, mPropertyService, mWifiMetrics, 238 wifiHandler, new Random(), this); 239 mWifiP2pMonitor = new WifiP2pMonitor(this); 240 mSupplicantP2pIfaceHal = new SupplicantP2pIfaceHal(mWifiP2pMonitor); 241 mWifiP2pNative = new WifiP2pNative(this, 242 mWifiVendorHal, mSupplicantP2pIfaceHal, mHalDeviceManager, 243 mPropertyService); 244 245 // Now get instances of all the objects that depend on the HandlerThreads 246 mWifiTrafficPoller = new WifiTrafficPoller(wifiHandler); 247 mCountryCode = new WifiCountryCode(mContext, wifiHandler, mWifiNative, 248 SystemProperties.get(BOOT_DEFAULT_WIFI_COUNTRY_CODE)); 249 // WifiConfigManager/Store objects and their dependencies. 250 KeyStore keyStore = null; 251 try { 252 keyStore = AndroidKeyStoreProvider.getKeyStoreForUid(Process.WIFI_UID); 253 } catch (KeyStoreException | NoSuchProviderException e) { 254 Log.wtf(TAG, "Failed to load keystore", e); 255 } 256 mKeyStore = keyStore; 257 mWifiKeyStore = new WifiKeyStore(mKeyStore); 258 // New config store 259 mWifiConfigStore = new WifiConfigStore(mContext, wifiHandler, mClock, mWifiMetrics, 260 WifiConfigStore.createSharedFiles(mFrameworkFacade.isNiapModeOn(mContext))); 261 SubscriptionManager subscriptionManager = 262 mContext.getSystemService(SubscriptionManager.class); 263 mWifiCarrierInfoManager = new WifiCarrierInfoManager(makeTelephonyManager(), 264 subscriptionManager, this, mFrameworkFacade, mContext, 265 mWifiConfigStore, wifiHandler, mWifiMetrics); 266 String l2KeySeed = Secure.getString(mContext.getContentResolver(), Secure.ANDROID_ID); 267 mWifiScoreCard = new WifiScoreCard(mClock, l2KeySeed, mDeviceConfigFacade); 268 mWifiMetrics.setWifiScoreCard(mWifiScoreCard); 269 mLruConnectionTracker = new LruConnectionTracker(MAX_RECENTLY_CONNECTED_NETWORK, 270 mContext); 271 // Config Manager 272 mWifiConfigManager = new WifiConfigManager(mContext, mClock, 273 mUserManager, mWifiCarrierInfoManager, 274 mWifiKeyStore, mWifiConfigStore, mWifiPermissionsUtil, 275 mWifiPermissionsWrapper, this, 276 new NetworkListSharedStoreData(mContext), 277 new NetworkListUserStoreData(mContext), 278 new RandomizedMacStoreData(), mFrameworkFacade, wifiHandler, mDeviceConfigFacade, 279 mWifiScoreCard, mLruConnectionTracker); 280 mSettingsConfigStore = new WifiSettingsConfigStore(context, wifiHandler, 281 mSettingsMigrationDataHolder, mWifiConfigManager, mWifiConfigStore); 282 mSettingsStore = new WifiSettingsStore(mContext, mSettingsConfigStore); 283 mWifiMetrics.setWifiConfigManager(mWifiConfigManager); 284 285 mWifiConnectivityHelper = new WifiConnectivityHelper(mWifiNative); 286 mConnectivityLocalLog = new LocalLog( 287 mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? 256 : 512); 288 mWifiMetrics.setScoringParams(mScoringParams); 289 mThroughputPredictor = new ThroughputPredictor(mContext); 290 mWifiNetworkSelector = new WifiNetworkSelector(mContext, mWifiScoreCard, mScoringParams, 291 mWifiConfigManager, mClock, mConnectivityLocalLog, mWifiMetrics, mWifiNative, 292 mThroughputPredictor); 293 CompatibilityScorer compatibilityScorer = new CompatibilityScorer(mScoringParams); 294 mWifiNetworkSelector.registerCandidateScorer(compatibilityScorer); 295 ScoreCardBasedScorer scoreCardBasedScorer = new ScoreCardBasedScorer(mScoringParams); 296 mWifiNetworkSelector.registerCandidateScorer(scoreCardBasedScorer); 297 BubbleFunScorer bubbleFunScorer = new BubbleFunScorer(mScoringParams); 298 mWifiNetworkSelector.registerCandidateScorer(bubbleFunScorer); 299 ThroughputScorer throughputScorer = new ThroughputScorer(mScoringParams); 300 mWifiNetworkSelector.registerCandidateScorer(throughputScorer); 301 mWifiMetrics.setWifiNetworkSelector(mWifiNetworkSelector); 302 mWifiNetworkSuggestionsManager = new WifiNetworkSuggestionsManager(mContext, wifiHandler, 303 this, mWifiPermissionsUtil, mWifiConfigManager, mWifiConfigStore, mWifiMetrics, 304 mWifiCarrierInfoManager, mWifiKeyStore, mLruConnectionTracker); 305 mPasspointManager = new PasspointManager(mContext, this, 306 wifiHandler, mWifiNative, mWifiKeyStore, mClock, new PasspointObjectFactory(), 307 mWifiConfigManager, mWifiConfigStore, mWifiMetrics, mWifiCarrierInfoManager, 308 mMacAddressUtil, mWifiPermissionsUtil); 309 PasspointNetworkNominateHelper nominateHelper = 310 new PasspointNetworkNominateHelper(mPasspointManager, mWifiConfigManager, 311 mConnectivityLocalLog); 312 mSavedNetworkNominator = new SavedNetworkNominator( 313 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager, 314 mWifiPermissionsUtil, mWifiNetworkSuggestionsManager); 315 mNetworkSuggestionNominator = new NetworkSuggestionNominator(mWifiNetworkSuggestionsManager, 316 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager); 317 mScoredNetworkNominator = new ScoredNetworkNominator(mContext, wifiHandler, 318 mFrameworkFacade, mNetworkScoreManager, mContext.getPackageManager(), 319 mWifiConfigManager, mConnectivityLocalLog, 320 mWifiNetworkScoreCache, mWifiPermissionsUtil); 321 322 mWifiMetrics.setPasspointManager(mPasspointManager); 323 mScanRequestProxy = new ScanRequestProxy(mContext, 324 (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE), 325 (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE), 326 this, mWifiConfigManager, 327 mWifiPermissionsUtil, mWifiMetrics, mClock, wifiHandler, mSettingsConfigStore); 328 mSarManager = new SarManager(mContext, makeTelephonyManager(), wifiLooper, 329 mWifiNative); 330 mWifiDiagnostics = new WifiDiagnostics( 331 mContext, this, mWifiNative, mBuildProperties, 332 new LastMileLogger(this), mClock); 333 mWifiChannelUtilizationConnected = new WifiChannelUtilization(mClock, mContext); 334 mWifiDataStall = new WifiDataStall(mFrameworkFacade, mWifiMetrics, mContext, 335 mDeviceConfigFacade, mWifiChannelUtilizationConnected, mClock, wifiHandler, 336 mThroughputPredictor); 337 mWifiMetrics.setWifiDataStall(mWifiDataStall); 338 mLinkProbeManager = new LinkProbeManager(mClock, mWifiNative, mWifiMetrics, 339 mFrameworkFacade, wifiHandler, mContext); 340 SupplicantStateTracker supplicantStateTracker = new SupplicantStateTracker( 341 mContext, mWifiConfigManager, mBatteryStats, wifiHandler); 342 mMboOceController = new MboOceController(makeTelephonyManager(), mWifiNative); 343 mWifiHealthMonitor = new WifiHealthMonitor(mContext, this, mClock, mWifiConfigManager, 344 mWifiScoreCard, wifiHandler, mWifiNative, l2KeySeed, mDeviceConfigFacade); 345 mWifiMetrics.setWifiHealthMonitor(mWifiHealthMonitor); 346 mClientModeImpl = new ClientModeImpl(mContext, mFrameworkFacade, 347 wifiLooper, mUserManager, 348 this, mBackupManagerProxy, mCountryCode, mWifiNative, 349 new WrongPasswordNotifier(mContext, mFrameworkFacade), 350 mSarManager, mWifiTrafficPoller, mLinkProbeManager, mBatteryStats, 351 supplicantStateTracker, mMboOceController, mWifiCarrierInfoManager, 352 new EapFailureNotifier(mContext, mFrameworkFacade, mWifiCarrierInfoManager), 353 new SimRequiredNotifier(mContext, mFrameworkFacade)); 354 mActiveModeWarden = new ActiveModeWarden(this, wifiLooper, 355 mWifiNative, new DefaultModeManager(mContext), mBatteryStats, mWifiDiagnostics, 356 mContext, mClientModeImpl, mSettingsStore, mFrameworkFacade, mWifiPermissionsUtil); 357 mWifiScanAlwaysAvailableSettingsCompatibility = 358 new WifiScanAlwaysAvailableSettingsCompatibility(mContext, wifiHandler, 359 mSettingsStore, mActiveModeWarden, mFrameworkFacade); 360 mWifiApConfigStore = new WifiApConfigStore( 361 mContext, this, wifiHandler, mBackupManagerProxy, 362 mWifiConfigStore, mWifiConfigManager, mActiveModeWarden, mWifiMetrics); 363 WakeupNotificationFactory wakeupNotificationFactory = 364 new WakeupNotificationFactory(mContext, this, mFrameworkFacade); 365 WakeupOnboarding wakeupOnboarding = new WakeupOnboarding(mContext, mWifiConfigManager, 366 wifiHandler, mFrameworkFacade, wakeupNotificationFactory); 367 mWakeupController = new WakeupController(mContext, wifiHandler, 368 new WakeupLock(mWifiConfigManager, mWifiMetrics.getWakeupMetrics(), mClock), 369 new WakeupEvaluator(mScoringParams), wakeupOnboarding, mWifiConfigManager, 370 mWifiConfigStore, mWifiNetworkSuggestionsManager, mWifiMetrics.getWakeupMetrics(), 371 this, mFrameworkFacade, mClock); 372 mLockManager = new WifiLockManager(mContext, mBatteryStats, 373 mClientModeImpl, mFrameworkFacade, wifiHandler, mWifiNative, mClock, mWifiMetrics); 374 mSelfRecovery = new SelfRecovery(mContext, mActiveModeWarden, mClock); 375 mWifiMulticastLockManager = new WifiMulticastLockManager( 376 mClientModeImpl.getMcastLockManagerFilterController(), mBatteryStats); 377 mDppManager = new DppManager(wifiHandler, mWifiNative, 378 mWifiConfigManager, mContext, mDppMetrics, mScanRequestProxy); 379 380 // Register the various network Nominators with the network selector. 381 mWifiNetworkSelector.registerNetworkNominator(mSavedNetworkNominator); 382 mWifiNetworkSelector.registerNetworkNominator(mNetworkSuggestionNominator); 383 mWifiNetworkSelector.registerNetworkNominator(mScoredNetworkNominator); 384 385 mClientModeImpl.start(); 386 } 387 388 /** 389 * Obtain an instance of the WifiInjector class. 390 * 391 * This is the generic method to get an instance of the class. The first instance should be 392 * retrieved using the getInstanceWithContext method. 393 */ getInstance()394 public static WifiInjector getInstance() { 395 if (sWifiInjector == null) { 396 throw new IllegalStateException( 397 "Attempted to retrieve a WifiInjector instance before constructor was called."); 398 } 399 return sWifiInjector; 400 } 401 402 /** 403 * Enable verbose logging in Injector objects. Called from the WifiServiceImpl (based on 404 * binder call). 405 */ enableVerboseLogging(int verbose)406 public void enableVerboseLogging(int verbose) { 407 mWifiLastResortWatchdog.enableVerboseLogging(verbose); 408 mWifiBackupRestore.enableVerboseLogging(verbose); 409 mHalDeviceManager.enableVerboseLogging(verbose); 410 mScanRequestProxy.enableVerboseLogging(verbose); 411 mWakeupController.enableVerboseLogging(verbose); 412 mWifiNetworkSuggestionsManager.enableVerboseLogging(verbose); 413 LogcatLog.enableVerboseLogging(verbose); 414 mDppManager.enableVerboseLogging(verbose); 415 mWifiCarrierInfoManager.enableVerboseLogging(verbose); 416 } 417 getUserManager()418 public UserManager getUserManager() { 419 return mUserManager; 420 } 421 getWifiMetrics()422 public WifiMetrics getWifiMetrics() { 423 return mWifiMetrics; 424 } 425 getWifiP2pMetrics()426 public WifiP2pMetrics getWifiP2pMetrics() { 427 return mWifiP2pMetrics; 428 } 429 getSupplicantStaIfaceHal()430 public SupplicantStaIfaceHal getSupplicantStaIfaceHal() { 431 return mSupplicantStaIfaceHal; 432 } 433 getBackupManagerProxy()434 public BackupManagerProxy getBackupManagerProxy() { 435 return mBackupManagerProxy; 436 } 437 getFrameworkFacade()438 public FrameworkFacade getFrameworkFacade() { 439 return mFrameworkFacade; 440 } 441 getAsyncChannelHandlerThread()442 public HandlerThread getAsyncChannelHandlerThread() { 443 return mAsyncChannelHandlerThread; 444 } 445 getWifiP2pServiceHandlerThread()446 public HandlerThread getWifiP2pServiceHandlerThread() { 447 return mWifiP2pServiceHandlerThread; 448 } 449 getPasspointProvisionerHandlerThread()450 public HandlerThread getPasspointProvisionerHandlerThread() { 451 return mPasspointProvisionerHandlerThread; 452 } 453 getWifiHandlerThread()454 public HandlerThread getWifiHandlerThread() { 455 return mWifiHandlerThread; 456 } 457 getWifiTrafficPoller()458 public WifiTrafficPoller getWifiTrafficPoller() { 459 return mWifiTrafficPoller; 460 } 461 getWifiCountryCode()462 public WifiCountryCode getWifiCountryCode() { 463 return mCountryCode; 464 } 465 getWifiApConfigStore()466 public WifiApConfigStore getWifiApConfigStore() { 467 return mWifiApConfigStore; 468 } 469 getSarManager()470 public SarManager getSarManager() { 471 return mSarManager; 472 } 473 getClientModeImpl()474 public ClientModeImpl getClientModeImpl() { 475 return mClientModeImpl; 476 } 477 getActiveModeWarden()478 public ActiveModeWarden getActiveModeWarden() { 479 return mActiveModeWarden; 480 } 481 getWifiSettingsStore()482 public WifiSettingsStore getWifiSettingsStore() { 483 return mSettingsStore; 484 } 485 getWifiLockManager()486 public WifiLockManager getWifiLockManager() { 487 return mLockManager; 488 } 489 getWifiLastResortWatchdog()490 public WifiLastResortWatchdog getWifiLastResortWatchdog() { 491 return mWifiLastResortWatchdog; 492 } 493 getClock()494 public Clock getClock() { 495 return mClock; 496 } 497 getPropertyService()498 public PropertyService getPropertyService() { 499 return mPropertyService; 500 } 501 getBuildProperties()502 public BuildProperties getBuildProperties() { 503 return mBuildProperties; 504 } 505 getWifiBackupRestore()506 public WifiBackupRestore getWifiBackupRestore() { 507 return mWifiBackupRestore; 508 } 509 getSoftApBackupRestore()510 public SoftApBackupRestore getSoftApBackupRestore() { 511 return mSoftApBackupRestore; 512 } 513 getWifiMulticastLockManager()514 public WifiMulticastLockManager getWifiMulticastLockManager() { 515 return mWifiMulticastLockManager; 516 } 517 getWifiConfigManager()518 public WifiConfigManager getWifiConfigManager() { 519 return mWifiConfigManager; 520 } 521 getPasspointManager()522 public PasspointManager getPasspointManager() { 523 return mPasspointManager; 524 } 525 getWakeupController()526 public WakeupController getWakeupController() { 527 return mWakeupController; 528 } 529 getScoringParams()530 public ScoringParams getScoringParams() { 531 return mScoringParams; 532 } 533 getWifiScoreCard()534 public WifiScoreCard getWifiScoreCard() { 535 return mWifiScoreCard; 536 } 537 makeTelephonyManager()538 public TelephonyManager makeTelephonyManager() { 539 return (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 540 } 541 getWifiCarrierInfoManager()542 public WifiCarrierInfoManager getWifiCarrierInfoManager() { 543 return mWifiCarrierInfoManager; 544 } 545 getWifiStateTracker()546 public WifiStateTracker getWifiStateTracker() { 547 return mWifiStateTracker; 548 } 549 getDppManager()550 public DppManager getDppManager() { 551 return mDppManager; 552 } 553 554 /** 555 * Create a SoftApManager. 556 * @param config SoftApModeConfiguration object holding the config and mode 557 * @return an instance of SoftApManager 558 */ makeSoftApManager(@onNull ActiveModeManager.Listener listener, @NonNull WifiManager.SoftApCallback callback, @NonNull SoftApModeConfiguration config)559 public SoftApManager makeSoftApManager(@NonNull ActiveModeManager.Listener listener, 560 @NonNull WifiManager.SoftApCallback callback, 561 @NonNull SoftApModeConfiguration config) { 562 return new SoftApManager(mContext, mWifiHandlerThread.getLooper(), 563 mFrameworkFacade, mWifiNative, mCountryCode.getCountryCode(), listener, callback, 564 mWifiApConfigStore, config, mWifiMetrics, mSarManager, mWifiDiagnostics); 565 } 566 567 /** 568 * Create a ClientModeManager 569 * 570 * @param listener listener for ClientModeManager state changes 571 * @return a new instance of ClientModeManager 572 */ makeClientModeManager(ClientModeManager.Listener listener)573 public ClientModeManager makeClientModeManager(ClientModeManager.Listener listener) { 574 return new ClientModeManager(mContext, mWifiHandlerThread.getLooper(), mClock, 575 mWifiNative, listener, mWifiMetrics, mSarManager, mWakeupController, 576 mClientModeImpl); 577 } 578 579 /** 580 * Create a WifiLog instance. 581 * @param tag module name to include in all log messages 582 */ makeLog(String tag)583 public WifiLog makeLog(String tag) { 584 return new LogcatLog(tag); 585 } 586 getWifiDiagnostics()587 public BaseWifiDiagnostics getWifiDiagnostics() { 588 return mWifiDiagnostics; 589 } 590 591 /** 592 * Obtain an instance of WifiScanner. 593 * If it was not already created, then obtain an instance. Note, this must be done lazily since 594 * WifiScannerService is separate and created later. 595 */ getWifiScanner()596 public synchronized WifiScanner getWifiScanner() { 597 if (mWifiScanner == null) { 598 mWifiScanner = mContext.getSystemService(WifiScanner.class); 599 } 600 return mWifiScanner; 601 } 602 603 /** 604 * Construct a new instance of WifiConnectivityManager & its dependencies. 605 * 606 * Create and return a new WifiConnectivityManager. 607 * @param clientModeImpl Instance of client mode impl. 608 * TODO(b/116233964): Remove cyclic dependency between WifiConnectivityManager & ClientModeImpl. 609 */ makeWifiConnectivityManager(ClientModeImpl clientModeImpl)610 public WifiConnectivityManager makeWifiConnectivityManager(ClientModeImpl clientModeImpl) { 611 mOpenNetworkNotifier = new OpenNetworkNotifier(mContext, 612 mWifiHandlerThread.getLooper(), mFrameworkFacade, mClock, mWifiMetrics, 613 mWifiConfigManager, mWifiConfigStore, clientModeImpl, 614 new ConnectToNetworkNotificationBuilder(mContext, this, mFrameworkFacade)); 615 mWifiLastResortWatchdog = new WifiLastResortWatchdog(this, mContext, mClock, 616 mWifiMetrics, clientModeImpl, mWifiHandlerThread.getLooper(), mDeviceConfigFacade, 617 mWifiThreadRunner); 618 mBssidBlocklistMonitor = new BssidBlocklistMonitor(mContext, mWifiConnectivityHelper, 619 mWifiLastResortWatchdog, mClock, mConnectivityLocalLog, mWifiScoreCard, 620 mScoringParams); 621 mWifiMetrics.setBssidBlocklistMonitor(mBssidBlocklistMonitor); 622 mWifiChannelUtilizationScan = new WifiChannelUtilization(mClock, mContext); 623 return new WifiConnectivityManager(mContext, getScoringParams(), 624 clientModeImpl, this, 625 mWifiConfigManager, mWifiNetworkSuggestionsManager, clientModeImpl.getWifiInfo(), 626 mWifiNetworkSelector, mWifiConnectivityHelper, 627 mWifiLastResortWatchdog, mOpenNetworkNotifier, 628 mWifiMetrics, new Handler(mWifiHandlerThread.getLooper()), 629 mClock, mConnectivityLocalLog, mWifiScoreCard); 630 } 631 632 /** 633 * Construct a new instance of ConnectionFailureNotifier. 634 * @param wifiConnectivityManager 635 * @return the created instance 636 */ makeConnectionFailureNotifier( WifiConnectivityManager wifiConnectivityManager)637 public ConnectionFailureNotifier makeConnectionFailureNotifier( 638 WifiConnectivityManager wifiConnectivityManager) { 639 return new ConnectionFailureNotifier(mContext, this, mFrameworkFacade, mWifiConfigManager, 640 wifiConnectivityManager, new Handler(mWifiHandlerThread.getLooper())); 641 } 642 643 /** 644 * Construct a new instance of {@link WifiNetworkFactory}. 645 * TODO(b/116233964): Remove cyclic dependency between WifiConnectivityManager & ClientModeImpl. 646 */ makeWifiNetworkFactory( NetworkCapabilities nc, WifiConnectivityManager wifiConnectivityManager)647 public WifiNetworkFactory makeWifiNetworkFactory( 648 NetworkCapabilities nc, WifiConnectivityManager wifiConnectivityManager) { 649 return new WifiNetworkFactory( 650 mWifiHandlerThread.getLooper(), mContext, nc, 651 (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE), 652 (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE), 653 (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE), 654 mClock, this, wifiConnectivityManager, mWifiConfigManager, 655 mWifiConfigStore, mWifiPermissionsUtil, mWifiMetrics); 656 } 657 658 /** 659 * Construct an instance of {@link NetworkRequestStoreData}. 660 */ makeNetworkRequestStoreData( NetworkRequestStoreData.DataSource dataSource)661 public NetworkRequestStoreData makeNetworkRequestStoreData( 662 NetworkRequestStoreData.DataSource dataSource) { 663 return new NetworkRequestStoreData(dataSource); 664 } 665 666 /** 667 * Construct a new instance of {@link UntrustedWifiNetworkFactory}. 668 * TODO(b/116233964): Remove cyclic dependency between WifiConnectivityManager & ClientModeImpl. 669 */ makeUntrustedWifiNetworkFactory( NetworkCapabilities nc, WifiConnectivityManager wifiConnectivityManager)670 public UntrustedWifiNetworkFactory makeUntrustedWifiNetworkFactory( 671 NetworkCapabilities nc, WifiConnectivityManager wifiConnectivityManager) { 672 return new UntrustedWifiNetworkFactory( 673 mWifiHandlerThread.getLooper(), mContext, nc, wifiConnectivityManager); 674 } 675 676 /** 677 * Construct an instance of {@link NetworkSuggestionStoreData}. 678 */ makeNetworkSuggestionStoreData( NetworkSuggestionStoreData.DataSource dataSource)679 public NetworkSuggestionStoreData makeNetworkSuggestionStoreData( 680 NetworkSuggestionStoreData.DataSource dataSource) { 681 return new NetworkSuggestionStoreData(dataSource); 682 } 683 684 /** 685 * 686 */ makeImsiProtectionExemptionStoreData( ImsiPrivacyProtectionExemptionStoreData.DataSource dataSource)687 public ImsiPrivacyProtectionExemptionStoreData makeImsiProtectionExemptionStoreData( 688 ImsiPrivacyProtectionExemptionStoreData.DataSource dataSource) { 689 return new ImsiPrivacyProtectionExemptionStoreData(dataSource); 690 } 691 692 /** 693 * Construct an instance of {@link SoftApStoreData}. 694 */ makeSoftApStoreData( SoftApStoreData.DataSource dataSource)695 public SoftApStoreData makeSoftApStoreData( 696 SoftApStoreData.DataSource dataSource) { 697 return new SoftApStoreData(mContext, mSettingsMigrationDataHolder, dataSource); 698 } 699 getWifiPermissionsUtil()700 public WifiPermissionsUtil getWifiPermissionsUtil() { 701 return mWifiPermissionsUtil; 702 } 703 getWifiPermissionsWrapper()704 public WifiPermissionsWrapper getWifiPermissionsWrapper() { 705 return mWifiPermissionsWrapper; 706 } 707 708 /** 709 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 710 * 711 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 712 */ getWifiAwareHandlerThread()713 public HandlerThread getWifiAwareHandlerThread() { 714 if (mWifiAwareHandlerThread == null) { // lazy initialization 715 mWifiAwareHandlerThread = new HandlerThread("wifiAwareService"); 716 mWifiAwareHandlerThread.start(); 717 } 718 return mWifiAwareHandlerThread; 719 } 720 721 /** 722 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 723 * 724 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 725 */ getRttHandlerThread()726 public HandlerThread getRttHandlerThread() { 727 if (mRttHandlerThread == null) { // lazy initialization 728 mRttHandlerThread = new HandlerThread("wifiRttService"); 729 mRttHandlerThread.start(); 730 } 731 return mRttHandlerThread; 732 } 733 getMacAddressUtil()734 public MacAddressUtil getMacAddressUtil() { 735 return mMacAddressUtil; 736 } 737 getNotificationManager()738 public NotificationManager getNotificationManager() { 739 return (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); 740 } 741 getConnectionFailureNotificationBuilder()742 public ConnectionFailureNotificationBuilder getConnectionFailureNotificationBuilder() { 743 return mConnectionFailureNotificationBuilder; 744 } 745 746 /** 747 * Returns a single instance of HalDeviceManager for injection. 748 */ getHalDeviceManager()749 public HalDeviceManager getHalDeviceManager() { 750 return mHalDeviceManager; 751 } 752 getWifiNative()753 public WifiNative getWifiNative() { 754 return mWifiNative; 755 } 756 getWifiMonitor()757 public WifiMonitor getWifiMonitor() { 758 return mWifiMonitor; 759 } 760 getWifiP2pNative()761 public WifiP2pNative getWifiP2pNative() { 762 return mWifiP2pNative; 763 } 764 getWifiP2pMonitor()765 public WifiP2pMonitor getWifiP2pMonitor() { 766 return mWifiP2pMonitor; 767 } 768 getSelfRecovery()769 public SelfRecovery getSelfRecovery() { 770 return mSelfRecovery; 771 } 772 getScanRequestProxy()773 public ScanRequestProxy getScanRequestProxy() { 774 return mScanRequestProxy; 775 } 776 getJavaRuntime()777 public Runtime getJavaRuntime() { 778 return Runtime.getRuntime(); 779 } 780 getWifiDataStall()781 public WifiDataStall getWifiDataStall() { 782 return mWifiDataStall; 783 } 784 getWifiNetworkSuggestionsManager()785 public WifiNetworkSuggestionsManager getWifiNetworkSuggestionsManager() { 786 return mWifiNetworkSuggestionsManager; 787 } 788 getIpMemoryStore()789 public IpMemoryStore getIpMemoryStore() { 790 if (mIpMemoryStore == null) { 791 mIpMemoryStore = IpMemoryStore.getMemoryStore(mContext); 792 } 793 return mIpMemoryStore; 794 } 795 getBssidBlocklistMonitor()796 public BssidBlocklistMonitor getBssidBlocklistMonitor() { 797 return mBssidBlocklistMonitor; 798 } 799 getHostapdHal()800 public HostapdHal getHostapdHal() { 801 return mHostapdHal; 802 } 803 getWifiStackPackageName()804 public String getWifiStackPackageName() { 805 return mContext.getPackageName(); 806 } 807 getWifiThreadRunner()808 public WifiThreadRunner getWifiThreadRunner() { 809 return mWifiThreadRunner; 810 } 811 getWifiChannelUtilizationScan()812 public WifiChannelUtilization getWifiChannelUtilizationScan() { 813 return mWifiChannelUtilizationScan; 814 } 815 getWifiNetworkScoreCache()816 public WifiNetworkScoreCache getWifiNetworkScoreCache() { 817 return mWifiNetworkScoreCache; 818 } 819 makeNetdWrapper()820 public NetdWrapper makeNetdWrapper() { 821 if (mNetdWrapper == null) { 822 mNetdWrapper = new NetdWrapper(mContext, new Handler(mWifiHandlerThread.getLooper())); 823 } 824 return mNetdWrapper; 825 } 826 getWifiCondManager()827 public WifiNl80211Manager getWifiCondManager() { 828 return mWifiCondManager; 829 } 830 getWifiHealthMonitor()831 public WifiHealthMonitor getWifiHealthMonitor() { 832 return mWifiHealthMonitor; 833 } 834 getThroughputPredictor()835 public ThroughputPredictor getThroughputPredictor() { 836 return mThroughputPredictor; 837 } 838 getSettingsConfigStore()839 public WifiSettingsConfigStore getSettingsConfigStore() { 840 return mSettingsConfigStore; 841 } 842 843 public WifiScanAlwaysAvailableSettingsCompatibility getWifiScanAlwaysAvailableSettingsCompatibility()844 getWifiScanAlwaysAvailableSettingsCompatibility() { 845 return mWifiScanAlwaysAvailableSettingsCompatibility; 846 } 847 getDeviceConfigFacade()848 public DeviceConfigFacade getDeviceConfigFacade() { 849 return mDeviceConfigFacade; 850 } 851 } 852