WifiContext、WifiInjector、WifiServiceImpl作用（2）

紧跟上篇文章讲解 WifiContext、WifiInjector、WifiServiceImpl主要做了什么

public WifiService(Context contextBase) {
    super(contextBase);
    mWifiContext = new WifiContext(contextBase);
    WifiInjector injector = new WifiInjector(mWifiContext);
    mImpl = new WifiServiceImpl(mWifiContext, injector);
}

WifiContext
先看看WifiContext里面的实现
这里没做什么，只是调用父类。WifiContext主要是获取资源、上下文

public WifiContext(@NonNull Context contextBase) {
    super(contextBase);
}

WifiInjector
WifiInjector里面new 的操作就多了，主要是负责初始化WiFi、P2P、SoftAp里面的内容

public WifiInjector(WifiContext context) {
    if (context == null) {
        throw new IllegalStateException(
            "WifiInjector should not be initialized with a null Context.");
    }

    if (sWifiInjector != null) {
        throw new IllegalStateException(
            "WifiInjector was already created, use getInstance instead.");
    }

    sWifiInjector = this;
    mLastCallerInfoManager = new LastCallerInfoManager();
    mContext = context;

    // Now create and start handler threads
    //这里创建线程并 start
    mWifiHandlerThread = new HandlerThread("WifiHandlerThread");
    mWifiHandlerThread.start();
    Looper wifiLooper = mWifiHandlerThread.getLooper();
    mWifiHandlerLocalLog = new LocalLog(1024);
    WifiAwareMetrics awareMetrics = new WifiAwareMetrics(mClock);
    RttMetrics rttMetrics = new RttMetrics(mClock);
    mDppMetrics = new DppMetrics();
    //WifiMonitor() 主要是接收底层事件来处理
    mWifiMonitor = new WifiMonitor();
    mBatteryStats = context.getSystemService(BatteryStatsManager.class);
    /**
     * Provides storage for wireless connectivity P2p metrics, as they are generated.
     * Metrics logged by this class include:
     *   Aggregated connection stats (num of connections, num of failures, ...)
     *   Discrete connection event stats (time, duration, failure codes, ...)
     */
    mWifiP2pMetrics = new WifiP2pMetrics(mClock, mContext);
    mWifiMetrics = new WifiMetrics(mContext, mFrameworkFacade, mClock, wifiLooper,
            awareMetrics, rttMetrics, new WifiPowerMetrics(mBatteryStats), mWifiP2pMetrics,
          mDppMetrics, mWifiMonitor);
    RunnerHandler wifiHandler = new RunnerHandler(wifiLooper, context.getResources().getInteger(
            R.integer.config_wifiConfigurationWifiRunnerThresholdInMs),
          mWifiHandlerLocalLog, mWifiMetrics);
    mWifiDiagnosticsHandlerThread = new HandlerThread("WifiDiagnostics");
    mWifiDiagnosticsHandlerThread.start();


    mWifiNotificationManager = new WifiNotificationManager(mContext);
    mWifiGlobals = new WifiGlobals(mContext);
    mScoringParams = new ScoringParams(mContext);
    mWifiChannelUtilizationScan = new WifiChannelUtilization(mClock, mContext);
    mSettingsMigrationDataHolder = new SettingsMigrationDataHolder(mContext);
    mConnectionFailureNotificationBuilder = new ConnectionFailureNotificationBuilder(
         mContext, mFrameworkFacade);

    mWifiPermissionsWrapper = new WifiPermissionsWrapper(mContext);
    mUserManager = mContext.getSystemService(UserManager.class);
    mWifiPermissionsUtil = new WifiPermissionsUtil(mWifiPermissionsWrapper, mContext,
        mUserManager, this);
    mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil);
    mSoftApBackupRestore = new SoftApBackupRestore(mContext, mSettingsMigrationDataHolder);
    mWifiStateTracker = new WifiStateTracker(mBatteryStats);
    mWifiThreadRunner = new WifiThreadRunner(wifiHandler);
    /**
     * Class to manage launching dialogs and returning the user reply.
     * All methods run on the main Wi-Fi thread runner except those annotated with @AnyThread, which can
     * run on any thread.
     */
    mWifiDialogManager = new WifiDialogManager(mContext, mWifiThreadRunner, mFrameworkFacade);
    mSsidTranslator = new SsidTranslator(mContext, wifiHandler);
    //这里是给P2P启动一个线程
    mWifiP2pServiceHandlerThread = new HandlerThread("WifiP2pService");
    mWifiP2pServiceHandlerThread.start();
    mPasspointProvisionerHandlerThread =
         new HandlerThread("PasspointProvisionerHandlerThread");
    mPasspointProvisionerHandlerThread.start();
    mDeviceConfigFacade = new DeviceConfigFacade(mContext, wifiHandler, mWifiMetrics);
    mAdaptiveConnectivityEnabledSettingObserver =
            new AdaptiveConnectivityEnabledSettingObserver(wifiHandler, mWifiMetrics,
                mFrameworkFacade, mContext);
    // Modules interacting with Native.
    mHalDeviceManager = new HalDeviceManager(mContext, mClock, this, wifiHandler);
    mInterfaceConflictManager = new InterfaceConflictManager(this, mContext, mFrameworkFacade,
            mHalDeviceManager, mWifiThreadRunner, mWifiDialogManager, new LocalLog(
                mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? 128 : 256));
        mWifiVendorHal = new WifiVendorHal(mContext, mHalDeviceManager, wifiHandler, mWifiGlobals,
            mSsidTranslator);
    //SupplicantStaIfaceHal  这里是初始化Supplicant
    mSupplicantStaIfaceHal = new SupplicantStaIfaceHal(
        mContext, mWifiMonitor, mFrameworkFacade, wifiHandler, mClock, mWifiMetrics,
            mWifiGlobals, mSsidTranslator, this);
    mHostapdHal = new HostapdHal(mContext, wifiHandler);
    //启动WifiNl80211Manager
    mWifiCondManager = (WifiNl80211Manager) mContext.getSystemService(
        Context.WIFI_NL80211_SERVICE);
    /**
    * Native calls for bring up/shut down of the supplicant daemon and for
    * sending requests to the supplicant daemon
    */
    mWifiNative = new WifiNative(
        mWifiVendorHal, mSupplicantStaIfaceHal, mHostapdHal, mWifiCondManager,
        mWifiMonitor, mPropertyService, mWifiMetrics,
        wifiHandler, new Random(), mBuildProperties, this);
    /**
    * Listens for events from the wpa_supplicant, and passes them on
    * to the {@link WifiP2pServiceImpl} for handling.
    */
    mWifiP2pMonitor = new WifiP2pMonitor();
    mSupplicantP2pIfaceHal = new SupplicantP2pIfaceHal(mWifiP2pMonitor, mWifiGlobals, this);
    mWifiP2pNative = new WifiP2pNative(mWifiCondManager, mWifiNative, mWifiMetrics,
        mWifiVendorHal, mSupplicantP2pIfaceHal, mHalDeviceManager, mPropertyService);
    SubscriptionManager subscriptionManager =
        mContext.getSystemService(SubscriptionManager.class);
    if (SdkLevel.isAtLeastS()) {
        mCoexManager = new CoexManager(mContext, mWifiNative, makeTelephonyManager(),
        subscriptionManager, mContext.getSystemService(CarrierConfigManager.class),
        wifiHandler);
    } else {
        mCoexManager = null;
    }

    // Now get instances of all the objects that depend on the HandlerThreads
    mWifiTrafficPoller = new WifiTrafficPoller(mContext);
    // WifiConfigManager/Store objects and their dependencies.
    KeyStore keyStore = null;
    try {
        keyStore = AndroidKeyStoreProvider.getKeyStoreForUid(Process.WIFI_UID);
    } catch (KeyStoreException | NoSuchProviderException e) {
        Log.wtf(TAG, "Failed to load keystore", e);
    }
    mKeyStore = keyStore;
    mWifiKeyStore = new WifiKeyStore(mContext, mKeyStore, mFrameworkFacade);
    // New config store
    mWifiConfigStore = new WifiConfigStore(mContext, wifiHandler, mClock, mWifiMetrics,
        WifiConfigStore.createSharedFiles(mFrameworkFacade.isNiapModeOn(mContext)));
    mWifiPseudonymManager = new WifiPseudonymManager(
        mContext, this, mClock, wifiLooper);
    mWifiCarrierInfoManager = new WifiCarrierInfoManager(makeTelephonyManager(),
        subscriptionManager, this, mFrameworkFacade, mContext,
        mWifiConfigStore, wifiHandler, mWifiMetrics, mClock, mWifiPseudonymManager);
    String l2KeySeed = Secure.getString(mContext.getContentResolver(), Secure.ANDROID_ID);
    mWifiScoreCard = new WifiScoreCard(mClock, l2KeySeed, mDeviceConfigFacade,
        mContext, mWifiGlobals);
    mWifiMetrics.setWifiScoreCard(mWifiScoreCard);
    mLruConnectionTracker = new LruConnectionTracker(MAX_RECENTLY_CONNECTED_NETWORK,
        mContext);
    mWifiConnectivityHelper = new WifiConnectivityHelper(this);
    int maxLinesLowRam = mContext.getResources().getInteger(
        R.integer.config_wifiConnectivityLocalLogMaxLinesLowRam);
    int maxLinesHighRam = mContext.getResources().getInteger(
        R.integer.config_wifiConnectivityLocalLogMaxLinesHighRam);
    mConnectivityLocalLog = new LocalLog(
        mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? maxLinesLowRam
            : maxLinesHighRam);
    mWifiAwareLocalLog = new LocalLog(
        mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? maxLinesLowRam
            : maxLinesHighRam);
    mWifiDiagnostics = new WifiDiagnostics(
        mContext, this, mWifiNative, mBuildProperties,
            new LastMileLogger(this), mClock, mWifiDiagnosticsHandlerThread.getLooper());
    mWifiLastResortWatchdog = new WifiLastResortWatchdog(this, mContext, mClock,
        mWifiMetrics, mWifiDiagnostics, wifiLooper,
            mDeviceConfigFacade, mWifiThreadRunner, mWifiMonitor);
    mWifiBlocklistMonitor = new WifiBlocklistMonitor(mContext, mWifiConnectivityHelper,
        mWifiLastResortWatchdog, mClock, new LocalLog(
        mContext.getSystemService(ActivityManager.class).isLowRamDevice() ? 128 : 256),
        mWifiScoreCard, mScoringParams, mWifiMetrics, mWifiPermissionsUtil);
    mWifiMetrics.setWifiBlocklistMonitor(mWifiBlocklistMonitor);
    // Config Manager
    /**
    * This class provides the APIs to manage configured Wi-Fi networks.
    * It deals with the following:
    * - Maintaining a list of configured networks for quick access.
    * - Persisting the configurations to store when required.
    * - Supporting WifiManager Public API calls:
    *   > addOrUpdateNetwork()
    *   > removeNetwork()
    *   > enableNetwork()
    *   > disableNetwork()
    * - Handle user switching on multi-user devices.
    *
    * All network configurations retrieved from this class are copies of the original configuration
    * stored in the internal database. So, any updates to the retrieved configuration object are
    * meaningless and will not be reflected in the original database.
    * This is done on purpose to ensure that only WifiConfigManager can modify configurations stored
    * in the internal database. Any configuration updates should be triggered with appropriate helper
    * methods of this class using the configuration's unique networkId.
    *
    * NOTE: These API's are not thread safe and should only be used from the main Wifi thread.
    */
    mWifiConfigManager = new WifiConfigManager(mContext, mWifiKeyStore, mWifiConfigStore,
        new NetworkListSharedStoreData(mContext),
        new NetworkListUserStoreData(mContext),
        new RandomizedMacStoreData(),
        mLruConnectionTracker, this);
    mSettingsConfigStore = new WifiSettingsConfigStore(context, wifiHandler,
    mSettingsMigrationDataHolder, mWifiConfigManager, mWifiConfigStore);
    mSettingsStore = new WifiSettingsStore(mContext, mSettingsConfigStore, mWifiThreadRunner,
        mFrameworkFacade, mWifiNotificationManager, mDeviceConfigFacade,
        mWifiMetrics, mClock);
    mWifiMetrics.setWifiConfigManager(mWifiConfigManager);
    mWifiMetrics.setWifiSettingsStore(mSettingsStore);

    mWifiMetrics.setScoringParams(mScoringParams);
    mThroughputPredictor = new ThroughputPredictor(mContext);
    mScanRequestProxy = new ScanRequestProxy(mContext,
        mContext.getSystemService(AppOpsManager.class),
        mContext.getSystemService(ActivityManager.class),
        this, mWifiConfigManager,
        mWifiPermissionsUtil, mWifiMetrics, mClock, wifiHandler, mSettingsConfigStore);
    mWifiBlocklistMonitor.setScanRequestProxy(mScanRequestProxy);
    //这里就是sar 相关的初始化
    mSarManager = new SarManager(mContext, makeTelephonyManager(), wifiLooper,
        mWifiNative);
    mWifiNetworkSelector = new WifiNetworkSelector(mContext, mWifiScoreCard, mScoringParams,
        mWifiConfigManager, mClock, mConnectivityLocalLog, mWifiMetrics, this,
        mThroughputPredictor, mWifiChannelUtilizationScan, mWifiGlobals,
        mScanRequestProxy, mWifiNative);
    CompatibilityScorer compatibilityScorer = new CompatibilityScorer(mScoringParams);
    mWifiNetworkSelector.registerCandidateScorer(compatibilityScorer);
    ScoreCardBasedScorer scoreCardBasedScorer = new ScoreCardBasedScorer(mScoringParams);
    mWifiNetworkSelector.registerCandidateScorer(scoreCardBasedScorer);
    BubbleFunScorer bubbleFunScorer = new BubbleFunScorer(mScoringParams);
    mWifiNetworkSelector.registerCandidateScorer(bubbleFunScorer);
    mThroughputScorer = new ThroughputScorer(mContext, mScoringParams);
    mWifiNetworkSelector.registerCandidateScorer(mThroughputScorer);
    mWifiMetrics.setWifiNetworkSelector(mWifiNetworkSelector);
    mWifiNetworkSuggestionsManager = new WifiNetworkSuggestionsManager(mContext, wifiHandler,
        this, mWifiPermissionsUtil, mWifiConfigManager, mWifiConfigStore, mWifiMetrics,
        mWifiCarrierInfoManager, mWifiKeyStore, mLruConnectionTracker,
        mClock);
    mPasspointManager = new PasspointManager(mContext, this,
        wifiHandler, mWifiNative, mWifiKeyStore, mClock, new PasspointObjectFactory(),
        mWifiConfigManager, mWifiConfigStore, mSettingsStore, mWifiMetrics,
        mWifiCarrierInfoManager, mMacAddressUtil, mWifiPermissionsUtil);
    PasspointNetworkNominateHelper nominateHelper =
        new PasspointNetworkNominateHelper(mPasspointManager, mWifiConfigManager,
        mConnectivityLocalLog, mWifiCarrierInfoManager, mContext.getResources(),
        mClock);
    mPasspointManager.setPasspointNetworkNominateHelper(nominateHelper);
    mSavedNetworkNominator = new SavedNetworkNominator(
        mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager,
        mWifiPseudonymManager, mWifiPermissionsUtil, mWifiNetworkSuggestionsManager);
    mNetworkSuggestionNominator = new NetworkSuggestionNominator(mWifiNetworkSuggestionsManager,
        mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager,
        mWifiPseudonymManager, mWifiMetrics);

    mWifiMetrics.setPasspointManager(mPasspointManager);
    WifiChannelUtilization wifiChannelUtilizationConnected =
        new WifiChannelUtilization(mClock, mContext);
    mWifiMetrics.setWifiChannelUtilization(wifiChannelUtilizationConnected);
    mLinkProbeManager = new LinkProbeManager(mClock, mWifiNative, mWifiMetrics,
        mFrameworkFacade, wifiHandler, mContext);
    mDefaultClientModeManager = new DefaultClientModeManager();
    mExternalScoreUpdateObserverProxy =
        new ExternalScoreUpdateObserverProxy(mWifiThreadRunner);
    mDppManager = new DppManager(this, wifiHandler, mWifiNative,
        mWifiConfigManager, mContext, mDppMetrics, mScanRequestProxy, mWifiPermissionsUtil);
    // This class provides the implementation for different WiFi operating modes.
    mActiveModeWarden = new ActiveModeWarden(this, wifiLooper,
        mWifiNative, mDefaultClientModeManager, mBatteryStats, mWifiDiagnostics,
        mContext, mSettingsStore, mFrameworkFacade, mWifiPermissionsUtil, mWifiMetrics,
        mExternalScoreUpdateObserverProxy, mDppManager);
    mWifiMetrics.setActiveModeWarden(mActiveModeWarden);
    mWifiHealthMonitor = new WifiHealthMonitor(mContext, this, mClock, mWifiConfigManager,
        mWifiScoreCard, wifiHandler, mWifiNative, l2KeySeed, mDeviceConfigFacade,
        mActiveModeWarden);
    mWifiDataStall = new WifiDataStall(mWifiMetrics, mContext,
        mDeviceConfigFacade, wifiChannelUtilizationConnected, mClock, wifiHandler,
        mThroughputPredictor, mActiveModeWarden, mCmiMonitor, mWifiGlobals);
    mWifiMetrics.setWifiDataStall(mWifiDataStall);
    mWifiMetrics.setWifiHealthMonitor(mWifiHealthMonitor);
    mWifiP2pConnection = new WifiP2pConnection(mContext, wifiLooper, mActiveModeWarden);
    mConnectHelper = new ConnectHelper(mActiveModeWarden, mWifiConfigManager);
    mBroadcastQueue = new ClientModeManagerBroadcastQueue(mActiveModeWarden, mContext);
    mMakeBeforeBreakManager = new MakeBeforeBreakManager(mActiveModeWarden, mFrameworkFacade,
        mContext, mCmiMonitor, mBroadcastQueue, mWifiMetrics);
    mOpenNetworkNotifier = new OpenNetworkNotifier(mContext,
        wifiLooper, mFrameworkFacade, mClock, mWifiMetrics,
        mWifiConfigManager, mWifiConfigStore, mConnectHelper,
        new ConnectToNetworkNotificationBuilder(mContext, mFrameworkFacade),
        mMakeBeforeBreakManager, mWifiNotificationManager, mWifiPermissionsUtil);
    mMultiInternetManager = new MultiInternetManager(mActiveModeWarden, mFrameworkFacade,
        mContext, mCmiMonitor, mSettingsStore, wifiHandler, mClock);
    mExternalPnoScanRequestManager = new ExternalPnoScanRequestManager(wifiHandler, mContext);
    mCountryCode = new WifiCountryCode(mContext, mActiveModeWarden, mWifiP2pMetrics,
        mCmiMonitor, mWifiNative, mSettingsConfigStore, mClock, mWifiPermissionsUtil);
   /**
    * This class manages all the connectivity related scanning activities.
    *
    * When the screen is turned on or off, WiFi is connected or disconnected,
    * or on-demand, a scan is initiatiated and the scan results are passed
    * to WifiNetworkSelector for it to make a recommendation on which network
    * to connect to.
    */
    mWifiConnectivityManager = new WifiConnectivityManager(
        mContext, mScoringParams, mWifiConfigManager,
        mWifiNetworkSuggestionsManager, mWifiNetworkSelector,
        mWifiConnectivityHelper, mWifiLastResortWatchdog, mOpenNetworkNotifier,
        mWifiMetrics, wifiHandler,
        mClock, mConnectivityLocalLog, mWifiScoreCard, mWifiBlocklistMonitor,
        mWifiChannelUtilizationScan, mPasspointManager, mMultiInternetManager,
        mDeviceConfigFacade, mActiveModeWarden, mFrameworkFacade, mWifiGlobals,
        mExternalPnoScanRequestManager, mSsidTranslator, mWifiPermissionsUtil,
        mWifiCarrierInfoManager, mCountryCode, mWifiDialogManager);
    mMboOceController = new MboOceController(makeTelephonyManager(), mActiveModeWarden,
        mWifiThreadRunner);
    mConnectionFailureNotifier = new ConnectionFailureNotifier(
        mContext, mFrameworkFacade, mWifiConfigManager,
        mWifiConnectivityManager, wifiHandler,
        mWifiNotificationManager, mConnectionFailureNotificationBuilder,
        mWifiDialogManager);
    mWifiNetworkFactory = new WifiNetworkFactory(
        wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER,
        (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE),
        (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE),
        (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE),
        mClock, this, mWifiConnectivityManager, mWifiConfigManager,
        mWifiConfigStore, mWifiPermissionsUtil, mWifiMetrics, mWifiNative,
        mActiveModeWarden, mConnectHelper, mCmiMonitor, mFrameworkFacade,
        mMultiInternetManager);
    // We can't filter untrusted network in the capabilities filter because a trusted
    // network would still satisfy a request that accepts untrusted ones.
    // We need a second network factory for untrusted network requests because we need a
    // different score filter for these requests.
    mUntrustedWifiNetworkFactory = new UntrustedWifiNetworkFactory(
        wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER,
        mWifiConnectivityManager);
    mOemWifiNetworkFactory = new OemWifiNetworkFactory(
        wifiLooper, mContext, OEM_NETWORK_CAPABILITIES_FILTER,
        mWifiConnectivityManager);
    mRestrictedWifiNetworkFactory = new RestrictedWifiNetworkFactory(
        wifiLooper, mContext, RESTRICTED_NETWORK_CAPABILITIES_FILTER,
        mWifiConnectivityManager);
    mMultiInternetWifiNetworkFactory = new MultiInternetWifiNetworkFactory(
        wifiLooper, mContext, REGULAR_NETWORK_CAPABILITIES_FILTER,
        mFrameworkFacade, mContext.getSystemService(AlarmManager.class),
        mWifiPermissionsUtil, mMultiInternetManager, mWifiConnectivityManager,
        mConnectivityLocalLog);
    mWifiScanAlwaysAvailableSettingsCompatibility =
        new WifiScanAlwaysAvailableSettingsCompatibility(mContext, wifiHandler,
        mSettingsStore, mActiveModeWarden, mFrameworkFacade);
    mWifiApConfigStore = new WifiApConfigStore(
        mContext, this, wifiHandler, mBackupManagerProxy,
        mWifiConfigStore, mWifiConfigManager, mActiveModeWarden, mWifiMetrics);
    WakeupNotificationFactory wakeupNotificationFactory =
        new WakeupNotificationFactory(mContext, mFrameworkFacade);
    WakeupOnboarding wakeupOnboarding = new WakeupOnboarding(mContext, mWifiConfigManager,
        wifiHandler, mFrameworkFacade, wakeupNotificationFactory, mWifiNotificationManager);
    mWakeupController = new WakeupController(mContext, wifiHandler,
        new WakeupLock(mWifiConfigManager, mWifiMetrics.getWakeupMetrics(), mClock),
        new WakeupEvaluator(mScoringParams), wakeupOnboarding, mWifiConfigManager,
        mWifiConfigStore, mWifiNetworkSuggestionsManager, mWifiMetrics.getWakeupMetrics(),
        this, mFrameworkFacade, mClock, mActiveModeWarden);
    mLockManager = new WifiLockManager(mContext, mBatteryStats, mActiveModeWarden,
        mFrameworkFacade, wifiHandler, mClock, mWifiMetrics, mDeviceConfigFacade,
        mWifiPermissionsUtil);
    mSelfRecovery = new SelfRecovery(mContext, mActiveModeWarden, mClock, mWifiNative,
        mWifiGlobals);
    mWifiMulticastLockManager = new WifiMulticastLockManager(mActiveModeWarden, mBatteryStats,
        wifiLooper);
    mApplicationQosPolicyRequestHandler = new ApplicationQosPolicyRequestHandler(
        mActiveModeWarden, mWifiNative, mWifiHandlerThread, mDeviceConfigFacade, mContext);
    // Register the various network Nominators with the network selector.
    mWifiNetworkSelector.registerNetworkNominator(mSavedNetworkNominator);
    mWifiNetworkSelector.registerNetworkNominator(mNetworkSuggestionNominator);
    mSimRequiredNotifier = new SimRequiredNotifier(mContext, mFrameworkFacade,
        mWifiNotificationManager);
    mWifiPulledAtomLogger = new WifiPulledAtomLogger(
        mContext.getSystemService(StatsManager.class), wifiHandler,
        mContext);
}

