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.annotation.Nullable; 21 import android.app.ActivityManager; 22 import android.app.AlarmManager; 23 import android.app.AppOpsManager; 24 import android.app.BroadcastOptions; 25 import android.content.Context; 26 import android.net.IpMemoryStore; 27 import android.net.LinkProperties; 28 import android.net.MatchAllNetworkSpecifier; 29 import android.net.NetworkAgentConfig; 30 import android.net.NetworkCapabilities; 31 import android.net.NetworkProvider; 32 import android.net.wifi.WifiContext; 33 import android.net.wifi.WifiScanner; 34 import android.net.wifi.nl80211.WifiNl80211Manager; 35 import android.os.BatteryManager; 36 import android.os.BatteryStatsManager; 37 import android.os.Handler; 38 import android.os.HandlerThread; 39 import android.os.Looper; 40 import android.os.Process; 41 import android.os.UserManager; 42 import android.os.WorkSource; 43 import android.provider.Settings.Secure; 44 import android.security.keystore.AndroidKeyStoreProvider; 45 import android.telephony.CarrierConfigManager; 46 import android.telephony.SubscriptionManager; 47 import android.telephony.TelephonyManager; 48 import android.util.LocalLog; 49 import android.util.Log; 50 51 import com.android.internal.annotations.VisibleForTesting; 52 import com.android.modules.utils.build.SdkLevel; 53 import com.android.server.wifi.aware.WifiAwareMetrics; 54 import com.android.server.wifi.coex.CoexManager; 55 import com.android.server.wifi.hotspot2.PasspointManager; 56 import com.android.server.wifi.hotspot2.PasspointNetworkNominateHelper; 57 import com.android.server.wifi.hotspot2.PasspointObjectFactory; 58 import com.android.server.wifi.p2p.SupplicantP2pIfaceHal; 59 import com.android.server.wifi.p2p.WifiP2pMetrics; 60 import com.android.server.wifi.p2p.WifiP2pMonitor; 61 import com.android.server.wifi.p2p.WifiP2pNative; 62 import com.android.server.wifi.rtt.RttMetrics; 63 import com.android.server.wifi.util.LastCallerInfoManager; 64 import com.android.server.wifi.util.LruConnectionTracker; 65 import com.android.server.wifi.util.NetdWrapper; 66 import com.android.server.wifi.util.SettingsMigrationDataHolder; 67 import com.android.server.wifi.util.WifiPermissionsUtil; 68 import com.android.server.wifi.util.WifiPermissionsWrapper; 69 import com.android.server.wifi.util.WorkSourceHelper; 70 import com.android.wifi.resources.R; 71 72 import java.io.BufferedReader; 73 import java.io.FileNotFoundException; 74 import java.io.FileReader; 75 import java.security.KeyStore; 76 import java.security.KeyStoreException; 77 import java.security.NoSuchProviderException; 78 import java.util.Random; 79 80 /** 81 * WiFi dependency injector. To be used for accessing various WiFi class instances and as a 82 * handle for mock injection. 83 * 84 * Some WiFi class instances currently depend on having a Looper from a HandlerThread that has 85 * been started. To accommodate this, we have a two-phased approach to initialize and retrieve 86 * an instance of the WifiInjector. 87 */ 88 public class WifiInjector { 89 private static final String TAG = "WifiInjector"; 90 private static final String BOOT_DEFAULT_WIFI_COUNTRY_CODE = "ro.boot.wificountrycode"; 91 /** 92 * Maximum number in-memory store network connection order; 93 */ 94 private static final int MAX_RECENTLY_CONNECTED_NETWORK = 100; 95 makeBaseNetworkCapatibilitiesFilterBuilder()96 private static NetworkCapabilities.Builder makeBaseNetworkCapatibilitiesFilterBuilder() { 97 NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder() 98 .addTransportType(NetworkCapabilities.TRANSPORT_WIFI) 99 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) 100 .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED) 101 .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING) 102 .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED) 103 .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED) 104 .setLinkUpstreamBandwidthKbps(1024 * 1024) 105 .setLinkDownstreamBandwidthKbps(1024 * 1024) 106 .setNetworkSpecifier(new MatchAllNetworkSpecifier()); 107 if (SdkLevel.isAtLeastS()) { 108 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED); 109 } 110 return builder; 111 } 112 113 @VisibleForTesting 114 public static final NetworkCapabilities REGULAR_NETWORK_CAPABILITIES_FILTER = 115 makeBaseNetworkCapatibilitiesFilterBuilder() 116 .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) 117 .build(); 118 makeOemNetworkCapatibilitiesFilter()119 private static NetworkCapabilities makeOemNetworkCapatibilitiesFilter() { 120 NetworkCapabilities.Builder builder = 121 makeBaseNetworkCapatibilitiesFilterBuilder() 122 .addCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID); 123 if (SdkLevel.isAtLeastS()) { 124 // OEM_PRIVATE capability was only added in Android S. 125 builder.addCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE); 126 } 127 return builder.build(); 128 } 129 130 private static final NetworkCapabilities OEM_NETWORK_CAPABILITIES_FILTER = 131 makeOemNetworkCapatibilitiesFilter(); 132 133 private static final NetworkCapabilities RESTRICTED_NETWORK_CAPABILITIES_FILTER = 134 makeBaseNetworkCapatibilitiesFilterBuilder() 135 .removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) 136 .build(); 137 138 139 static WifiInjector sWifiInjector = null; 140 141 private final WifiContext mContext; 142 private final BatteryStatsManager mBatteryStats; 143 private final FrameworkFacade mFrameworkFacade = new FrameworkFacade(); 144 private final DeviceConfigFacade mDeviceConfigFacade; 145 private final UserManager mUserManager; 146 private final HandlerThread mWifiHandlerThread; 147 private final HandlerThread mWifiP2pServiceHandlerThread; 148 private final HandlerThread mPasspointProvisionerHandlerThread; 149 private final HandlerThread mWifiDiagnosticsHandlerThread; 150 private final WifiTrafficPoller mWifiTrafficPoller; 151 private final WifiCountryCode mCountryCode; 152 private final BackupManagerProxy mBackupManagerProxy = new BackupManagerProxy(); 153 private final WifiApConfigStore mWifiApConfigStore; 154 private final WifiNative mWifiNative; 155 private final WifiMonitor mWifiMonitor; 156 private final WifiP2pNative mWifiP2pNative; 157 private final WifiP2pMonitor mWifiP2pMonitor; 158 private final SupplicantStaIfaceHal mSupplicantStaIfaceHal; 159 private final SupplicantP2pIfaceHal mSupplicantP2pIfaceHal; 160 private final HostapdHal mHostapdHal; 161 private final WifiVendorHal mWifiVendorHal; 162 private final ScoringParams mScoringParams; 163 private final ActiveModeWarden mActiveModeWarden; 164 private final WifiSettingsStore mSettingsStore; 165 private final OpenNetworkNotifier mOpenNetworkNotifier; 166 private final WifiLockManager mLockManager; 167 private final WifiNl80211Manager mWifiCondManager; 168 private final Clock mClock = new Clock(); 169 private final WifiMetrics mWifiMetrics; 170 private final WifiP2pMetrics mWifiP2pMetrics; 171 private final WifiLastResortWatchdog mWifiLastResortWatchdog; 172 private final PropertyService mPropertyService = new SystemPropertyService(); 173 private final BuildProperties mBuildProperties = new SystemBuildProperties(); 174 private final WifiBackupRestore mWifiBackupRestore; 175 // This will only be null if SdkLevel is not at least S 176 @Nullable private final CoexManager mCoexManager; 177 private final SoftApBackupRestore mSoftApBackupRestore; 178 private final WifiMulticastLockManager mWifiMulticastLockManager; 179 private final WifiConfigStore mWifiConfigStore; 180 private final WifiKeyStore mWifiKeyStore; 181 private final WifiConfigManager mWifiConfigManager; 182 private final WifiConnectivityHelper mWifiConnectivityHelper; 183 private final LocalLog mConnectivityLocalLog; 184 private final WifiNetworkSelector mWifiNetworkSelector; 185 private final SavedNetworkNominator mSavedNetworkNominator; 186 private final NetworkSuggestionNominator mNetworkSuggestionNominator; 187 private final ClientModeManagerBroadcastQueue mBroadcastQueue; 188 private WifiScanner mWifiScanner; 189 private final WifiPermissionsWrapper mWifiPermissionsWrapper; 190 private final WifiPermissionsUtil mWifiPermissionsUtil; 191 private final PasspointManager mPasspointManager; 192 private HandlerThread mWifiAwareHandlerThread; 193 private HandlerThread mRttHandlerThread; 194 private final HalDeviceManager mHalDeviceManager; 195 private final WifiStateTracker mWifiStateTracker; 196 private final SelfRecovery mSelfRecovery; 197 private final WakeupController mWakeupController; 198 private final ScanRequestProxy mScanRequestProxy; 199 private final SarManager mSarManager; 200 private final WifiDiagnostics mWifiDiagnostics; 201 private final WifiDataStall mWifiDataStall; 202 private final WifiScoreCard mWifiScoreCard; 203 private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager; 204 private final DppMetrics mDppMetrics; 205 private final DppManager mDppManager; 206 private final LinkProbeManager mLinkProbeManager; 207 private IpMemoryStore mIpMemoryStore; 208 private final WifiThreadRunner mWifiThreadRunner; 209 private final WifiBlocklistMonitor mWifiBlocklistMonitor; 210 private final MacAddressUtil mMacAddressUtil = new MacAddressUtil(); 211 private final MboOceController mMboOceController; 212 private final WifiCarrierInfoManager mWifiCarrierInfoManager; 213 private final WifiChannelUtilization mWifiChannelUtilizationScan; 214 private final KeyStore mKeyStore; 215 private final ConnectionFailureNotificationBuilder mConnectionFailureNotificationBuilder; 216 private final ThroughputPredictor mThroughputPredictor; 217 private NetdWrapper mNetdWrapper; 218 private final WifiHealthMonitor mWifiHealthMonitor; 219 private final WifiSettingsConfigStore mSettingsConfigStore; 220 private final WifiScanAlwaysAvailableSettingsCompatibility 221 mWifiScanAlwaysAvailableSettingsCompatibility; 222 private final SettingsMigrationDataHolder mSettingsMigrationDataHolder; 223 private final LruConnectionTracker mLruConnectionTracker; 224 private final WifiConnectivityManager mWifiConnectivityManager; 225 private final ExternalPnoScanRequestManager mExternalPnoScanRequestManager; 226 private final ConnectHelper mConnectHelper; 227 private final ConnectionFailureNotifier mConnectionFailureNotifier; 228 private final WifiNetworkFactory mWifiNetworkFactory; 229 private final UntrustedWifiNetworkFactory mUntrustedWifiNetworkFactory; 230 private final OemWifiNetworkFactory mOemWifiNetworkFactory; 231 private final RestrictedWifiNetworkFactory mRestrictedWifiNetworkFactory; 232 private final MultiInternetWifiNetworkFactory mMultiInternetWifiNetworkFactory; 233 private final WifiP2pConnection mWifiP2pConnection; 234 private final WifiGlobals mWifiGlobals; 235 private final SimRequiredNotifier mSimRequiredNotifier; 236 private final DefaultClientModeManager mDefaultClientModeManager; 237 private final AdaptiveConnectivityEnabledSettingObserver 238 mAdaptiveConnectivityEnabledSettingObserver; 239 private final MakeBeforeBreakManager mMakeBeforeBreakManager; 240 private final MultiInternetManager mMultiInternetManager; 241 private final ClientModeImplMonitor mCmiMonitor = new ClientModeImplMonitor(); 242 private final ExternalScoreUpdateObserverProxy mExternalScoreUpdateObserverProxy; 243 private final WifiNotificationManager mWifiNotificationManager; 244 private final LastCallerInfoManager mLastCallerInfoManager; 245 private final InterfaceConflictManager mInterfaceConflictManager; 246 @NonNull private final WifiDialogManager mWifiDialogManager; 247 WifiInjector(WifiContext context)248 public WifiInjector(WifiContext context) { 249 if (context == null) { 250 throw new IllegalStateException( 251 "WifiInjector should not be initialized with a null Context."); 252 } 253 254 if (sWifiInjector != null) { 255 throw new IllegalStateException( 256 "WifiInjector was already created, use getInstance instead."); 257 } 258 259 sWifiInjector = this; 260 261 // Now create and start handler threads 262 mWifiHandlerThread = new HandlerThread("WifiHandlerThread"); 263 mWifiHandlerThread.start(); 264 Looper wifiLooper = mWifiHandlerThread.getLooper(); 265 Handler wifiHandler = new Handler(wifiLooper); 266 mWifiDiagnosticsHandlerThread = new HandlerThread("WifiDiagnostics"); 267 mWifiDiagnosticsHandlerThread.start(); 268 269 mContext = context; 270 mWifiNotificationManager = new WifiNotificationManager(mContext); 271 mWifiGlobals = new WifiGlobals(mContext); 272 mScoringParams = new ScoringParams(mContext); 273 mWifiChannelUtilizationScan = new WifiChannelUtilization(mClock, mContext); 274 mSettingsMigrationDataHolder = new SettingsMigrationDataHolder(mContext); 275 mConnectionFailureNotificationBuilder = new ConnectionFailureNotificationBuilder( 276 mContext, mFrameworkFacade); 277 mBatteryStats = context.getSystemService(BatteryStatsManager.class); 278 mWifiPermissionsWrapper = new WifiPermissionsWrapper(mContext); 279 mUserManager = mContext.getSystemService(UserManager.class); 280 mWifiPermissionsUtil = new WifiPermissionsUtil(mWifiPermissionsWrapper, mContext, 281 mUserManager, this); 282 mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil); 283 mSoftApBackupRestore = new SoftApBackupRestore(mContext, mSettingsMigrationDataHolder); 284 mWifiStateTracker = new WifiStateTracker(mBatteryStats); 285 mWifiThreadRunner = new WifiThreadRunner(wifiHandler); 286 mWifiDialogManager = new WifiDialogManager(mContext, mWifiThreadRunner); 287 mWifiP2pServiceHandlerThread = new HandlerThread("WifiP2pService"); 288 mWifiP2pServiceHandlerThread.start(); 289 mPasspointProvisionerHandlerThread = 290 new HandlerThread("PasspointProvisionerHandlerThread"); 291 mPasspointProvisionerHandlerThread.start(); 292 WifiAwareMetrics awareMetrics = new WifiAwareMetrics(mClock); 293 RttMetrics rttMetrics = new RttMetrics(mClock); 294 mWifiP2pMetrics = new WifiP2pMetrics(mClock); 295 mDppMetrics = new DppMetrics(); 296 mWifiMonitor = new WifiMonitor(); 297 mWifiMetrics = new WifiMetrics(mContext, mFrameworkFacade, mClock, wifiLooper, 298 awareMetrics, rttMetrics, new WifiPowerMetrics(mBatteryStats), mWifiP2pMetrics, 299 mDppMetrics, mWifiMonitor); 300 mDeviceConfigFacade = new DeviceConfigFacade(mContext, wifiHandler, mWifiMetrics); 301 mAdaptiveConnectivityEnabledSettingObserver = 302 new AdaptiveConnectivityEnabledSettingObserver(wifiHandler, mWifiMetrics, 303 mFrameworkFacade, mContext); 304 // Modules interacting with Native. 305 mHalDeviceManager = new HalDeviceManager(mContext, mClock, this, wifiHandler); 306 mInterfaceConflictManager = new InterfaceConflictManager(mContext, mFrameworkFacade, 307 mHalDeviceManager, mWifiThreadRunner, mWifiDialogManager); 308 mWifiVendorHal = new WifiVendorHal(mContext, mHalDeviceManager, wifiHandler, mWifiGlobals); 309 mSupplicantStaIfaceHal = new SupplicantStaIfaceHal( 310 mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics, 311 mWifiGlobals); 312 mHostapdHal = new HostapdHal(mContext, wifiHandler); 313 mWifiCondManager = (WifiNl80211Manager) mContext.getSystemService( 314 Context.WIFI_NL80211_SERVICE); 315 mWifiNative = new WifiNative( 316 mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager, 317 mWifiMonitor, mPropertyService, mWifiMetrics, 318 wifiHandler, new Random(), mBuildProperties, this); 319 mWifiP2pMonitor = new WifiP2pMonitor(); 320 mSupplicantP2pIfaceHal = new SupplicantP2pIfaceHal(mWifiP2pMonitor, mWifiGlobals); 321 mWifiP2pNative = new WifiP2pNative(mWifiCondManager, mWifiNative, 322 mWifiVendorHal, mSupplicantP2pIfaceHal, mHalDeviceManager, mPropertyService); 323 SubscriptionManager subscriptionManager = 324 mContext.getSystemService(SubscriptionManager.class); 325 if (SdkLevel.isAtLeastS()) { 326 mCoexManager = new CoexManager(mContext, mWifiNative, makeTelephonyManager(), 327 subscriptionManager, mContext.getSystemService(CarrierConfigManager.class), 328 wifiHandler); 329 } else { 330 mCoexManager = null; 331 } 332 333 // Now get instances of all the objects that depend on the HandlerThreads 334 mWifiTrafficPoller = new WifiTrafficPoller(mContext); 335 // WifiConfigManager/Store objects and their dependencies. 336 KeyStore keyStore = null; 337 try { 338 keyStore = AndroidKeyStoreProvider.getKeyStoreForUid(Process.WIFI_UID); 339 } catch (KeyStoreException | NoSuchProviderException e) { 340 Log.wtf(TAG, "Failed to load keystore", e); 341 } 342 mKeyStore = keyStore; 343 mWifiKeyStore = new WifiKeyStore(mContext, mKeyStore, mFrameworkFacade); 344 // New config store 345 mWifiConfigStore = new WifiConfigStore(mContext, wifiHandler, mClock, mWifiMetrics, 346 WifiConfigStore.createSharedFiles(mFrameworkFacade.isNiapModeOn(mContext))); 347 mWifiCarrierInfoManager = new WifiCarrierInfoManager(makeTelephonyManager(), 348 subscriptionManager, this, mFrameworkFacade, mContext, 349 mWifiConfigStore, wifiHandler, mWifiMetrics, mClock); 350 String l2KeySeed = Secure.getString(mContext.getContentResolver(), Secure.ANDROID_ID); 351 mWifiScoreCard = new WifiScoreCard(mClock, l2KeySeed, mDeviceConfigFacade, 352 mContext); 353 mWifiMetrics.setWifiScoreCard(mWifiScoreCard); 354 mLruConnectionTracker = new LruConnectionTracker(MAX_RECENTLY_CONNECTED_NETWORK, 355 mContext); 356 mWifiConnectivityHelper = new WifiConnectivityHelper(this); 357 int maxLinesLowRam = mContext.getResources().getInteger( 358 R.integer.config_wifiConnectivityLocalLogMaxLinesLowRam); 359 int maxLinesHighRam = mContext.getResources().getInteger( 360 R.integer.config_wifiConnectivityLocalLogMaxLinesHighRam); 361 mConnectivityLocalLog = new LocalLog( 362 mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? maxLinesLowRam 363 : maxLinesHighRam); 364 mWifiDiagnostics = new WifiDiagnostics( 365 mContext, this, mWifiNative, mBuildProperties, 366 new LastMileLogger(this), mClock, mWifiDiagnosticsHandlerThread.getLooper()); 367 mWifiLastResortWatchdog = new WifiLastResortWatchdog(this, mContext, mClock, 368 mWifiMetrics, mWifiDiagnostics, wifiLooper, 369 mDeviceConfigFacade, mWifiThreadRunner, mWifiMonitor); 370 mWifiBlocklistMonitor = new WifiBlocklistMonitor(mContext, mWifiConnectivityHelper, 371 mWifiLastResortWatchdog, mClock, new LocalLog( 372 mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? 128 : 256), 373 mWifiScoreCard, mScoringParams, mWifiMetrics, mWifiPermissionsUtil); 374 mWifiMetrics.setWifiBlocklistMonitor(mWifiBlocklistMonitor); 375 // Config Manager 376 mWifiConfigManager = new WifiConfigManager(mContext, mWifiKeyStore, mWifiConfigStore, 377 new NetworkListSharedStoreData(mContext), 378 new NetworkListUserStoreData(mContext), 379 new RandomizedMacStoreData(), 380 mLruConnectionTracker, this); 381 mSettingsConfigStore = new WifiSettingsConfigStore(context, wifiHandler, 382 mSettingsMigrationDataHolder, mWifiConfigManager, mWifiConfigStore); 383 mSettingsStore = new WifiSettingsStore(mContext, mSettingsConfigStore); 384 mWifiMetrics.setWifiConfigManager(mWifiConfigManager); 385 mWifiMetrics.setWifiSettingsStore(mSettingsStore); 386 387 mWifiMetrics.setScoringParams(mScoringParams); 388 mThroughputPredictor = new ThroughputPredictor(mContext); 389 mScanRequestProxy = new ScanRequestProxy(mContext, 390 mContext.getSystemService(AppOpsManager.class), 391 mContext.getSystemService(ActivityManager.class), 392 this, mWifiConfigManager, 393 mWifiPermissionsUtil, mWifiMetrics, mClock, wifiHandler, mSettingsConfigStore); 394 mSarManager = new SarManager(mContext, makeTelephonyManager(), wifiLooper, 395 mWifiNative); 396 mWifiNetworkSelector = new WifiNetworkSelector(mContext, mWifiScoreCard, mScoringParams, 397 mWifiConfigManager, mClock, mConnectivityLocalLog, mWifiMetrics, this, 398 mThroughputPredictor, mWifiChannelUtilizationScan, mWifiGlobals, 399 mScanRequestProxy); 400 CompatibilityScorer compatibilityScorer = new CompatibilityScorer(mScoringParams); 401 mWifiNetworkSelector.registerCandidateScorer(compatibilityScorer); 402 ScoreCardBasedScorer scoreCardBasedScorer = new ScoreCardBasedScorer(mScoringParams); 403 mWifiNetworkSelector.registerCandidateScorer(scoreCardBasedScorer); 404 BubbleFunScorer bubbleFunScorer = new BubbleFunScorer(mScoringParams); 405 mWifiNetworkSelector.registerCandidateScorer(bubbleFunScorer); 406 ThroughputScorer throughputScorer = new ThroughputScorer(mScoringParams); 407 mWifiNetworkSelector.registerCandidateScorer(throughputScorer); 408 mWifiMetrics.setWifiNetworkSelector(mWifiNetworkSelector); 409 mWifiNetworkSuggestionsManager = new WifiNetworkSuggestionsManager(mContext, wifiHandler, 410 this, mWifiPermissionsUtil, mWifiConfigManager, mWifiConfigStore, mWifiMetrics, 411 mWifiCarrierInfoManager, mWifiKeyStore, mLruConnectionTracker, 412 mClock); 413 mPasspointManager = new PasspointManager(mContext, this, 414 wifiHandler, mWifiNative, mWifiKeyStore, mClock, new PasspointObjectFactory(), 415 mWifiConfigManager, mWifiConfigStore, mSettingsStore, mWifiMetrics, 416 mWifiCarrierInfoManager, mMacAddressUtil, mWifiPermissionsUtil); 417 PasspointNetworkNominateHelper nominateHelper = 418 new PasspointNetworkNominateHelper(mPasspointManager, mWifiConfigManager, 419 mConnectivityLocalLog, mWifiCarrierInfoManager); 420 mPasspointManager.setPasspointNetworkNominateHelper(nominateHelper); 421 mSavedNetworkNominator = new SavedNetworkNominator( 422 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager, 423 mWifiPermissionsUtil, mWifiNetworkSuggestionsManager); 424 mNetworkSuggestionNominator = new NetworkSuggestionNominator(mWifiNetworkSuggestionsManager, 425 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager, 426 mWifiMetrics); 427 428 mWifiMetrics.setPasspointManager(mPasspointManager); 429 WifiChannelUtilization wifiChannelUtilizationConnected = 430 new WifiChannelUtilization(mClock, mContext); 431 mWifiMetrics.setWifiChannelUtilization(wifiChannelUtilizationConnected); 432 mLinkProbeManager = new LinkProbeManager(mClock, mWifiNative, mWifiMetrics, 433 mFrameworkFacade, wifiHandler, mContext); 434 mDefaultClientModeManager = new DefaultClientModeManager(); 435 mExternalScoreUpdateObserverProxy = 436 new ExternalScoreUpdateObserverProxy(mWifiThreadRunner); 437 mDppManager = new DppManager(wifiHandler, mWifiNative, 438 mWifiConfigManager, mContext, mDppMetrics, mScanRequestProxy, mWifiPermissionsUtil); 439 mActiveModeWarden = new ActiveModeWarden(this, wifiLooper, 440 mWifiNative, mDefaultClientModeManager, mBatteryStats, mWifiDiagnostics, 441 mContext, mSettingsStore, mFrameworkFacade, mWifiPermissionsUtil, mWifiMetrics, 442 mExternalScoreUpdateObserverProxy, mDppManager); 443 mWifiMetrics.setActiveModeWarden(mActiveModeWarden); 444 mWifiHealthMonitor = new WifiHealthMonitor(mContext, this, mClock, mWifiConfigManager, 445 mWifiScoreCard, wifiHandler, mWifiNative, l2KeySeed, mDeviceConfigFacade, 446 mActiveModeWarden); 447 mWifiDataStall = new WifiDataStall(mWifiMetrics, mContext, 448 mDeviceConfigFacade, wifiChannelUtilizationConnected, mClock, wifiHandler, 449 mThroughputPredictor, mActiveModeWarden, mCmiMonitor); 450 mWifiMetrics.setWifiDataStall(mWifiDataStall); 451 mWifiMetrics.setWifiHealthMonitor(mWifiHealthMonitor); 452 mWifiP2pConnection = new WifiP2pConnection(mContext, wifiLooper, mActiveModeWarden); 453 mConnectHelper = new ConnectHelper(mActiveModeWarden, mWifiConfigManager); 454 mBroadcastQueue = new ClientModeManagerBroadcastQueue(mActiveModeWarden, mContext); 455 mMakeBeforeBreakManager = new MakeBeforeBreakManager(mActiveModeWarden, mFrameworkFacade, 456 mContext, mCmiMonitor, mBroadcastQueue, mWifiMetrics); 457 mOpenNetworkNotifier = new OpenNetworkNotifier(mContext, 458 wifiLooper, mFrameworkFacade, mClock, mWifiMetrics, 459 mWifiConfigManager, mWifiConfigStore, mConnectHelper, 460 new ConnectToNetworkNotificationBuilder(mContext, mFrameworkFacade), 461 mMakeBeforeBreakManager, mWifiNotificationManager, mWifiPermissionsUtil); 462 mMultiInternetManager = new MultiInternetManager(mActiveModeWarden, mFrameworkFacade, 463 mContext, mCmiMonitor, mSettingsStore, wifiHandler, mClock); 464 mExternalPnoScanRequestManager = new ExternalPnoScanRequestManager(wifiHandler, mContext); 465 mWifiConnectivityManager = new WifiConnectivityManager( 466 mContext, mScoringParams, mWifiConfigManager, 467 mWifiNetworkSuggestionsManager, mWifiNetworkSelector, 468 mWifiConnectivityHelper, mWifiLastResortWatchdog, mOpenNetworkNotifier, 469 mWifiMetrics, wifiHandler, 470 mClock, mConnectivityLocalLog, mWifiScoreCard, mWifiBlocklistMonitor, 471 mWifiChannelUtilizationScan, mPasspointManager, mMultiInternetManager, 472 mDeviceConfigFacade, mActiveModeWarden, mFrameworkFacade, mWifiGlobals, 473 mExternalPnoScanRequestManager); 474 mMboOceController = new MboOceController(makeTelephonyManager(), mActiveModeWarden); 475 mCountryCode = new WifiCountryCode(mContext, mActiveModeWarden, 476 mCmiMonitor, mWifiNative, mSettingsConfigStore); 477 mConnectionFailureNotifier = new ConnectionFailureNotifier( 478 mContext, mFrameworkFacade, mWifiConfigManager, 479 mWifiConnectivityManager, wifiHandler, 480 mWifiNotificationManager, mConnectionFailureNotificationBuilder, 481 mWifiDialogManager); 482 mWifiNetworkFactory = new WifiNetworkFactory( 483 wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER, 484 (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE), 485 (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE), 486 (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE), 487 mClock, this, mWifiConnectivityManager, mWifiConfigManager, 488 mWifiConfigStore, mWifiPermissionsUtil, mWifiMetrics, mWifiNative, 489 mActiveModeWarden, mConnectHelper, mCmiMonitor, mFrameworkFacade, 490 mMultiInternetManager); 491 // We can't filter untrusted network in the capabilities filter because a trusted 492 // network would still satisfy a request that accepts untrusted ones. 493 // We need a second network factory for untrusted network requests because we need a 494 // different score filter for these requests. 495 mUntrustedWifiNetworkFactory = new UntrustedWifiNetworkFactory( 496 wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER, 497 mWifiConnectivityManager); 498 mOemWifiNetworkFactory = new OemWifiNetworkFactory( 499 wifiLooper, mContext, OEM_NETWORK_CAPABILITIES_FILTER, 500 mWifiConnectivityManager); 501 mRestrictedWifiNetworkFactory = new RestrictedWifiNetworkFactory( 502 wifiLooper, mContext, RESTRICTED_NETWORK_CAPABILITIES_FILTER, 503 mWifiConnectivityManager); 504 mMultiInternetWifiNetworkFactory = new MultiInternetWifiNetworkFactory( 505 wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER, 506 mFrameworkFacade, mContext.getSystemService(AlarmManager.class), 507 mWifiPermissionsUtil, mMultiInternetManager, mWifiConnectivityManager, 508 mConnectivityLocalLog); 509 mWifiScanAlwaysAvailableSettingsCompatibility = 510 new WifiScanAlwaysAvailableSettingsCompatibility(mContext, wifiHandler, 511 mSettingsStore, mActiveModeWarden, mFrameworkFacade); 512 mWifiApConfigStore = new WifiApConfigStore( 513 mContext, this, wifiHandler, mBackupManagerProxy, 514 mWifiConfigStore, mWifiConfigManager, mActiveModeWarden, mWifiMetrics); 515 WakeupNotificationFactory wakeupNotificationFactory = 516 new WakeupNotificationFactory(mContext, mFrameworkFacade); 517 WakeupOnboarding wakeupOnboarding = new WakeupOnboarding(mContext, mWifiConfigManager, 518 wifiHandler, mFrameworkFacade, wakeupNotificationFactory, mWifiNotificationManager); 519 mWakeupController = new WakeupController(mContext, wifiHandler, 520 new WakeupLock(mWifiConfigManager, mWifiMetrics.getWakeupMetrics(), mClock), 521 new WakeupEvaluator(mScoringParams), wakeupOnboarding, mWifiConfigManager, 522 mWifiConfigStore, mWifiNetworkSuggestionsManager, mWifiMetrics.getWakeupMetrics(), 523 this, mFrameworkFacade, mClock, mActiveModeWarden); 524 mLockManager = new WifiLockManager(mContext, mBatteryStats, mActiveModeWarden, 525 mFrameworkFacade, wifiHandler, mClock, mWifiMetrics); 526 mSelfRecovery = new SelfRecovery(mContext, mActiveModeWarden, mClock, mWifiNative); 527 mWifiMulticastLockManager = new WifiMulticastLockManager(mActiveModeWarden, mBatteryStats, 528 wifiLooper); 529 530 // Register the various network Nominators with the network selector. 531 mWifiNetworkSelector.registerNetworkNominator(mSavedNetworkNominator); 532 mWifiNetworkSelector.registerNetworkNominator(mNetworkSuggestionNominator); 533 534 mSimRequiredNotifier = new SimRequiredNotifier(mContext, mFrameworkFacade, 535 mWifiNotificationManager); 536 mLastCallerInfoManager = new LastCallerInfoManager(); 537 } 538 539 /** 540 * Obtain an instance of the WifiInjector class. 541 * 542 * This is the generic method to get an instance of the class. The first instance should be 543 * retrieved using the getInstanceWithContext method. 544 */ getInstance()545 public static WifiInjector getInstance() { 546 if (sWifiInjector == null) { 547 throw new IllegalStateException( 548 "Attempted to retrieve a WifiInjector instance before constructor was called."); 549 } 550 return sWifiInjector; 551 } 552 553 /** 554 * Enable verbose logging in Injector objects. Called from the WifiServiceImpl (based on 555 * binder call). 556 */ enableVerboseLogging(boolean verboseEnabled, boolean halVerboseEnabled)557 public void enableVerboseLogging(boolean verboseEnabled, boolean halVerboseEnabled) { 558 Log.i(TAG, "enableVerboseLogging " + verboseEnabled + " hal " + halVerboseEnabled); 559 mWifiLastResortWatchdog.enableVerboseLogging(verboseEnabled); 560 mWifiBackupRestore.enableVerboseLogging(verboseEnabled); 561 mHalDeviceManager.enableVerboseLogging(verboseEnabled); 562 mScanRequestProxy.enableVerboseLogging(verboseEnabled); 563 mInterfaceConflictManager.enableVerboseLogging(verboseEnabled); 564 mWakeupController.enableVerboseLogging(verboseEnabled); 565 mWifiNetworkSuggestionsManager.enableVerboseLogging(verboseEnabled); 566 LogcatLog.enableVerboseLogging(verboseEnabled); 567 mDppManager.enableVerboseLogging(verboseEnabled); 568 mWifiCarrierInfoManager.enableVerboseLogging(verboseEnabled); 569 mCountryCode.enableVerboseLogging(verboseEnabled); 570 mWifiDiagnostics.enableVerboseLogging(verboseEnabled, halVerboseEnabled); 571 mWifiMonitor.enableVerboseLogging(verboseEnabled); 572 mWifiNative.enableVerboseLogging(verboseEnabled, halVerboseEnabled); 573 mWifiConfigManager.enableVerboseLogging(verboseEnabled); 574 mPasspointManager.enableVerboseLogging(verboseEnabled); 575 mWifiNetworkFactory.enableVerboseLogging(verboseEnabled); 576 mLinkProbeManager.enableVerboseLogging(verboseEnabled); 577 mMboOceController.enableVerboseLogging(verboseEnabled); 578 mWifiScoreCard.enableVerboseLogging(verboseEnabled); 579 mWifiHealthMonitor.enableVerboseLogging(verboseEnabled); 580 mThroughputPredictor.enableVerboseLogging(verboseEnabled); 581 mWifiDataStall.enableVerboseLogging(verboseEnabled); 582 mWifiConnectivityManager.enableVerboseLogging(verboseEnabled); 583 mWifiNetworkSelector.enableVerboseLogging(verboseEnabled); 584 mMakeBeforeBreakManager.setVerboseLoggingEnabled(verboseEnabled); 585 mMultiInternetManager.setVerboseLoggingEnabled(verboseEnabled); 586 mBroadcastQueue.setVerboseLoggingEnabled(verboseEnabled); 587 if (SdkLevel.isAtLeastS()) { 588 mCoexManager.enableVerboseLogging(verboseEnabled); 589 } 590 mWifiPermissionsUtil.enableVerboseLogging(verboseEnabled); 591 mWifiDialogManager.enableVerboseLogging(verboseEnabled); 592 mExternalPnoScanRequestManager.enableVerboseLogging(verboseEnabled); 593 } 594 getUserManager()595 public UserManager getUserManager() { 596 return mUserManager; 597 } 598 getWifiMetrics()599 public WifiMetrics getWifiMetrics() { 600 return mWifiMetrics; 601 } 602 getWifiP2pMetrics()603 public WifiP2pMetrics getWifiP2pMetrics() { 604 return mWifiP2pMetrics; 605 } 606 getSupplicantStaIfaceHal()607 public SupplicantStaIfaceHal getSupplicantStaIfaceHal() { 608 return mSupplicantStaIfaceHal; 609 } 610 getBackupManagerProxy()611 public BackupManagerProxy getBackupManagerProxy() { 612 return mBackupManagerProxy; 613 } 614 getFrameworkFacade()615 public FrameworkFacade getFrameworkFacade() { 616 return mFrameworkFacade; 617 } 618 getWifiP2pServiceHandlerThread()619 public HandlerThread getWifiP2pServiceHandlerThread() { 620 return mWifiP2pServiceHandlerThread; 621 } 622 getPasspointProvisionerHandlerThread()623 public HandlerThread getPasspointProvisionerHandlerThread() { 624 return mPasspointProvisionerHandlerThread; 625 } 626 getWifiHandlerThread()627 public HandlerThread getWifiHandlerThread() { 628 return mWifiHandlerThread; 629 } 630 631 /** 632 * Wrapper method for getting the current native Java Thread ID of the current thread. 633 */ getCurrentThreadId()634 public long getCurrentThreadId() { 635 return Thread.currentThread().getId(); 636 } 637 getWifiTrafficPoller()638 public WifiTrafficPoller getWifiTrafficPoller() { 639 return mWifiTrafficPoller; 640 } 641 getWifiCountryCode()642 public WifiCountryCode getWifiCountryCode() { 643 return mCountryCode; 644 } 645 getWifiApConfigStore()646 public WifiApConfigStore getWifiApConfigStore() { 647 return mWifiApConfigStore; 648 } 649 getSarManager()650 public SarManager getSarManager() { 651 return mSarManager; 652 } 653 getActiveModeWarden()654 public ActiveModeWarden getActiveModeWarden() { 655 return mActiveModeWarden; 656 } 657 getWifiSettingsStore()658 public WifiSettingsStore getWifiSettingsStore() { 659 return mSettingsStore; 660 } 661 getWifiLockManager()662 public WifiLockManager getWifiLockManager() { 663 return mLockManager; 664 } 665 getWifiLastResortWatchdog()666 public WifiLastResortWatchdog getWifiLastResortWatchdog() { 667 return mWifiLastResortWatchdog; 668 } 669 getClock()670 public Clock getClock() { 671 return mClock; 672 } 673 getWifiBackupRestore()674 public WifiBackupRestore getWifiBackupRestore() { 675 return mWifiBackupRestore; 676 } 677 getSoftApBackupRestore()678 public SoftApBackupRestore getSoftApBackupRestore() { 679 return mSoftApBackupRestore; 680 } 681 getWifiMulticastLockManager()682 public WifiMulticastLockManager getWifiMulticastLockManager() { 683 return mWifiMulticastLockManager; 684 } 685 getWifiConfigManager()686 public WifiConfigManager getWifiConfigManager() { 687 return mWifiConfigManager; 688 } 689 getPasspointManager()690 public PasspointManager getPasspointManager() { 691 return mPasspointManager; 692 } 693 getWakeupController()694 public WakeupController getWakeupController() { 695 return mWakeupController; 696 } 697 getScoringParams()698 public ScoringParams getScoringParams() { 699 return mScoringParams; 700 } 701 getWifiScoreCard()702 public WifiScoreCard getWifiScoreCard() { 703 return mWifiScoreCard; 704 } 705 makeTelephonyManager()706 public TelephonyManager makeTelephonyManager() { 707 return mContext.getSystemService(TelephonyManager.class); 708 } 709 710 /** 711 * Returns BatteryManager service 712 */ makeBatteryManager()713 public BatteryManager makeBatteryManager() { 714 return mContext.getSystemService(BatteryManager.class); 715 } 716 getWifiCarrierInfoManager()717 public WifiCarrierInfoManager getWifiCarrierInfoManager() { 718 return mWifiCarrierInfoManager; 719 } 720 getDppManager()721 public DppManager getDppManager() { 722 return mDppManager; 723 } 724 725 /** 726 * Create a WifiShellCommand. 727 * 728 * @param wifiService WifiServiceImpl object shell commands get sent to. 729 * @return an instance of WifiShellCommand 730 */ makeWifiShellCommand(WifiServiceImpl wifiService)731 public WifiShellCommand makeWifiShellCommand(WifiServiceImpl wifiService) { 732 return new WifiShellCommand(this, wifiService, mContext, 733 mWifiGlobals, mWifiThreadRunner); 734 } 735 736 /** 737 * Create a SoftApManager. 738 * 739 * @param config SoftApModeConfiguration object holding the config and mode 740 * @return an instance of SoftApManager 741 */ makeSoftApManager( @onNull ActiveModeManager.Listener<SoftApManager> listener, @NonNull WifiServiceImpl.SoftApCallbackInternal callback, @NonNull SoftApModeConfiguration config, @NonNull WorkSource requestorWs, @NonNull ActiveModeManager.SoftApRole role, boolean verboseLoggingEnabled)742 public SoftApManager makeSoftApManager( 743 @NonNull ActiveModeManager.Listener<SoftApManager> listener, 744 @NonNull WifiServiceImpl.SoftApCallbackInternal callback, 745 @NonNull SoftApModeConfiguration config, 746 @NonNull WorkSource requestorWs, 747 @NonNull ActiveModeManager.SoftApRole role, 748 boolean verboseLoggingEnabled) { 749 return new SoftApManager(mContext, mWifiHandlerThread.getLooper(), 750 mFrameworkFacade, mWifiNative, mCoexManager, makeBatteryManager(), 751 mCountryCode.getCountryCode(), listener, callback, mWifiApConfigStore, 752 config, mWifiMetrics, mSarManager, mWifiDiagnostics, 753 new SoftApNotifier(mContext, mFrameworkFacade, mWifiNotificationManager), 754 mCmiMonitor, mActiveModeWarden, mClock.getElapsedSinceBootMillis(), 755 requestorWs, role, verboseLoggingEnabled); 756 } 757 758 /** 759 * Create a ClientModeImpl 760 * @param ifaceName interface name for the ClientModeImpl 761 * @param clientModeManager ClientModeManager that will own the ClientModeImpl 762 */ makeClientModeImpl( @onNull String ifaceName, @NonNull ConcreteClientModeManager clientModeManager, boolean verboseLoggingEnabled)763 public ClientModeImpl makeClientModeImpl( 764 @NonNull String ifaceName, 765 @NonNull ConcreteClientModeManager clientModeManager, 766 boolean verboseLoggingEnabled) { 767 ExtendedWifiInfo wifiInfo = new ExtendedWifiInfo(mWifiGlobals, ifaceName); 768 SupplicantStateTracker supplicantStateTracker = new SupplicantStateTracker( 769 mContext, mWifiConfigManager, mBatteryStats, mWifiHandlerThread.getLooper(), 770 mWifiMonitor, ifaceName, clientModeManager, mBroadcastQueue); 771 supplicantStateTracker.enableVerboseLogging(verboseLoggingEnabled); 772 return new ClientModeImpl(mContext, mWifiMetrics, mClock, 773 mWifiScoreCard, mWifiStateTracker, mWifiPermissionsUtil, mWifiConfigManager, 774 mPasspointManager, mWifiMonitor, mWifiDiagnostics, 775 mWifiDataStall, mScoringParams, mWifiThreadRunner, 776 mWifiNetworkSuggestionsManager, mWifiHealthMonitor, mThroughputPredictor, 777 mDeviceConfigFacade, mScanRequestProxy, wifiInfo, mWifiConnectivityManager, 778 mWifiBlocklistMonitor, mConnectionFailureNotifier, 779 REGULAR_NETWORK_CAPABILITIES_FILTER, mWifiNetworkFactory, 780 mUntrustedWifiNetworkFactory, mOemWifiNetworkFactory, mRestrictedWifiNetworkFactory, 781 mMultiInternetManager, mWifiLastResortWatchdog, mWakeupController, 782 mLockManager, mFrameworkFacade, mWifiHandlerThread.getLooper(), 783 mWifiNative, new WrongPasswordNotifier(mContext, mFrameworkFacade, 784 mWifiNotificationManager), 785 mWifiTrafficPoller, mLinkProbeManager, mClock.getElapsedSinceBootMillis(), 786 mBatteryStats, supplicantStateTracker, mMboOceController, mWifiCarrierInfoManager, 787 new EapFailureNotifier(mContext, mFrameworkFacade, mWifiCarrierInfoManager, 788 mWifiNotificationManager), 789 mSimRequiredNotifier, 790 new WifiScoreReport(mScoringParams, mClock, mWifiMetrics, wifiInfo, 791 mWifiNative, mWifiBlocklistMonitor, mWifiThreadRunner, mWifiScoreCard, 792 mDeviceConfigFacade, mContext, mAdaptiveConnectivityEnabledSettingObserver, 793 ifaceName, mExternalScoreUpdateObserverProxy, mSettingsStore, mWifiGlobals, 794 mActiveModeWarden, mWifiConnectivityManager, mWifiConfigManager), 795 mWifiP2pConnection, mWifiGlobals, ifaceName, clientModeManager, 796 mCmiMonitor, mBroadcastQueue, mWifiNetworkSelector, makeTelephonyManager(), 797 this, mSettingsConfigStore, verboseLoggingEnabled, mWifiNotificationManager); 798 } 799 makeWifiNetworkAgent( @onNull NetworkCapabilities nc, @NonNull LinkProperties linkProperties, @NonNull NetworkAgentConfig naConfig, @Nullable NetworkProvider provider, @NonNull WifiNetworkAgent.Callback callback)800 public WifiNetworkAgent makeWifiNetworkAgent( 801 @NonNull NetworkCapabilities nc, 802 @NonNull LinkProperties linkProperties, 803 @NonNull NetworkAgentConfig naConfig, 804 @Nullable NetworkProvider provider, 805 @NonNull WifiNetworkAgent.Callback callback) { 806 return new WifiNetworkAgent(mContext, mWifiHandlerThread.getLooper(), 807 nc, linkProperties, naConfig, provider, callback); 808 } 809 810 /** 811 * Create a ClientModeManager 812 * 813 * @param listener listener for ClientModeManager state changes 814 * @return a new instance of ClientModeManager 815 */ makeClientModeManager( @onNull ClientModeManager.Listener<ConcreteClientModeManager> listener, @NonNull WorkSource requestorWs, @NonNull ActiveModeManager.ClientRole role, boolean verboseLoggingEnabled)816 public ConcreteClientModeManager makeClientModeManager( 817 @NonNull ClientModeManager.Listener<ConcreteClientModeManager> listener, 818 @NonNull WorkSource requestorWs, 819 @NonNull ActiveModeManager.ClientRole role, 820 boolean verboseLoggingEnabled) { 821 return new ConcreteClientModeManager( 822 mContext, mWifiHandlerThread.getLooper(), mClock, 823 mWifiNative, listener, mWifiMetrics, mWakeupController, 824 this, mSelfRecovery, mWifiGlobals, mDefaultClientModeManager, 825 mClock.getElapsedSinceBootMillis(), requestorWs, role, mBroadcastQueue, 826 verboseLoggingEnabled); 827 } 828 makeScanOnlyModeImpl(@onNull String ifaceName)829 public ScanOnlyModeImpl makeScanOnlyModeImpl(@NonNull String ifaceName) { 830 return new ScanOnlyModeImpl(mClock.getElapsedSinceBootMillis(), mWifiNative, ifaceName); 831 } 832 833 /** 834 * Create a WifiLog instance. 835 * 836 * @param tag module name to include in all log messages 837 */ makeLog(String tag)838 public WifiLog makeLog(String tag) { 839 return new LogcatLog(tag); 840 } 841 842 /** 843 * Obtain an instance of WifiScanner. 844 * If it was not already created, then obtain an instance. Note, this must be done lazily since 845 * WifiScannerService is separate and created later. 846 */ getWifiScanner()847 public synchronized WifiScanner getWifiScanner() { 848 if (mWifiScanner == null) { 849 mWifiScanner = mContext.getSystemService(WifiScanner.class); 850 } 851 return mWifiScanner; 852 } 853 854 /** 855 * Construct an instance of {@link NetworkRequestStoreData}. 856 */ makeNetworkRequestStoreData( NetworkRequestStoreData.DataSource dataSource)857 public NetworkRequestStoreData makeNetworkRequestStoreData( 858 NetworkRequestStoreData.DataSource dataSource) { 859 return new NetworkRequestStoreData(dataSource); 860 } 861 862 /** 863 * Construct an instance of {@link NetworkSuggestionStoreData}. 864 */ makeNetworkSuggestionStoreData( NetworkSuggestionStoreData.DataSource dataSource)865 public NetworkSuggestionStoreData makeNetworkSuggestionStoreData( 866 NetworkSuggestionStoreData.DataSource dataSource) { 867 return new NetworkSuggestionStoreData(dataSource); 868 } 869 870 /** 871 * Construct an instance of {@link WifiCarrierInfoStoreManagerData} 872 */ makeWifiCarrierInfoStoreManagerData( WifiCarrierInfoStoreManagerData.DataSource dataSource)873 public WifiCarrierInfoStoreManagerData makeWifiCarrierInfoStoreManagerData( 874 WifiCarrierInfoStoreManagerData.DataSource dataSource) { 875 return new WifiCarrierInfoStoreManagerData(dataSource); 876 } 877 878 /** 879 * Construct an instance of {@link ImsiPrivacyProtectionExemptionStoreData} 880 */ makeImsiPrivacyProtectionExemptionStoreData( ImsiPrivacyProtectionExemptionStoreData.DataSource dataSource)881 public ImsiPrivacyProtectionExemptionStoreData makeImsiPrivacyProtectionExemptionStoreData( 882 ImsiPrivacyProtectionExemptionStoreData.DataSource dataSource) { 883 return new ImsiPrivacyProtectionExemptionStoreData(dataSource); 884 } 885 886 /** 887 * Construct an instance of {@link SoftApStoreData}. 888 */ makeSoftApStoreData( SoftApStoreData.DataSource dataSource)889 public SoftApStoreData makeSoftApStoreData( 890 SoftApStoreData.DataSource dataSource) { 891 return new SoftApStoreData(mContext, mSettingsMigrationDataHolder, dataSource); 892 } 893 getWifiPermissionsUtil()894 public WifiPermissionsUtil getWifiPermissionsUtil() { 895 return mWifiPermissionsUtil; 896 } 897 getWifiPermissionsWrapper()898 public WifiPermissionsWrapper getWifiPermissionsWrapper() { 899 return mWifiPermissionsWrapper; 900 } 901 902 /** 903 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 904 * 905 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 906 */ getWifiAwareHandlerThread()907 public HandlerThread getWifiAwareHandlerThread() { 908 if (mWifiAwareHandlerThread == null) { // lazy initialization 909 mWifiAwareHandlerThread = new HandlerThread("wifiAwareService"); 910 mWifiAwareHandlerThread.start(); 911 } 912 return mWifiAwareHandlerThread; 913 } 914 915 /** 916 * Returns a singleton instance of a HandlerThread for injection. Uses lazy initialization. 917 * 918 * TODO: share worker thread with other Wi-Fi handlers (b/27924886) 919 */ getRttHandlerThread()920 public HandlerThread getRttHandlerThread() { 921 if (mRttHandlerThread == null) { // lazy initialization 922 mRttHandlerThread = new HandlerThread("wifiRttService"); 923 mRttHandlerThread.start(); 924 } 925 return mRttHandlerThread; 926 } 927 getMacAddressUtil()928 public MacAddressUtil getMacAddressUtil() { 929 return mMacAddressUtil; 930 } 931 932 /** 933 * Returns a single instance of HalDeviceManager for injection. 934 */ getHalDeviceManager()935 public HalDeviceManager getHalDeviceManager() { 936 return mHalDeviceManager; 937 } 938 getWifiNative()939 public WifiNative getWifiNative() { 940 return mWifiNative; 941 } 942 getWifiMonitor()943 public WifiMonitor getWifiMonitor() { 944 return mWifiMonitor; 945 } 946 getWifiP2pNative()947 public WifiP2pNative getWifiP2pNative() { 948 return mWifiP2pNative; 949 } 950 951 /** 952 * Returns a single instance of CoexManager for injection. 953 * This will be null if SdkLevel is not at least S. 954 */ getCoexManager()955 @Nullable public CoexManager getCoexManager() { 956 return mCoexManager; 957 } 958 getWifiP2pMonitor()959 public WifiP2pMonitor getWifiP2pMonitor() { 960 return mWifiP2pMonitor; 961 } 962 getSelfRecovery()963 public SelfRecovery getSelfRecovery() { 964 return mSelfRecovery; 965 } 966 getScanRequestProxy()967 public ScanRequestProxy getScanRequestProxy() { 968 return mScanRequestProxy; 969 } 970 getJavaRuntime()971 public Runtime getJavaRuntime() { 972 return Runtime.getRuntime(); 973 } 974 getWifiDataStall()975 public WifiDataStall getWifiDataStall() { 976 return mWifiDataStall; 977 } 978 getWifiNetworkSuggestionsManager()979 public WifiNetworkSuggestionsManager getWifiNetworkSuggestionsManager() { 980 return mWifiNetworkSuggestionsManager; 981 } 982 getIpMemoryStore()983 public IpMemoryStore getIpMemoryStore() { 984 if (mIpMemoryStore == null) { 985 mIpMemoryStore = IpMemoryStore.getMemoryStore(mContext); 986 } 987 return mIpMemoryStore; 988 } 989 getWifiBlocklistMonitor()990 public WifiBlocklistMonitor getWifiBlocklistMonitor() { 991 return mWifiBlocklistMonitor; 992 } 993 getHostapdHal()994 public HostapdHal getHostapdHal() { 995 return mHostapdHal; 996 } 997 getWifiThreadRunner()998 public WifiThreadRunner getWifiThreadRunner() { 999 return mWifiThreadRunner; 1000 } 1001 makeNetdWrapper()1002 public NetdWrapper makeNetdWrapper() { 1003 if (mNetdWrapper == null) { 1004 mNetdWrapper = new NetdWrapper(mContext, new Handler(mWifiHandlerThread.getLooper())); 1005 } 1006 return mNetdWrapper; 1007 } 1008 getWifiCondManager()1009 public WifiNl80211Manager getWifiCondManager() { 1010 return mWifiCondManager; 1011 } 1012 getWifiHealthMonitor()1013 public WifiHealthMonitor getWifiHealthMonitor() { 1014 return mWifiHealthMonitor; 1015 } 1016 getSettingsConfigStore()1017 public WifiSettingsConfigStore getSettingsConfigStore() { 1018 return mSettingsConfigStore; 1019 } 1020 1021 public WifiScanAlwaysAvailableSettingsCompatibility getWifiScanAlwaysAvailableSettingsCompatibility()1022 getWifiScanAlwaysAvailableSettingsCompatibility() { 1023 return mWifiScanAlwaysAvailableSettingsCompatibility; 1024 } 1025 getDeviceConfigFacade()1026 public DeviceConfigFacade getDeviceConfigFacade() { 1027 return mDeviceConfigFacade; 1028 } 1029 getWifiConnectivityManager()1030 public WifiConnectivityManager getWifiConnectivityManager() { 1031 return mWifiConnectivityManager; 1032 } 1033 getConnectHelper()1034 public ConnectHelper getConnectHelper() { 1035 return mConnectHelper; 1036 } 1037 getWifiNetworkFactory()1038 public WifiNetworkFactory getWifiNetworkFactory() { 1039 return mWifiNetworkFactory; 1040 } 1041 getUntrustedWifiNetworkFactory()1042 public UntrustedWifiNetworkFactory getUntrustedWifiNetworkFactory() { 1043 return mUntrustedWifiNetworkFactory; 1044 } 1045 getOemWifiNetworkFactory()1046 public OemWifiNetworkFactory getOemWifiNetworkFactory() { 1047 return mOemWifiNetworkFactory; 1048 } 1049 getRestrictedWifiNetworkFactory()1050 public RestrictedWifiNetworkFactory getRestrictedWifiNetworkFactory() { 1051 return mRestrictedWifiNetworkFactory; 1052 } 1053 getMultiInternetWifiNetworkFactory()1054 public MultiInternetWifiNetworkFactory getMultiInternetWifiNetworkFactory() { 1055 return mMultiInternetWifiNetworkFactory; 1056 } 1057 getWifiDiagnostics()1058 public WifiDiagnostics getWifiDiagnostics() { 1059 return mWifiDiagnostics; 1060 } 1061 getWifiP2pConnection()1062 public WifiP2pConnection getWifiP2pConnection() { 1063 return mWifiP2pConnection; 1064 } 1065 getWifiGlobals()1066 public WifiGlobals getWifiGlobals() { 1067 return mWifiGlobals; 1068 } 1069 getSimRequiredNotifier()1070 public SimRequiredNotifier getSimRequiredNotifier() { 1071 return mSimRequiredNotifier; 1072 } 1073 1074 /** 1075 * Useful for mocking {@link WorkSourceHelper} instance in {@link HalDeviceManager} unit tests. 1076 */ makeWsHelper(@onNull WorkSource ws)1077 public WorkSourceHelper makeWsHelper(@NonNull WorkSource ws) { 1078 return new WorkSourceHelper(ws, mWifiPermissionsUtil, 1079 mContext.getSystemService(ActivityManager.class), mContext.getPackageManager(), 1080 mContext.getResources()); 1081 } 1082 1083 public AdaptiveConnectivityEnabledSettingObserver getAdaptiveConnectivityEnabledSettingObserver()1084 getAdaptiveConnectivityEnabledSettingObserver() { 1085 return mAdaptiveConnectivityEnabledSettingObserver; 1086 } 1087 1088 /** 1089 * Creates a BroadcastOptions. 1090 */ makeBroadcastOptions()1091 public BroadcastOptions makeBroadcastOptions() { 1092 return BroadcastOptions.makeBasic(); 1093 } 1094 getMakeBeforeBreakManager()1095 public MakeBeforeBreakManager getMakeBeforeBreakManager() { 1096 return mMakeBeforeBreakManager; 1097 } 1098 getOpenNetworkNotifier()1099 public OpenNetworkNotifier getOpenNetworkNotifier() { 1100 return mOpenNetworkNotifier; 1101 } 1102 getWifiNotificationManager()1103 public WifiNotificationManager getWifiNotificationManager() { 1104 return mWifiNotificationManager; 1105 } 1106 getInterfaceConflictManager()1107 public InterfaceConflictManager getInterfaceConflictManager() { 1108 return mInterfaceConflictManager; 1109 } 1110 getLastCallerInfoManager()1111 public LastCallerInfoManager getLastCallerInfoManager() { 1112 return mLastCallerInfoManager; 1113 } 1114 1115 @NonNull getWifiDialogManager()1116 public WifiDialogManager getWifiDialogManager() { 1117 return mWifiDialogManager; 1118 } 1119 getBuildProperties()1120 public BuildProperties getBuildProperties() { 1121 return mBuildProperties; 1122 } 1123 getDefaultClientModeManager()1124 public DefaultClientModeManager getDefaultClientModeManager() { 1125 return mDefaultClientModeManager; 1126 } 1127 getLinkProbeManager()1128 public LinkProbeManager getLinkProbeManager() { 1129 return mLinkProbeManager; 1130 } 1131 getMultiInternetManager()1132 public MultiInternetManager getMultiInternetManager() { 1133 return mMultiInternetManager; 1134 } 1135 getContext()1136 public WifiContext getContext() { 1137 return mContext; 1138 } 1139 1140 /** 1141 * Creates a BufferedReader for the given filename. Useful for unit tests that depend on IO. 1142 */ 1143 @NonNull createBufferedReader(String filename)1144 public BufferedReader createBufferedReader(String filename) throws FileNotFoundException { 1145 return new BufferedReader(new FileReader(filename)); 1146 } 1147 1148 @NonNull getWifiKeyStore()1149 public WifiKeyStore getWifiKeyStore() { 1150 return mWifiKeyStore; 1151 } 1152 } 1153