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.AppOpsManager; 22 import android.content.Context; 23 import android.net.NetworkKey; 24 import android.net.NetworkScoreManager; 25 import android.net.wifi.IWifiScanner; 26 import android.net.wifi.IWificond; 27 import android.net.wifi.WifiInfo; 28 import android.net.wifi.WifiManager; 29 import android.net.wifi.WifiNetworkScoreCache; 30 import android.net.wifi.WifiScanner; 31 import android.os.BatteryStats; 32 import android.os.Handler; 33 import android.os.HandlerThread; 34 import android.os.IBinder; 35 import android.os.INetworkManagementService; 36 import android.os.Looper; 37 import android.os.ServiceManager; 38 import android.os.SystemProperties; 39 import android.os.UserManager; 40 import android.security.KeyStore; 41 import android.telephony.TelephonyManager; 42 import android.util.LocalLog; 43 44 import com.android.internal.R; 45 import com.android.internal.app.IBatteryStats; 46 import com.android.internal.os.PowerProfile; 47 import com.android.server.am.ActivityManagerService; 48 import com.android.server.am.BatteryStatsService; 49 import com.android.server.net.DelayedDiskWrite; 50 import com.android.server.net.IpConfigStore; 51 import com.android.server.wifi.aware.WifiAwareMetrics; 52 import com.android.server.wifi.hotspot2.LegacyPasspointConfigParser; 53 import com.android.server.wifi.hotspot2.PasspointManager; 54 import com.android.server.wifi.hotspot2.PasspointNetworkEvaluator; 55 import com.android.server.wifi.hotspot2.PasspointObjectFactory; 56 import com.android.server.wifi.p2p.SupplicantP2pIfaceHal; 57 import com.android.server.wifi.p2p.WifiP2pMonitor; 58 import com.android.server.wifi.p2p.WifiP2pNative; 59 import com.android.server.wifi.rtt.RttMetrics; 60 import com.android.server.wifi.util.WifiPermissionsUtil; 61 import com.android.server.wifi.util.WifiPermissionsWrapper; 62 63 /** 64 * WiFi dependency injector. To be used for accessing various WiFi class instances and as a 65 * handle for mock injection. 66 * 67 * Some WiFi class instances currently depend on having a Looper from a HandlerThread that has 68 * been started. To accommodate this, we have a two-phased approach to initialize and retrieve 69 * an instance of the WifiInjector. 70 */ 71 public class WifiInjector { 72 private static final String BOOT_DEFAULT_WIFI_COUNTRY_CODE = "ro.boot.wificountrycode"; 73 private static final String WIFICOND_SERVICE_NAME = "wificond"; 74 75 static WifiInjector sWifiInjector = null; 76 77 private final Context mContext; 78 private final FrameworkFacade mFrameworkFacade = new FrameworkFacade(); 79 private final HandlerThread mWifiServiceHandlerThread; 80 private final HandlerThread mWifiStateMachineHandlerThread; 81 private final WifiTrafficPoller mTrafficPoller; 82 private final WifiCountryCode mCountryCode; 83 private final BackupManagerProxy mBackupManagerProxy = new BackupManagerProxy(); 84 private final WifiApConfigStore mWifiApConfigStore; 85 private final WifiNative mWifiNative; 86 private final WifiMonitor mWifiMonitor; 87 private final WifiP2pNative mWifiP2pNative; 88 private final WifiP2pMonitor mWifiP2pMonitor; 89 private final SupplicantStaIfaceHal mSupplicantStaIfaceHal; 90 private final SupplicantP2pIfaceHal mSupplicantP2pIfaceHal; 91 private final HostapdHal mHostapdHal; 92 private final WifiVendorHal mWifiVendorHal; 93 private final ScoringParams mScoringParams; 94 private final WifiStateMachine mWifiStateMachine; 95 private final WifiStateMachinePrime mWifiStateMachinePrime; 96 private final WifiSettingsStore mSettingsStore; 97 private final OpenNetworkNotifier mOpenNetworkNotifier; 98 private final CarrierNetworkNotifier mCarrierNetworkNotifier; 99 private final CarrierNetworkConfig mCarrierNetworkConfig; 100 private final WifiLockManager mLockManager; 101 private final WifiController mWifiController; 102 private final WificondControl mWificondControl; 103 private final Clock mClock = new Clock(); 104 private final WifiMetrics mWifiMetrics; 105 private final WifiLastResortWatchdog mWifiLastResortWatchdog; 106 private final PropertyService mPropertyService = new SystemPropertyService(); 107 private final BuildProperties mBuildProperties = new SystemBuildProperties(); 108 private final KeyStore mKeyStore = KeyStore.getInstance(); 109 private final WifiBackupRestore mWifiBackupRestore; 110 private final WifiMulticastLockManager mWifiMulticastLockManager; 111 private final WifiConfigStore mWifiConfigStore; 112 private final WifiKeyStore mWifiKeyStore; 113 private final WifiNetworkHistory mWifiNetworkHistory; 114 private final IpConfigStore mIpConfigStore; 115 private final WifiConfigStoreLegacy mWifiConfigStoreLegacy; 116 private final WifiConfigManager mWifiConfigManager; 117 private final WifiConnectivityHelper mWifiConnectivityHelper; 118 private final LocalLog mConnectivityLocalLog; 119 private final WifiNetworkSelector mWifiNetworkSelector; 120 private final SavedNetworkEvaluator mSavedNetworkEvaluator; 121 private final PasspointNetworkEvaluator mPasspointNetworkEvaluator; 122 private final ScoredNetworkEvaluator mScoredNetworkEvaluator; 123 private final WifiNetworkScoreCache mWifiNetworkScoreCache; 124 private final NetworkScoreManager mNetworkScoreManager; 125 private WifiScanner mWifiScanner; 126 private final WifiPermissionsWrapper mWifiPermissionsWrapper; 127 private final WifiPermissionsUtil mWifiPermissionsUtil; 128 private final PasspointManager mPasspointManager; 129 private final SIMAccessor mSimAccessor; 130 private HandlerThread mWifiAwareHandlerThread; 131 private HandlerThread mRttHandlerThread; 132 private HalDeviceManager mHalDeviceManager; 133 private final IBatteryStats mBatteryStats; 134 private final WifiStateTracker mWifiStateTracker; 135 private final SelfRecovery mSelfRecovery; 136 private final WakeupController mWakeupController; 137 private final INetworkManagementService mNwManagementService; 138 private final ScanRequestProxy mScanRequestProxy; 139 private final SarManager mSarManager; 140 private final BaseWifiDiagnostics mWifiDiagnostics; 141 142 private final boolean mUseRealLogger; 143 144 public WifiInjector(Context context) { 145 if (context == null) { 146 throw new IllegalStateException( 147 "WifiInjector should not be initialized with a null Context."); 148 } 149 150 if (sWifiInjector != null) { 151 throw new IllegalStateException( 152 "WifiInjector was already created, use getInstance instead."); 153 } 154 155 sWifiInjector = this; 156 157 mContext = context; 158 mUseRealLogger = mContext.getResources().getBoolean( 159 R.bool.config_wifi_enable_wifi_firmware_debugging); 160 mSettingsStore = new WifiSettingsStore(mContext); 161 mWifiPermissionsWrapper = new WifiPermissionsWrapper(mContext); 162 mNetworkScoreManager = mContext.getSystemService(NetworkScoreManager.class); 163 mWifiNetworkScoreCache = new WifiNetworkScoreCache(mContext); 164 mNetworkScoreManager.registerNetworkScoreCache(NetworkKey.TYPE_WIFI, 165 mWifiNetworkScoreCache, NetworkScoreManager.CACHE_FILTER_NONE); 166 mWifiPermissionsUtil = new WifiPermissionsUtil(mWifiPermissionsWrapper, mContext, 167 mSettingsStore, UserManager.get(mContext), this); 168 mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil); 169 mBatteryStats = IBatteryStats.Stub.asInterface(mFrameworkFacade.getService( 170 BatteryStats.SERVICE_NAME)); 171 mWifiStateTracker = new WifiStateTracker(mBatteryStats); 172 // Now create and start handler threads 173 mWifiServiceHandlerThread = new HandlerThread("WifiService"); 174 mWifiServiceHandlerThread.start(); 175 mWifiStateMachineHandlerThread = new HandlerThread("WifiStateMachine"); 176 mWifiStateMachineHandlerThread.start(); 177 Looper wifiStateMachineLooper = mWifiStateMachineHandlerThread.getLooper(); 178 mCarrierNetworkConfig = new CarrierNetworkConfig(mContext, 179 mWifiServiceHandlerThread.getLooper(), mFrameworkFacade); 180 WifiAwareMetrics awareMetrics = new WifiAwareMetrics(mClock); 181 RttMetrics rttMetrics = new RttMetrics(mClock); 182 mWifiMetrics = new WifiMetrics(mClock, wifiStateMachineLooper, awareMetrics, rttMetrics); 183 // Modules interacting with Native. 184 mWifiMonitor = new WifiMonitor(this); 185 mHalDeviceManager = new HalDeviceManager(mClock); 186 mWifiVendorHal = 187 new WifiVendorHal(mHalDeviceManager, mWifiStateMachineHandlerThread.getLooper()); 188 mSupplicantStaIfaceHal = new SupplicantStaIfaceHal(mContext, mWifiMonitor); 189 mHostapdHal = new HostapdHal(mContext); 190 mWificondControl = new WificondControl(this, mWifiMonitor, mCarrierNetworkConfig); 191 mNwManagementService = INetworkManagementService.Stub.asInterface( 192 ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE)); 193 mWifiNative = new WifiNative( 194 mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWificondControl, 195 mWifiMonitor, mNwManagementService, mPropertyService, mWifiMetrics); 196 mWifiP2pMonitor = new WifiP2pMonitor(this); 197 mSupplicantP2pIfaceHal = new SupplicantP2pIfaceHal(mWifiP2pMonitor); 198 mWifiP2pNative = new WifiP2pNative(mSupplicantP2pIfaceHal, mHalDeviceManager); 199 200 // Now get instances of all the objects that depend on the HandlerThreads 201 mTrafficPoller = new WifiTrafficPoller(mContext, mWifiServiceHandlerThread.getLooper(), 202 mWifiNative); 203 mCountryCode = new WifiCountryCode(mWifiNative, 204 SystemProperties.get(BOOT_DEFAULT_WIFI_COUNTRY_CODE), 205 mContext.getResources() 206 .getBoolean(R.bool.config_wifi_revert_country_code_on_cellular_loss)); 207 mWifiApConfigStore = new WifiApConfigStore(mContext, mBackupManagerProxy); 208 209 // WifiConfigManager/Store objects and their dependencies. 210 // New config store 211 mWifiKeyStore = new WifiKeyStore(mKeyStore); 212 mWifiConfigStore = new WifiConfigStore( 213 mContext, wifiStateMachineLooper, mClock, 214 WifiConfigStore.createSharedFile()); 215 // Legacy config store 216 DelayedDiskWrite writer = new DelayedDiskWrite(); 217 mWifiNetworkHistory = new WifiNetworkHistory(mContext, writer); 218 mIpConfigStore = new IpConfigStore(writer); 219 mWifiConfigStoreLegacy = new WifiConfigStoreLegacy( 220 mWifiNetworkHistory, mWifiNative, new WifiConfigStoreLegacy.IpConfigStoreWrapper(), 221 new LegacyPasspointConfigParser()); 222 // Config Manager 223 mWifiConfigManager = new WifiConfigManager(mContext, mClock, 224 UserManager.get(mContext), TelephonyManager.from(mContext), 225 mWifiKeyStore, mWifiConfigStore, mWifiConfigStoreLegacy, mWifiPermissionsUtil, 226 mWifiPermissionsWrapper, new NetworkListStoreData(mContext), 227 new DeletedEphemeralSsidsStoreData()); 228 mWifiMetrics.setWifiConfigManager(mWifiConfigManager); 229 mWifiConnectivityHelper = new WifiConnectivityHelper(mWifiNative); 230 mConnectivityLocalLog = new LocalLog(ActivityManager.isLowRamDeviceStatic() ? 256 : 512); 231 mScoringParams = new ScoringParams(mContext, mFrameworkFacade, 232 new Handler(wifiStateMachineLooper)); 233 mWifiMetrics.setScoringParams(mScoringParams); 234 mWifiNetworkSelector = new WifiNetworkSelector(mContext, mScoringParams, 235 mWifiConfigManager, mClock, 236 mConnectivityLocalLog); 237 mWifiMetrics.setWifiNetworkSelector(mWifiNetworkSelector); 238 mSavedNetworkEvaluator = new SavedNetworkEvaluator(mContext, mScoringParams, 239 mWifiConfigManager, mClock, mConnectivityLocalLog, mWifiConnectivityHelper); 240 mScoredNetworkEvaluator = new ScoredNetworkEvaluator(context, wifiStateMachineLooper, 241 mFrameworkFacade, mNetworkScoreManager, mWifiConfigManager, mConnectivityLocalLog, 242 mWifiNetworkScoreCache, mWifiPermissionsUtil); 243 mSimAccessor = new SIMAccessor(mContext); 244 mPasspointManager = new PasspointManager(mContext, mWifiNative, mWifiKeyStore, mClock, 245 mSimAccessor, new PasspointObjectFactory(), mWifiConfigManager, mWifiConfigStore, 246 mWifiMetrics); 247 mPasspointNetworkEvaluator = new PasspointNetworkEvaluator( 248 mPasspointManager, mWifiConfigManager, mConnectivityLocalLog); 249 mWifiMetrics.setPasspointManager(mPasspointManager); 250 mScanRequestProxy = new ScanRequestProxy(mContext, 251 (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE), 252 (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE), 253 this, mWifiConfigManager, 254 mWifiPermissionsUtil, mWifiMetrics, mClock); 255 mSarManager = new SarManager(mContext, makeTelephonyManager(), wifiStateMachineLooper, 256 mWifiNative); 257 if (mUseRealLogger) { 258 mWifiDiagnostics = new WifiDiagnostics( 259 mContext, this, mWifiNative, mBuildProperties, 260 new LastMileLogger(this)); 261 } else { 262 mWifiDiagnostics = new BaseWifiDiagnostics(mWifiNative); 263 } 264 mWifiStateMachine = new WifiStateMachine(mContext, mFrameworkFacade, 265 wifiStateMachineLooper, UserManager.get(mContext), 266 this, mBackupManagerProxy, mCountryCode, mWifiNative, 267 new WrongPasswordNotifier(mContext, mFrameworkFacade), 268 mSarManager); 269 mWifiStateMachinePrime = new WifiStateMachinePrime(this, mContext, wifiStateMachineLooper, 270 mWifiNative, new DefaultModeManager(mContext, wifiStateMachineLooper), 271 mBatteryStats); 272 mOpenNetworkNotifier = new OpenNetworkNotifier(mContext, 273 mWifiStateMachineHandlerThread.getLooper(), mFrameworkFacade, mClock, mWifiMetrics, 274 mWifiConfigManager, mWifiConfigStore, mWifiStateMachine, 275 new ConnectToNetworkNotificationBuilder(mContext, mFrameworkFacade)); 276 mCarrierNetworkNotifier = new CarrierNetworkNotifier(mContext, 277 mWifiStateMachineHandlerThread.getLooper(), mFrameworkFacade, mClock, mWifiMetrics, 278 mWifiConfigManager, mWifiConfigStore, mWifiStateMachine, 279 new ConnectToNetworkNotificationBuilder(mContext, mFrameworkFacade)); 280 281 WakeupNotificationFactory wakeupNotificationFactory = 282 new WakeupNotificationFactory(mContext, mFrameworkFacade); 283 WakeupOnboarding wakeupOnboarding = new WakeupOnboarding(mContext, mWifiConfigManager, 284 mWifiStateMachineHandlerThread.getLooper(), mFrameworkFacade, 285 wakeupNotificationFactory); 286 mWakeupController = new WakeupController(mContext, 287 mWifiStateMachineHandlerThread.getLooper(), 288 new WakeupLock(mWifiConfigManager, mWifiMetrics.getWakeupMetrics(), mClock), 289 WakeupEvaluator.fromContext(mContext), wakeupOnboarding, mWifiConfigManager, 290 mWifiConfigStore, mWifiMetrics.getWakeupMetrics(), this, mFrameworkFacade); 291 mLockManager = new WifiLockManager(mContext, BatteryStatsService.getService()); 292 mWifiController = new WifiController(mContext, mWifiStateMachine, wifiStateMachineLooper, 293 mSettingsStore, mWifiServiceHandlerThread.getLooper(), mFrameworkFacade, 294 mWifiStateMachinePrime); 295 mSelfRecovery = new SelfRecovery(mWifiController, mClock); 296 mWifiLastResortWatchdog = new WifiLastResortWatchdog(mSelfRecovery, mClock, 297 mWifiMetrics, mWifiStateMachine, wifiStateMachineLooper); 298 mWifiMulticastLockManager = new WifiMulticastLockManager( 299 mWifiStateMachine.getMcastLockManagerFilterController(), 300 BatteryStatsService.getService()); 301 } 302 303 /** 304 * Obtain an instance of the WifiInjector class. 305 * 306 * This is the generic method to get an instance of the class. The first instance should be 307 * retrieved using the getInstanceWithContext method. 308 */ 309 public static WifiInjector getInstance() { 310 if (sWifiInjector == null) { 311 throw new IllegalStateException( 312 "Attempted to retrieve a WifiInjector instance before constructor was called."); 313 } 314 return sWifiInjector; 315 } 316 317 /** 318 * Enable verbose logging in Injector objects. Called from the WifiServiceImpl (based on 319 * binder call). 320 */ 321 public void enableVerboseLogging(int verbose) { 322 mWifiLastResortWatchdog.enableVerboseLogging(verbose); 323 mWifiBackupRestore.enableVerboseLogging(verbose); 324 mHalDeviceManager.enableVerboseLogging(verbose); 325 mScanRequestProxy.enableVerboseLogging(verbose); 326 mWakeupController.enableVerboseLogging(verbose); 327 LogcatLog.enableVerboseLogging(verbose); 328 } 329 330 public UserManager getUserManager() { 331 return UserManager.get(mContext); 332 } 333 334 public WifiMetrics getWifiMetrics() { 335 return mWifiMetrics; 336 } 337 338 public SupplicantStaIfaceHal getSupplicantStaIfaceHal() { 339 return mSupplicantStaIfaceHal; 340 } 341 342 public BackupManagerProxy getBackupManagerProxy() { 343 return mBackupManagerProxy; 344 } 345 346 public FrameworkFacade getFrameworkFacade() { 347 return mFrameworkFacade; 348 } 349 350 public HandlerThread getWifiServiceHandlerThread() { 351 return mWifiServiceHandlerThread; 352 } 353 354 public HandlerThread getWifiStateMachineHandlerThread() { 355 return mWifiStateMachineHandlerThread; 356 } 357 358 public WifiTrafficPoller getWifiTrafficPoller() { 359 return mTrafficPoller; 360 } 361 362 public WifiCountryCode getWifiCountryCode() { 363 return mCountryCode; 364 } 365 366 public WifiApConfigStore getWifiApConfigStore() { 367 return mWifiApConfigStore; 368 } 369 370 public SarManager getSarManager() { 371 return mSarManager; 372 } 373 374 public WifiStateMachine getWifiStateMachine() { 375 return mWifiStateMachine; 376 } 377 378 public Handler getWifiStateMachineHandler() { 379 return mWifiStateMachine.getHandler(); 380 } 381 382 public WifiStateMachinePrime getWifiStateMachinePrime() { 383 return mWifiStateMachinePrime; 384 } 385 386 public WifiSettingsStore getWifiSettingsStore() { 387 return mSettingsStore; 388 } 389 390 public WifiLockManager getWifiLockManager() { 391 return mLockManager; 392 } 393 394 public WifiController getWifiController() { 395 return mWifiController; 396 } 397 398 public WifiLastResortWatchdog getWifiLastResortWatchdog() { 399 return mWifiLastResortWatchdog; 400 } 401 402 public Clock getClock() { 403 return mClock; 404 } 405 406 public PropertyService getPropertyService() { 407 return mPropertyService; 408 } 409 410 public BuildProperties getBuildProperties() { 411 return mBuildProperties; 412 } 413 414 public KeyStore getKeyStore() { 415 return mKeyStore; 416 } 417 418 public WifiBackupRestore getWifiBackupRestore() { 419 return mWifiBackupRestore; 420 } 421 422 public WifiMulticastLockManager getWifiMulticastLockManager() { 423 return mWifiMulticastLockManager; 424 } 425 426 public WifiConfigManager getWifiConfigManager() { 427 return mWifiConfigManager; 428 } 429 430 public PasspointManager getPasspointManager() { 431 return mPasspointManager; 432 } 433 434 public WakeupController getWakeupController() { 435 return mWakeupController; 436 } 437 438 public ScoringParams getScoringParams() { 439 return mScoringParams; 440 } 441 442 public TelephonyManager makeTelephonyManager() { 443 // may not be available when WiFi starts 444 return (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); 445 } 446 447 public WifiStateTracker getWifiStateTracker() { 448 return mWifiStateTracker; 449 } 450 451 public IWificond makeWificond() { 452 // We depend on being able to refresh our binder in WifiStateMachine, so don't cache it. 453 IBinder binder = ServiceManager.getService(WIFICOND_SERVICE_NAME); 454 return IWificond.Stub.asInterface(binder); 455 } 456 457 /** 458 * Create a SoftApManager. 459 * @param listener listener for SoftApManager 460 * @param config SoftApModeConfiguration object holding the config and mode 461 * @return an instance of SoftApManager 462 */ 463 public SoftApManager makeSoftApManager(@NonNull WifiManager.SoftApCallback callback, 464 @NonNull SoftApModeConfiguration config) { 465 return new SoftApManager(mContext, mWifiStateMachineHandlerThread.getLooper(), 466 mFrameworkFacade, mWifiNative, mCountryCode.getCountryCode(), callback, 467 mWifiApConfigStore, config, mWifiMetrics); 468 } 469 470 /** 471 * Create a ScanOnlyModeManager 472 * 473 * @param listener listener for ScanOnlyModeManager state changes 474 * @return a new instance of ScanOnlyModeManager 475 */ 476 public ScanOnlyModeManager makeScanOnlyModeManager( 477 @NonNull ScanOnlyModeManager.Listener listener) { 478 return new ScanOnlyModeManager(mContext, mWifiStateMachineHandlerThread.getLooper(), 479 mWifiNative, listener, mWifiMetrics, mScanRequestProxy, mWakeupController); 480 } 481 482 /** 483 * Create a ClientModeManager 484 * 485 * @param listener listener for ClientModeManager state changes 486 * @return a new instance of ClientModeManager 487 */ 488 public ClientModeManager makeClientModeManager(ClientModeManager.Listener listener) { 489 return new ClientModeManager(mContext, mWifiStateMachineHandlerThread.getLooper(), 490 mWifiNative, listener, mWifiMetrics, mScanRequestProxy, mWifiStateMachine); 491 } 492 493 /** 494 * Create a WifiLog instance. 495 * @param tag module name to include in all log messages 496 */ 497 public WifiLog makeLog(String tag) { 498 return new LogcatLog(tag); 499 } 500 501 public BaseWifiDiagnostics getWifiDiagnostics() { 502 return mWifiDiagnostics; 503 } 504 505 /** 506 * Obtain an instance of WifiScanner. 507 * If it was not already created, then obtain an instance. Note, this must be done lazily since 508 * WifiScannerService is separate and created later. 509 */ 510 public synchronized WifiScanner getWifiScanner() { 511 if (mWifiScanner == null) { 512 mWifiScanner = new WifiScanner(mContext, 513 IWifiScanner.Stub.asInterface(ServiceManager.getService( 514 Context.WIFI_SCANNING_SERVICE)), 515 mWifiStateMachineHandlerThread.getLooper()); 516 } 517 return mWifiScanner; 518 } 519 520 /** 521 * Obtain a new instance of WifiConnectivityManager. 522 * 523 * Create and return a new WifiConnectivityManager. 524 * @param wifiInfo WifiInfo object for updating wifi state. 525 * @param hasConnectionRequests boolean indicating if WifiConnectivityManager to start 526 * immediately based on connection requests. 527 */ 528 public WifiConnectivityManager makeWifiConnectivityManager(WifiInfo wifiInfo, 529 boolean hasConnectionRequests) { 530 return new WifiConnectivityManager(mContext, getScoringParams(), 531 mWifiStateMachine, getWifiScanner(), 532 mWifiConfigManager, wifiInfo, mWifiNetworkSelector, mWifiConnectivityHelper, 533 mWifiLastResortWatchdog, mOpenNetworkNotifier, mCarrierNetworkNotifier, 534 mCarrierNetworkConfig, mWifiMetrics, mWifiStateMachineHandlerThread.getLooper(), 535 mClock, mConnectivityLocalLog, hasConnectionRequests, mFrameworkFacade, 536 mSavedNetworkEvaluator, mScoredNetworkEvaluator, mPasspointNetworkEvaluator); 537 } 538 539 public WifiPermissionsUtil getWifiPermissionsUtil() { 540 return mWifiPermissionsUtil; 541 } 542 543 public WifiPermissionsWrapper getWifiPermissionsWrapper() { 544 return mWifiPermissionsWrapper; 545 } 546 547 /** 548 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 549 * 550 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 551 */ 552 public HandlerThread getWifiAwareHandlerThread() { 553 if (mWifiAwareHandlerThread == null) { // lazy initialization 554 mWifiAwareHandlerThread = new HandlerThread("wifiAwareService"); 555 mWifiAwareHandlerThread.start(); 556 } 557 return mWifiAwareHandlerThread; 558 } 559 560 /** 561 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 562 * 563 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 564 */ 565 public HandlerThread getRttHandlerThread() { 566 if (mRttHandlerThread == null) { // lazy initialization 567 mRttHandlerThread = new HandlerThread("wifiRttService"); 568 mRttHandlerThread.start(); 569 } 570 return mRttHandlerThread; 571 } 572 573 /** 574 * Returns a single instance of HalDeviceManager for injection. 575 */ 576 public HalDeviceManager getHalDeviceManager() { 577 return mHalDeviceManager; 578 } 579 580 public WifiNative getWifiNative() { 581 return mWifiNative; 582 } 583 584 public WifiMonitor getWifiMonitor() { 585 return mWifiMonitor; 586 } 587 588 public WifiP2pNative getWifiP2pNative() { 589 return mWifiP2pNative; 590 } 591 592 public WifiP2pMonitor getWifiP2pMonitor() { 593 return mWifiP2pMonitor; 594 } 595 596 public SelfRecovery getSelfRecovery() { 597 return mSelfRecovery; 598 } 599 600 public PowerProfile getPowerProfile() { 601 return new PowerProfile(mContext, false); 602 } 603 604 public ScanRequestProxy getScanRequestProxy() { 605 return mScanRequestProxy; 606 } 607 608 public Runtime getJavaRuntime() { 609 return Runtime.getRuntime(); 610 } 611 612 public ActivityManagerService getActivityManagerService() { 613 return (ActivityManagerService) ActivityManager.getService(); 614 } 615 } 616