WifiServiceImpl
WifiServiceImpl可以看到很多都是从wifiInjector里面获取参数。而WifiServiceImpl是WifiManager接口的具体实现。

public WifiServiceImpl(WifiContext context, WifiInjector wifiInjector) {
    mContext = context;
    mWifiInjector = wifiInjector;
    mClock = wifiInjector.getClock();

    mFacade = mWifiInjector.getFrameworkFacade();
    mWifiMetrics = mWifiInjector.getWifiMetrics();
    mWifiTrafficPoller = mWifiInjector.getWifiTrafficPoller();
    mUserManager = mWifiInjector.getUserManager();
    mCountryCode = mWifiInjector.getWifiCountryCode();
    mActiveModeWarden = mWifiInjector.getActiveModeWarden();
    mScanRequestProxy = mWifiInjector.getScanRequestProxy();
    mSettingsStore = mWifiInjector.getWifiSettingsStore();
    mPowerManager = mContext.getSystemService(PowerManager.class);
    mAppOps = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
    mWifiLockManager = mWifiInjector.getWifiLockManager();
    mWifiMulticastLockManager = mWifiInjector.getWifiMulticastLockManager();
    mWifiBackupRestore = mWifiInjector.getWifiBackupRestore();
    mSoftApBackupRestore = mWifiInjector.getSoftApBackupRestore();
    mWifiApConfigStore = mWifiInjector.getWifiApConfigStore();
    mWifiPermissionsUtil = mWifiInjector.getWifiPermissionsUtil();
    mLog = mWifiInjector.makeLog(TAG);
    mFrameworkFacade = wifiInjector.getFrameworkFacade();
    mTetheredSoftApTracker = new TetheredSoftApTracker();
    mActiveModeWarden.registerSoftApCallback(mTetheredSoftApTracker);
    mLohsSoftApTracker = new LohsSoftApTracker();
    mActiveModeWarden.registerLohsCallback(mLohsSoftApTracker);
    mWifiNetworkSuggestionsManager = mWifiInjector.getWifiNetworkSuggestionsManager();
    mWifiNetworkFactory = mWifiInjector.getWifiNetworkFactory();
    mDppManager = mWifiInjector.getDppManager();
    mWifiThreadRunner = mWifiInjector.getWifiThreadRunner();
    mWifiHandlerThread = mWifiInjector.getWifiHandlerThread();
    mWifiConfigManager = mWifiInjector.getWifiConfigManager();
    mHalDeviceManager = mWifiInjector.getHalDeviceManager();
    mWifiBlocklistMonitor = mWifiInjector.getWifiBlocklistMonitor();
    mPasspointManager = mWifiInjector.getPasspointManager();
    mWifiScoreCard = mWifiInjector.getWifiScoreCard();
    mWifiHealthMonitor = wifiInjector.getWifiHealthMonitor();
    mMemoryStoreImpl = new MemoryStoreImpl(mContext, mWifiInjector,
        mWifiScoreCard,  mWifiHealthMonitor);
    mWifiConnectivityManager = wifiInjector.getWifiConnectivityManager();
    mWifiDataStall = wifiInjector.getWifiDataStall();
    mWifiNative = wifiInjector.getWifiNative();
    mCoexManager = wifiInjector.getCoexManager();
    mConnectHelper = wifiInjector.getConnectHelper();
    mWifiGlobals = wifiInjector.getWifiGlobals();
    mSimRequiredNotifier = wifiInjector.getSimRequiredNotifier();
    mWifiCarrierInfoManager = wifiInjector.getWifiCarrierInfoManager();
    mWifiPseudonymManager = wifiInjector.getWifiPseudonymManager();
    mMakeBeforeBreakManager = mWifiInjector.getMakeBeforeBreakManager();
    mLastCallerInfoManager = mWifiInjector.getLastCallerInfoManager();
    mWifiDialogManager = mWifiInjector.getWifiDialogManager();
    mBuildProperties = mWifiInjector.getBuildProperties();
    mDefaultClientModeManager = mWifiInjector.getDefaultClientModeManager();
    mCountryCodeTracker = new CountryCodeTracker();
    mWifiTetheringDisallowed = false;
    mMultiInternetManager = mWifiInjector.getMultiInternetManager();
    mDeviceConfigFacade = mWifiInjector.getDeviceConfigFacade();
    mApplicationQosPolicyRequestHandler = mWifiInjector.getApplicationQosPolicyRequestHandler();
    mWifiPulledAtomLogger = mWifiInjector.getWifiPulledAtomLogger();
}

这里就结束了