• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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