android13#settings#internet

86 阅读10分钟

1.简介

简单看下Internet页面相关的数据相关

  • settings 》Network&internet 》Internet
  • 或者下拉快捷方式Internet图标长按
  • 页面图片参考1.1

关于 WiFi Channels & Frequency Bands

Wireless - Wi-Fi 5 GHz frequency band and channels

1.1.图片

>1.关闭wifi

image.png

>2.打开wifi

image.png

2.NetworkProviderSettings

2.1.onCreate

    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        mAirplaneModeEnabler = new AirplaneModeEnabler(getContext(), this);

        setAnimationAllowed(false);

        addPreferences();//补充1

        mIsRestricted = isUiRestricted();
        mIsAdmin = isAdminUser();
    }

>1.addPreferences

    private void addPreferences() {
        addPreferencesFromResource(R.xml.network_provider_settings);//补充2

        mAirplaneModeMsgPreference = findPreference(PREF_KEY_AIRPLANE_MODE_MSG);
        //飞行模式打开与否决定这个选项是否可见
        updateAirplaneModeMsgPreference(mAirplaneModeEnabler.isAirplaneModeOn() /* visible */);
        mConnectedWifiEntryPreferenceCategory = findPreference(PREF_KEY_CONNECTED_ACCESS_POINTS);
        mFirstWifiEntryPreferenceCategory = findPreference(PREF_KEY_FIRST_ACCESS_POINTS);
        mWifiEntryPreferenceCategory = findPreference(PREF_KEY_ACCESS_POINTS);
        mConfigureWifiSettingsPreference = findPreference(PREF_KEY_CONFIGURE_NETWORK_SETTINGS);
        mSavedNetworksPreference = findPreference(PREF_KEY_SAVED_NETWORKS);
        mAddWifiNetworkPreference = new AddWifiNetworkPreference(getPrefContext());
        //已使用的流量
        mDataUsagePreference = findPreference(PREF_KEY_DATA_USAGE);
        mDataUsagePreference.setVisible(DataUsageUtils.hasWifiRadio(getContext()));
        mDataUsagePreference.setTemplate(new NetworkTemplate.Builder(NetworkTemplate.MATCH_WIFI)
                        .build(), 0 /*subId*/, null /*service*/);
                        
        mResetInternetPreference = findPreference(PREF_KEY_RESET_INTERNET);
        if (mResetInternetPreference != null) {
            mResetInternetPreference.setVisible(false);
        }
        addNetworkMobileProviderController();
        addConnectedEthernetNetworkController();
        addWifiSwitchPreferenceController();
        mWifiStatusMessagePreference = findPreference(PREF_KEY_WIFI_STATUS_MESSAGE);
    }

>2.network_provider_settings.xml

<PreferenceScreen
        android:title="@string/provider_internet_settings"
        settings:keywords="@string/keywords_wifi">

    <!-- Resetting your internet,点击右上角那个reset按钮后,这个提示选项会出现 -->
    <com.android.settingslib.widget.LayoutPreference
        android:key="resetting_your_internet"
        android:title="@string/resetting_internet_text"
        android:selectable="false"
        android:layout="@layout/resetting_internet"
        settings:allowDividerBelow="true"/>

    <!-- 飞行模式打开会显示,参考1.1.1标记1 -->
    <com.android.settingslib.widget.LayoutPreference
        android:key="airplane_mode_message"
        android:title="@string/condition_airplane_title"
        android:selectable="false"
        android:layout="@layout/airplane_mode_message_preference"
        settings:allowDividerBelow="true"/>

    <Preference
        android:key="connected_ethernet_network"
        android:title="@string/ethernet"
        android:summary="@string/to_switch_networks_disconnect_ethernet"
        android:icon="@drawable/ic_settings_ethernet"/>

    <PreferenceCategory
        android:key="provider_model_mobile_network"
        android:title="@string/summary_placeholder"
        android:layout="@layout/preference_category_no_label"
        settings:controller="com.android.settings.network.NetworkMobileProviderController"/>
<!--wifi 开关,1.1.1标记2-->
    <com.android.settingslib.RestrictedSwitchPreference
        android:key="main_toggle_wifi"
        android:title="@string/wifi"
        settings:keywords="@string/keywords_wifi"
        settings:allowDividerAbove="true"/>

    <PreferenceCategory
        android:key="connected_access_point"
        android:layout="@layout/preference_category_no_label"/>
<!--已连接的wif显示在这里-->
    <PreferenceCategory
        android:key="first_access_points"
        android:layout="@layout/preference_category_no_label"/>
<!--wifi列表加在这个容器里-->
    <PreferenceCategory
        android:key="access_points"
        android:layout="@layout/preference_category_no_label"/>
<!--1.1.1图上标记3 network preference选项-->
    <Preference
        android:key="configure_network_settings"
        android:title="@string/network_and_internet_preferences_title"
        settings:allowDividerAbove="true"
        android:fragment="com.android.settings.wifi.ConfigureWifiSettings"/>
<!--1.1.1标记4,已保存的网络-->
    <Preference
        android:key="saved_networks"
        android:title="@string/wifi_saved_access_points_label"
        android:fragment="com.android.settings.wifi.savedaccesspoints2.SavedAccessPointsWifiSettings2"/>
<!--1.1.1标记5,已使用的数据-->
    <com.android.settings.datausage.DataUsagePreference
        android:key="non_carrier_data_usage"
        android:title="@string/non_carrier_data_usage"/>
<!--1.1.1标记6,footer提示-->
    <com.android.settingslib.widget.FooterPreference
        android:key="wifi_status_message_footer"
        android:selectable="false"
        settings:allowDividerAbove="false"
        settings:searchable="false"/>
</PreferenceScreen>

2.2.onActivityCreated

    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        if (hasWifiManager()) {
            mWifiPickerTrackerHelper =
                    new WifiPickerTrackerHelper(getSettingsLifecycle(), getContext(), this);
                    //补充1
            mWifiPickerTracker = mWifiPickerTrackerHelper.getWifiPickerTracker();
        }
        mInternetUpdater = new InternetUpdater(getContext(), getSettingsLifecycle(), this);

        mConnectListener = new WifiConnectListener(getActivity());

//..

        if (mNetworkMobileProviderController != null) {
            mNetworkMobileProviderController.setWifiPickerTrackerHelper(mWifiPickerTrackerHelper);
        }
    }

>1.createWifiPickerTracker

WifiTrackerLibProviderImpl.java

    public WifiPickerTracker createWifiPickerTracker(
            Lifecycle lifecycle, Context context,
            Handler mainHandler, Handler workerHandler, Clock clock,
            long maxScanAgeMillis, long scanIntervalMillis,
            WifiPickerTracker.WifiPickerTrackerCallback listener) {
            //参考4.2
        return new WifiPickerTracker(
                lifecycle, context,
                context.getSystemService(WifiManager.class),
                context.getSystemService(ConnectivityManager.class),
                mainHandler, workerHandler, clock,
                maxScanAgeMillis, scanIntervalMillis,
                listener);
    }

>2.createNetworkDetailsTracker

  • 补充1是wifi追踪,这个是网络追踪,这里没用到
    public NetworkDetailsTracker createNetworkDetailsTracker(
            Lifecycle lifecycle, Context context,
            Handler mainHandler, Handler workerHandler, Clock clock,
            long maxScanAgeMillis, long scanIntervalMillis,
            String key) {
        return NetworkDetailsTracker.createNetworkDetailsTracker(
                lifecycle, context,
                context.getSystemService(WifiManager.class),
                context.getSystemService(ConnectivityManager.class),
                mainHandler, workerHandler, clock,
                maxScanAgeMillis, scanIntervalMillis,
                key);
    }

2.3.onCreateContextMenu

  • wifi 列表选项的长按事件
    public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo info) {
        Preference preference = (Preference) view.getTag();
        if (!(preference instanceof LongPressWifiEntryPreference)) {
            return;
        }

        mSelectedWifiEntry = ((LongPressWifiEntryPreference) preference).getWifiEntry();
//标题就是wifi的名字
        menu.setHeaderTitle(mSelectedWifiEntry.getTitle());
        if (mSelectedWifiEntry.canConnect()) {
        //显示connect 选项
            menu.add(Menu.NONE, MENU_ID_CONNECT, 0 /* order */, R.string.wifi_connect);
        }
//可以断开连接,也就是已经连接的
        if (mSelectedWifiEntry.canDisconnect()) {
            if (mSelectedWifiEntry.canShare()) {
            //share 选项
                addShareMenuIfSuitable(menu);
            }
            //disconnect 选项
            menu.add(Menu.NONE, MENU_ID_DISCONNECT, 1 /* order */,
                    R.string.wifi_disconnect_button_text);
        }

        //补充1, forget,就是彻底删除连接信息,
        if (canForgetNetwork()) {
            addForgetMenuIfSuitable(menu);
        }

        WifiConfiguration config = mSelectedWifiEntry.getWifiConfiguration();
        //有些配置是不可编辑的
        if (WifiUtils.isNetworkLockedDown(getActivity(), config)) {
            return;
        }
//已经保存的wifi,没有连接上网络,添加modify选项
        if (mSelectedWifiEntry.isSaved() && mSelectedWifiEntry.getConnectedState()
                != WifiEntry.CONNECTED_STATE_CONNECTED) {
            menu.add(Menu.NONE, MENU_ID_MODIFY, 0 /* order */, R.string.wifi_modify);
        }
    }

>1.canForgetNetwork

    private boolean canForgetNetwork() {
        return mSelectedWifiEntry.canForget() && !WifiUtils.isNetworkLockedDown(getActivity(),
                mSelectedWifiEntry.getWifiConfiguration());
    }

>2.onContextItemSelected

    public boolean onContextItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case MENU_ID_CONNECT:
                connect(mSelectedWifiEntry, true /* editIfNoConfig */, false /* fullScreenEdit */);
                return true;
            case MENU_ID_DISCONNECT:
                mSelectedWifiEntry.disconnect(null /* callback */);
                return true;
            case MENU_ID_FORGET:
                forget(mSelectedWifiEntry);
                return true;
            case MENU_ID_SHARE:
                WifiDppUtils.showLockScreen(getContext(),
                        () -> launchWifiDppConfiguratorActivity(mSelectedWifiEntry));
                return true;
            case MENU_ID_MODIFY:
                showDialog(mSelectedWifiEntry, WifiConfigUiBase2.MODE_MODIFY);
                return true;
            default:
                return super.onContextItemSelected(item);
        }
    }

2.4.isDisabledByWrongPassword

    private static boolean isDisabledByWrongPassword(WifiEntry wifiEntry) {
        WifiConfiguration config = wifiEntry.getWifiConfiguration();
        if (config == null) {
            return false;
        }
        WifiConfiguration.NetworkSelectionStatus networkStatus =
                config.getNetworkSelectionStatus();
        if (networkStatus == null
                || networkStatus.getNetworkSelectionStatus() == NETWORK_SELECTION_ENABLED) {
            return false;
        }
        int reason = networkStatus.getNetworkSelectionDisableReason();
        return WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD == reason;
    }

2.5.fixConnectivity

参考图1.1.1,右上角的标记7按钮点击事件,重置网络系统

    private void fixConnectivity() {
        if (mInternetResetHelper == null) {
            mInternetResetHelper = new InternetResetHelper(getContext(), getLifecycle());
            mInternetResetHelper.setResettingPreference(mResetInternetPreference);
            mInternetResetHelper.setMobileNetworkController(mNetworkMobileProviderController);
            mInternetResetHelper.setWifiTogglePreference(
                    findPreference(WifiSwitchPreferenceController.KEY));
            mInternetResetHelper.addWifiNetworkPreference(mConnectedWifiEntryPreferenceCategory);
            mInternetResetHelper.addWifiNetworkPreference(mFirstWifiEntryPreferenceCategory);
            mInternetResetHelper.addWifiNetworkPreference(mWifiEntryPreferenceCategory);
        }
        //补充1,最终交给2.6对象处理的
        mInternetResetHelper.restart();
    }

>1.InternetResetHelper

    public void restart() {
        if (!mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()) {
//参考2.6.1,飞行模式打开,并且wifi关闭的时候不能重置
            return;
        },
        suspendPreferences();
        mIsRecoveryReady = false;
        mIsWifiReady = !mWifiManager.isWifiEnabled();
        mHandlerInjector.postDelayed(mTimeoutRunnable, RESTART_TIMEOUT_MS);
        //参考2.6.4
        mConnectivitySubsystemsRecoveryManager.triggerSubsystemRestart(null /* reason */, this);
    }

2.6.ConnectivitySubsystemsRecoveryManager

>1.isRecoveryAvailable

    public boolean isRecoveryAvailable() {
    //补充2,飞行模式没有打开的话,返回true
        if (!isApmEnabled()) return true;
//补充3
        return isWifiEnabled();
    }

>2.isApmEnabled

  • 飞行模式是否打开
    private boolean isApmEnabled() {
        return Settings.Global.getInt(mContext.getContentResolver(),
                Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
    }

>3.isWifiEnabled

  • wifi是否打开
    private boolean isWifiEnabled() {
        return mWifiManager != null && (mWifiManager.isWifiEnabled()
                || mWifiManager.isWifiApEnabled());
    }

>4.triggerSubsystemRestart

  • 省事的话反射调用 mWifiManager.restartWifiSubsystem()方法就可以了。
    public void triggerSubsystemRestart(String reason, @NonNull RecoveryStatusCallback callback) {
        mHandler.post(() -> {
            boolean someSubsystemRestarted = false;

            if (mWifiRestartInProgress) {
                return;
            }

            if (mTelephonyRestartInProgress) {
                return;
            }
//重启wifi子系统
            if (isWifiEnabled()) {
                mWifiManager.restartWifiSubsystem();//这个基本就可以重启wifi了
                mWifiRestartInProgress = true;
                someSubsystemRestarted = true;
                startTrackingWifiRestart();//重启状态监听
            }
//重启无线电
            if (mTelephonyManager != null && !isApmEnabled()) {
                if (mTelephonyManager.rebootRadio()) {
                    mTelephonyRestartInProgress = true;
                    someSubsystemRestarted = true;
                    startTrackingTelephonyRestart();//无线电重启状态监听
                }
            }

            if (someSubsystemRestarted) {
                mCurrentRecoveryCallback = callback;
                callback.onSubsystemRestartOperationBegin();

                mHandler.postDelayed(() -> {
                    stopTrackingWifiRestart();
                    stopTrackingTelephonyRestart();
                    mWifiRestartInProgress = false;
                    mTelephonyRestartInProgress = false;
                    if (mCurrentRecoveryCallback != null) {
                        mCurrentRecoveryCallback.onSubsystemRestartOperationEnd();
                        mCurrentRecoveryCallback = null;
                    }
                }, RESTART_TIMEOUT_MS);//延迟15s,二次确认重启操作结束
            }
        });
    }

2.7.updateWifiEntryPreferences

  • 刷新扫描到的wifi条目
    protected void updateWifiEntryPreferences() {
        //如果活动和视图没有准备好,或者它是受限制的UI,则绕过更新
        if (getActivity() == null || getView() == null || mIsRestricted) {
            return;
        }
        //以防状态发生变化
        if (mWifiPickerTracker == null
                || mWifiPickerTracker.getWifiState() != WifiManager.WIFI_STATE_ENABLED) {
            return;
        }

        boolean hasAvailableWifiEntries = false;
        mWifiEntryPreferenceCategory.setVisible(true);
//已连接的wifi条目
        final WifiEntry connectedEntry = mWifiPickerTracker.getConnectedWifiEntry();
        PreferenceCategory connectedWifiPreferenceCategory = getConnectedWifiPreferenceCategory();
        //不为空的话使容器可见
        connectedWifiPreferenceCategory.setVisible(connectedEntry != null);
        if (connectedEntry != null) {
            final LongPressWifiEntryPreference connectedPref =
                    connectedWifiPreferenceCategory.findPreference(connectedEntry.getKey());
            if (connectedPref == null || connectedPref.getWifiEntry() != connectedEntry) {
                connectedWifiPreferenceCategory.removeAll();
                final ConnectedWifiEntryPreference pref =
                        createConnectedWifiEntryPreference(connectedEntry);
                pref.setKey(connectedEntry.getKey());
                pref.refresh();
                connectedWifiPreferenceCategory.addPreference(pref);
                pref.setOnPreferenceClickListener(preference -> {
                    if (connectedEntry.canSignIn()) {
                        connectedEntry.signIn(null /* callback */);
                    } else {
                        launchNetworkDetailsFragment(pref);
                    }
                    return true;
                });
                pref.setOnGearClickListener(preference -> {
                    launchNetworkDetailsFragment(pref);
                });

                if (mClickedConnect) {
                    mClickedConnect = false;
                    scrollToPreference(connectedWifiPreferenceCategory);
                }
            }
        } else {//没有已连接的wifi
            connectedWifiPreferenceCategory.removeAll();
        }

        int index = 0;
        cacheRemoveAllPrefs(mWifiEntryPreferenceCategory);
        List<WifiEntry> wifiEntries = mWifiPickerTracker.getWifiEntries();
        for (WifiEntry wifiEntry : wifiEntries) {
            hasAvailableWifiEntries = true;

            String key = wifiEntry.getKey();
            # 获取缓存里的条目
            LongPressWifiEntryPreference pref =
                    (LongPressWifiEntryPreference) getCachedPreference(key);
            if (pref != null) {
                if (pref.getWifiEntry() == wifiEntry) {
                    pref.setOrder(index++);//缓存里的数据可以使用,修改下order即可
                    continue;
                } else {
                    //缓存里的数据不一样,移除
                    removePreference(key);
                }
            }
//添加新的
            pref = createLongPressWifiEntryPreference(wifiEntry);
            pref.setKey(wifiEntry.getKey());
            pref.setOrder(index++);
            pref.refresh();

            if (wifiEntry.getHelpUriString() != null) {
                pref.setOnButtonClickListener(preference -> {
                    openSubscriptionHelpPage(wifiEntry);
                });
            }
            mWifiEntryPreferenceCategory.addPreference(pref);
        }
        removeCachedPrefs(mWifiEntryPreferenceCategory);
        //没有扫描到wifi
        if (!hasAvailableWifiEntries) {
        //扫描进度条可见
            setProgressBarVisible(true);
            Preference pref = new Preference(getPrefContext());
            pref.setSelectable(false);
            pref.setSummary(R.string.wifi_empty_list_wifi_on);
            pref.setOrder(index++);
            pref.setKey(PREF_KEY_EMPTY_WIFI_LIST);
            mWifiEntryPreferenceCategory.addPreference(pref);
        } else {
            //移除进度条
            getView().postDelayed(mHideProgressBarRunnable, 1700 /* delay millis */);
        }
        //wifi列表后边有个 add network的选项,补充1里的1
        mAddWifiNetworkPreference.setOrder(index++);
        mWifiEntryPreferenceCategory.addPreference(mAddWifiNetworkPreference);
        //补充1的2
        setAdditionalSettingsSummaries();
    }

>1.图片

image.png

3.WifiEntry

3.1.常量

>1.WIFI_PICKER_COMPARATOR

数据排序逻辑,已连接的在前边,后边未连接的按照下边的条件排序

    public static Comparator<WifiEntry> WIFI_PICKER_COMPARATOR =
            Comparator.comparing((WifiEntry entry) -> entry.getConnectedState()
                            != CONNECTED_STATE_CONNECTED)
                    .thenComparing((WifiEntry entry) -> !entry.canConnect())
                    .thenComparing((WifiEntry entry) -> !entry.isSubscription())
                    .thenComparing((WifiEntry entry) -> !entry.isSaved())
                    .thenComparing((WifiEntry entry) -> !entry.isSuggestion())
                    .thenComparing((WifiEntry entry) -> -entry.getLevel())
                    .thenComparing((WifiEntry entry) -> entry.getTitle());

>2.TITLE_COMPARATOR

    public static Comparator<WifiEntry> TITLE_COMPARATOR =
            Comparator.comparing((WifiEntry entry) -> entry.getTitle());

3.2.子类

>1.StandardWifiEntry

WifiEntry表示逻辑Wi-Fi网络,由SSID和安全性唯一标识。这种类型的WifiEntry既可以表示打开的网络,也可以表示保存的网络

public class StandardWifiEntry extends WifiEntry {

>2.PasspointWifiEntry

代表的是已加密的网络,由FQDN唯一标识

public class PasspointWifiEntry extends WifiEntry implements WifiEntry.WifiEntryCallback {

>3.NetworkRequestEntry

由SSID、安全性和配置文件密钥唯一标识。

public class NetworkRequestEntry extends StandardWifiEntry {

4.BaseWifiTracker

public class BaseWifiTracker implements LifecycleObserver {

4.1.onStart

注册wifi相关的广播

    public void onStart() {
        mWorkerHandler.post(() -> {
            updateDefaultRouteInfo();
            IntentFilter filter = new IntentFilter();
            filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
            filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
            filter.addAction(WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION);
            filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
            filter.addAction(WifiManager.RSSI_CHANGED_ACTION);
            filter.addAction(TelephonyManager.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
            //补充1
            mContext.registerReceiver(mBroadcastReceiver, filter,
                    /* broadcastPermission */ null, mWorkerHandler);
                    //补充2
            mConnectivityManager.registerNetworkCallback(mNetworkRequest, mNetworkCallback,
                    mWorkerHandler);
                    //补充3
            NonSdkApiWrapper.registerSystemDefaultNetworkCallback(
                    mConnectivityManager, mDefaultNetworkCallback, mWorkerHandler);
            handleOnStart();//参考4.2和4.3子类的实现
            mIsInitialized = true;
        });
    }

>1.mBroadcastReceiver

处理方法都在子类实现。

    private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        @WorkerThread
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();

            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {
                mWifiState = intent.getIntExtra(
                        WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED);
                if (mWifiState == WifiManager.WIFI_STATE_ENABLED) {
                    mScanner.start();//可用,开始扫描
                } else {
                    mScanner.stop();//不可用,停止扫描
                }
                notifyOnWifiStateChanged();
                handleWifiStateChangedAction();
            } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)) {
                handleScanResultsAvailableAction(intent);
            } else if (WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION.equals(action)) {
                handleConfiguredNetworksChangedAction(intent);
            } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {
                handleNetworkStateChangedAction(intent);
            } else if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) {
                handleRssiChangedAction();
            } else if (TelephonyManager.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED.equals(action)) {
                handleDefaultSubscriptionChanged(intent.getIntExtra(
                        "subscription", SubscriptionManager.INVALID_SUBSCRIPTION_ID));
            }
        }
    };

>2.mNetworkCallback

    private final NetworkRequest mNetworkRequest = new NetworkRequest.Builder()
            .clearCapabilities()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
            .addTransportType(TRANSPORT_WIFI)//请求类型是wifi
            .build();

回调

    private final ConnectivityManager.NetworkCallback mNetworkCallback =
            new ConnectivityManager.NetworkCallback() {
                @Override
                @WorkerThread
                public void onLinkPropertiesChanged(@NonNull Network network,
                        @NonNull LinkProperties lp) {
                    if (!isPrimaryWifiNetwork(
                            mConnectivityManager.getNetworkCapabilities(network))) {
                        return;
                    }
                    handleLinkPropertiesChanged(lp);
                }

                @Override
                @WorkerThread
                public void onCapabilitiesChanged(@NonNull Network network,
                        @NonNull NetworkCapabilities networkCapabilities) {
                    if (!isPrimaryWifiNetwork(networkCapabilities)) {
                        return;
                    }
                    final boolean oldWifiValidated = mIsWifiValidated;
                    mIsWifiValidated = networkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED);

                    handleNetworkCapabilitiesChanged(networkCapabilities);
                }

                @Override
                @WorkerThread
                public void onLost(@NonNull Network network) {
                    if (!isPrimaryWifiNetwork(
                            mConnectivityManager.getNetworkCapabilities(network))) {
                        return;
                    }
                    mIsWifiValidated = false;
                }
            };

>3.mDefaultNetworkCallback

    private final ConnectivityManager.NetworkCallback mDefaultNetworkCallback =
            new ConnectivityManager.NetworkCallback() {

                public void onCapabilitiesChanged(@NonNull Network network,
                        @NonNull NetworkCapabilities networkCapabilities) {
                    final boolean oldWifiDefault = mIsWifiDefaultRoute;
                    final boolean oldCellDefault = mIsCellDefaultRoute;
                    // raw Wifi or VPN-over-Wifi or VCN-over-Wifi is default => Wifi is default.
                    mIsWifiDefaultRoute = networkCapabilities.hasTransport(TRANSPORT_WIFI)
                            || NonSdkApiWrapper.isVcnOverWifi(networkCapabilities);
                    mIsCellDefaultRoute = !mIsWifiDefaultRoute
                            && networkCapabilities.hasTransport(TRANSPORT_CELLULAR);
                    if (mIsWifiDefaultRoute != oldWifiDefault
                            || mIsCellDefaultRoute != oldCellDefault) {
//处理默认的route改变
                        handleDefaultRouteChanged();
                    }
                }

                @WorkerThread
                public void onLost(@NonNull Network network) {
                    mIsWifiDefaultRoute = false;
                    mIsCellDefaultRoute = false;
                    handleDefaultRouteChanged();
                }
            };

4.2.WifiPickerTracker

public class WifiPickerTracker extends BaseWifiTracker {

>1.handleOnStart

    protected void handleOnStart() {
    //补充2,更新已保存的网络配置
        updateWifiConfigurations(mWifiManager.getPrivilegedConfiguredNetworks());
        updatePasspointConfigurations(mWifiManager.getPasspointConfigurations());
        mScanResultUpdater.update(mWifiManager.getScanResults());
        //补充4,更新扫描结果
        conditionallyUpdateScanResults(true /* lastScanSucceeded */);
        final WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
        final Network currentNetwork = mWifiManager.getCurrentNetwork();
        mCurrentNetworkInfo = mConnectivityManager.getNetworkInfo(currentNetwork);
        updateConnectionInfo(wifiInfo, mCurrentNetworkInfo);
        notifyOnNumSavedNetworksChanged();
        notifyOnNumSavedSubscriptionsChanged();
        handleDefaultSubscriptionChanged(SubscriptionManager.getDefaultDataSubscriptionId());
        updateWifiEntries();//补充3

        handleNetworkCapabilitiesChanged(
                mConnectivityManager.getNetworkCapabilities(currentNetwork));
        handleLinkPropertiesChanged(mConnectivityManager.getLinkProperties(currentNetwork));
        handleDefaultRouteChanged();
    }

>2.updateWifiConfigurations

    private void updateWifiConfigurations(@NonNull List<WifiConfiguration> configs) {

        mStandardWifiConfigCache.clear();
        mSuggestedConfigCache.clear();
        mNetworkRequestConfigCache.clear();
        final List<WifiConfiguration> networkRequestConfigs = new ArrayList<>();
        for (WifiConfiguration config : configs) {
            if (config.carrierMerged) {
                continue;
            }
            StandardWifiEntryKey standardWifiEntryKey =
                    new StandardWifiEntryKey(config, true /* isTargetingNewNetworks */);
            if (config.isPasspoint()) {
                mPasspointWifiConfigCache.put(config.networkId, config);
            } else if (config.fromWifiNetworkSuggestion) {
                if (!mSuggestedConfigCache.containsKey(standardWifiEntryKey)) {
                    mSuggestedConfigCache.put(standardWifiEntryKey, new ArrayList<>());
                }
                mSuggestedConfigCache.get(standardWifiEntryKey).add(config);
            } else if (config.fromWifiNetworkSpecifier) {
                if (!mNetworkRequestConfigCache.containsKey(standardWifiEntryKey)) {
                    mNetworkRequestConfigCache.put(standardWifiEntryKey, new ArrayList<>());
                }
                mNetworkRequestConfigCache.get(standardWifiEntryKey).add(config);
            } else {
                if (!mStandardWifiConfigCache.containsKey(standardWifiEntryKey)) {
                    mStandardWifiConfigCache.put(standardWifiEntryKey, new ArrayList<>());
                }
                mStandardWifiConfigCache.get(standardWifiEntryKey).add(config);
            }
        }
        mNumSavedNetworks = (int) mStandardWifiConfigCache.values().stream()
                .flatMap(List::stream)
                .filter(config -> !config.isEphemeral())//排除短暂的一次性的wifi
                .map(config -> config.networkId)
                .distinct()
                .count();

        //更新缓存数据
        mStandardWifiEntryCache.forEach(entry ->
                entry.updateConfig(mStandardWifiConfigCache.get(entry.getStandardWifiEntryKey())));

        //删除不再是建议类型的wifi
        mSuggestedWifiEntryCache.removeIf(entry -> {
            entry.updateConfig(mSuggestedConfigCache.get(entry.getStandardWifiEntryKey()));
            return !entry.isSuggestion();
        });

        if (mNetworkRequestEntry != null) {
            mNetworkRequestEntry.updateConfig(
                    mNetworkRequestConfigCache.get(mNetworkRequestEntry.getStandardWifiEntryKey()));
        }
    }

>3.updateWifiEntries

    protected void updateWifiEntries() {
        synchronized (mLock) {
        //找到已连接或者连接中的
            mConnectedWifiEntry = mStandardWifiEntryCache.stream().filter(entry -> {
                final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
                return connectedState == CONNECTED_STATE_CONNECTED
                        || connectedState == CONNECTED_STATE_CONNECTING;
            }).findAny().orElse(null /* other */);
            //已连接的为空,找建议的
            if (mConnectedWifiEntry == null) {
                mConnectedWifiEntry = mSuggestedWifiEntryCache.stream().filter(entry -> {
                    final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
                    return connectedState == CONNECTED_STATE_CONNECTED
                            || connectedState == CONNECTED_STATE_CONNECTING;
                }).findAny().orElse(null /* other */);
            }
            //继续从加密的找
            if (mConnectedWifiEntry == null) {
                mConnectedWifiEntry = mPasspointWifiEntryCache.values().stream().filter(entry -> {
                    final @WifiEntry.ConnectedState int connectedState = entry.getConnectedState();
                    return connectedState == CONNECTED_STATE_CONNECTED
                            || connectedState == CONNECTED_STATE_CONNECTING;
                }).findAny().orElse(null /* other */);
            }
            if (mConnectedWifiEntry == null && mNetworkRequestEntry != null
                    && mNetworkRequestEntry.getConnectedState() != CONNECTED_STATE_DISCONNECTED) {
                mConnectedWifiEntry = mNetworkRequestEntry;
            }
            if (mConnectedWifiEntry != null) {
                mConnectedWifiEntry.setIsDefaultNetwork(mIsWifiDefaultRoute);
            }
            mWifiEntries.clear();
            final Set<ScanResultKey> scanResultKeysWithVisibleSuggestions =
                    mSuggestedWifiEntryCache.stream()
                            .filter(entry -> entry.isUserShareable()
                                    || entry == mConnectedWifiEntry)
                            .map(entry -> entry.getStandardWifiEntryKey().getScanResultKey())
                            .collect(Collectors.toSet());
            Set<String> passpointUtf8Ssids = new ArraySet<>();
            for (PasspointWifiEntry passpointWifiEntry : mPasspointWifiEntryCache.values()) {
                passpointUtf8Ssids.addAll(passpointWifiEntry.getAllUtf8Ssids());
            }
            for (StandardWifiEntry entry : mStandardWifiEntryCache) {
                entry.updateAdminRestrictions();
                if (entry == mConnectedWifiEntry) {
                    continue;
                }
                if (!entry.isSaved()) {
                    if (scanResultKeysWithVisibleSuggestions
                            .contains(entry.getStandardWifiEntryKey().getScanResultKey())) {
                        continue;
                    }
                    // Filter out any unsaved entries that are already provisioned with Passpoint
                    if (passpointUtf8Ssids.contains(entry.getSsid())) {
                        continue;
                    }
                }
                mWifiEntries.add(entry);
            }
            mWifiEntries.addAll(mSuggestedWifiEntryCache.stream().filter(entry ->
                    entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED
                            && entry.isUserShareable()).collect(toList()));
            mWifiEntries.addAll(mPasspointWifiEntryCache.values().stream().filter(entry ->
                    entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED).collect(toList()));
            mWifiEntries.addAll(mOsuWifiEntryCache.values().stream().filter(entry ->
                    entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED
                            && !entry.isAlreadyProvisioned()).collect(toList()));
            mWifiEntries.addAll(getContextualWifiEntries().stream().filter(entry ->
                    entry.getConnectedState() == CONNECTED_STATE_DISCONNECTED).collect(toList()));
            Collections.sort(mWifiEntries, WifiEntry.WIFI_PICKER_COMPARATOR);
            if (isVerboseLoggingEnabled()) {
                Log.v(TAG, "Connected WifiEntry: " + mConnectedWifiEntry);
                Log.v(TAG, "Updated WifiEntries: " + Arrays.toString(mWifiEntries.toArray()));
            }
        }
        notifyOnWifiEntriesChanged();
    }

>4.conditionallyUpdateScanResults

    private void conditionallyUpdateScanResults(boolean lastScanSucceeded) {
    //wifi不可用 ,扫描结果置空
        if (mWifiManager.getWifiState() == WifiManager.WIFI_STATE_DISABLED) {
            updateStandardWifiEntryScans(Collections.emptyList());
            updateSuggestedWifiEntryScans(Collections.emptyList());
            updatePasspointWifiEntryScans(Collections.emptyList());
            updateOsuWifiEntryScans(Collections.emptyList());
            updateNetworkRequestEntryScans(Collections.emptyList());
            updateContextualWifiEntryScans(Collections.emptyList());
            return;
        }

        long scanAgeWindow = mMaxScanAgeMillis;//15s
        if (lastScanSucceeded) {
        //扫描结果为true,直接使用扫描结果
            mScanResultUpdater.update(mWifiManager.getScanResults());
        } else {//为false,增加查询数据的时长
            scanAgeWindow += mScanIntervalMillis;//10s
        }

        List<ScanResult> scanResults = mScanResultUpdater.getScanResults(scanAgeWindow);
        //补充5
        updateStandardWifiEntryScans(scanResults);
        //补充6
        updateSuggestedWifiEntryScans(scanResults);
        //补充7
        updatePasspointWifiEntryScans(scanResults);
        //补充8
        updateOsuWifiEntryScans(scanResults);
        //补充9
        updateNetworkRequestEntryScans(scanResults);
        //空实现
        updateContextualWifiEntryScans(scanResults);
    }

>5.updateStandardWifiEntryScans

  • ScanResultKey里存储的SSID和security types集合
  • StandardWifiEntry是否一样,看的就是里边的StandardWifiEntryKey
    private void updateStandardWifiEntryScans(@NonNull List<ScanResult> scanResults) {
        //SSID不能为空,按照ScanResultKey进行分组
        final Map<ScanResultKey, List<ScanResult>> scanResultsByKey = scanResults.stream()
                .filter(scan -> !TextUtils.isEmpty(scan.SSID))
                .collect(Collectors.groupingBy(ScanResultKey::new));
        final Set<ScanResultKey> newScanKeys = new ArraySet<>(scanResultsByKey.keySet());

        //更新缓存数据里的扫描结果
        mStandardWifiEntryCache.forEach(entry -> {
            final ScanResultKey scanKey = entry.getStandardWifiEntryKey().getScanResultKey();
            newScanKeys.remove(scanKey);
            entry.updateScanResultInfo(scanResultsByKey.get(scanKey));
        });
        //缓存里添加新的数据
        for (ScanResultKey scanKey: newScanKeys) {
            final StandardWifiEntryKey entryKey =
                    new StandardWifiEntryKey(scanKey, true /* isTargetingNewNetworks */);
            final StandardWifiEntry newEntry = new StandardWifiEntry(mInjector, mContext,
                    mMainHandler, entryKey, mStandardWifiConfigCache.get(entryKey),
                    scanResultsByKey.get(scanKey), mWifiManager,
                    false /* forSavedNetworksPage */);
            mStandardWifiEntryCache.add(newEntry);
        }

        //移除无法使用的
        mStandardWifiEntryCache.removeIf(
                entry -> entry.getLevel() == WIFI_LEVEL_UNREACHABLE);
    }

>6.updateSuggestedWifiEntryScans

    private void updateSuggestedWifiEntryScans(@NonNull List<ScanResult> scanResults) {
     //过滤属于建议类型的结果
        final Set<StandardWifiEntryKey> userSharedEntryKeys =
                mWifiManager.getWifiConfigForMatchedNetworkSuggestionsSharedWithUser(scanResults)
                        .stream()
                        .map(StandardWifiEntryKey::new)
                        .collect(Collectors.toSet());

        // 按照ScanResultKey分组
        final Map<ScanResultKey, List<ScanResult>> scanResultsByKey = scanResults.stream()
                .filter(scan -> !TextUtils.isEmpty(scan.SSID))
                .collect(Collectors.groupingBy(ScanResultKey::new));

        //更新缓存数据的扫描结果
        final Set<StandardWifiEntryKey> seenEntryKeys = new ArraySet<>();
        mSuggestedWifiEntryCache.forEach(entry -> {
            final StandardWifiEntryKey entryKey = entry.getStandardWifiEntryKey();
            seenEntryKeys.add(entryKey);
            entry.updateScanResultInfo(scanResultsByKey.get(entryKey.getScanResultKey()));
            entry.setUserShareable(userSharedEntryKeys.contains(entryKey));
        });
        //从建议配置缓存里创建 建议条目缓存
        for (StandardWifiEntryKey entryKey : mSuggestedConfigCache.keySet()) {
            final ScanResultKey scanKey = entryKey.getScanResultKey();
            if (seenEntryKeys.contains(entryKey)
                    || !scanResultsByKey.containsKey(scanKey)) {
                continue;
            }
            final StandardWifiEntry newEntry = new StandardWifiEntry(mInjector, mContext,
                    mMainHandler, entryKey, mSuggestedConfigCache.get(entryKey),
                    scanResultsByKey.get(scanKey), mWifiManager,
                    false /* forSavedNetworksPage */);
            newEntry.setUserShareable(userSharedEntryKeys.contains(entryKey));
            mSuggestedWifiEntryCache.add(newEntry);
        }

        //移除无效的
        mSuggestedWifiEntryCache.removeIf(entry -> entry.getLevel() == WIFI_LEVEL_UNREACHABLE);
    }

>7.updatePasspointWifiEntryScans

    private void updatePasspointWifiEntryScans(@NonNull List<ScanResult> scanResults) {

        Set<String> seenKeys = new TreeSet<>();
        List<Pair<WifiConfiguration, Map<Integer, List<ScanResult>>>> matchingWifiConfigs =
                mWifiManager.getAllMatchingWifiConfigs(scanResults);

        for (Pair<WifiConfiguration, Map<Integer, List<ScanResult>>> pair : matchingWifiConfigs) {
            final WifiConfiguration wifiConfig = pair.first;
            final List<ScanResult> homeScans =
                    pair.second.get(WifiManager.PASSPOINT_HOME_NETWORK);
            final List<ScanResult> roamingScans =
                    pair.second.get(WifiManager.PASSPOINT_ROAMING_NETWORK);
            final String key = uniqueIdToPasspointWifiEntryKey(wifiConfig.getKey());
            seenKeys.add(key);

            // 缓存里没有的
            if (!mPasspointWifiEntryCache.containsKey(key)) {
            //建议类型的
                if (wifiConfig.fromWifiNetworkSuggestion) {
                    mPasspointWifiEntryCache.put(key, new PasspointWifiEntry(mInjector, mContext,
                            mMainHandler, wifiConfig, mWifiManager,
                            false /* forSavedNetworksPage */));
                } else if (mPasspointConfigCache.containsKey(key)) {
                //缓存配置里有对应的key,根据key获取对应的config
                    mPasspointWifiEntryCache.put(key, new PasspointWifiEntry(mInjector, mContext,
                            mMainHandler, mPasspointConfigCache.get(key), mWifiManager,
                            false /* forSavedNetworksPage */));
                } else {
                    //没有对应的配置
                    continue;
                }
            }//更新扫描结果
            mPasspointWifiEntryCache.get(key).updateScanResultInfo(wifiConfig,
                    homeScans, roamingScans);
        }

        //移除不可用的
        mPasspointWifiEntryCache.entrySet()
                .removeIf(entry -> entry.getValue().getLevel() == WIFI_LEVEL_UNREACHABLE
                        || (!seenKeys.contains(entry.getKey()))
                        && entry.getValue().getConnectedState() == CONNECTED_STATE_DISCONNECTED);
    }

>8.updateOsuWifiEntryScans

  • OSU:online sign-up
  • 返回与给定的ScanResult列表相关联的唯一Hotspot 2.0 OSU(提供者列表
    private void updateOsuWifiEntryScans(@NonNull List<ScanResult> scanResults) {

        Map<OsuProvider, List<ScanResult>> osuProviderToScans =
                mWifiManager.getMatchingOsuProviders(scanResults);
        Map<OsuProvider, PasspointConfiguration> osuProviderToPasspointConfig =
                mWifiManager.getMatchingPasspointConfigsForOsuProviders(
                        osuProviderToScans.keySet());
        //
        for (OsuWifiEntry entry : mOsuWifiEntryCache.values()) {
            entry.updateScanResultInfo(osuProviderToScans.remove(entry.getOsuProvider()));
        }

        //循环创建entry缓存对象
        for (OsuProvider provider : osuProviderToScans.keySet()) {
            OsuWifiEntry newEntry = new OsuWifiEntry(mInjector, mContext, mMainHandler, provider,
                    mWifiManager, false /* forSavedNetworksPage */);
            newEntry.updateScanResultInfo(osuProviderToScans.get(provider));
            mOsuWifiEntryCache.put(osuProviderToOsuWifiEntryKey(provider), newEntry);
        }

        //
        mOsuWifiEntryCache.values().forEach(osuEntry -> {
            PasspointConfiguration provisionedConfig =
                    osuProviderToPasspointConfig.get(osuEntry.getOsuProvider());
            if (provisionedConfig == null) {//没找到配置
                osuEntry.setAlreadyProvisioned(false);
                return;
            }
            osuEntry.setAlreadyProvisioned(true);
            PasspointWifiEntry provisionedEntry = mPasspointWifiEntryCache.get(
                    uniqueIdToPasspointWifiEntryKey(provisionedConfig.getUniqueId()));
            if (provisionedEntry == null) {
                return;
            }
            provisionedEntry.setOsuWifiEntry(osuEntry);
        });

        //移除不可用的
        mOsuWifiEntryCache.entrySet()
                .removeIf(entry -> entry.getValue().getLevel() == WIFI_LEVEL_UNREACHABLE);
    }

>9.updateNetworkRequestEntryScans

    private void updateNetworkRequestEntryScans(@NonNull List<ScanResult> scanResults) {

        if (mNetworkRequestEntry == null) {
            return;
        }

        final ScanResultKey scanKey =
                mNetworkRequestEntry.getStandardWifiEntryKey().getScanResultKey();
        List<ScanResult> matchedScans = scanResults.stream()
                .filter(scan -> scanKey.equals(new ScanResultKey(scan)))
                .collect(toList());
        mNetworkRequestEntry.updateScanResultInfo(matchedScans);
    }

>10.updateNetworkRequestEntryConnectionInfo

  • mNetworkRequestConfigCache数据来源参考补充2
    private void updateNetworkRequestEntryConnectionInfo(
            @Nullable WifiInfo wifiInfo, @Nullable NetworkInfo networkInfo) {
        final List<WifiConfiguration> matchingConfigs = new ArrayList<>();

        if (wifiInfo != null) {
            for (int i = 0; i < mNetworkRequestConfigCache.size(); i++) {
                final List<WifiConfiguration> configs = mNetworkRequestConfigCache.valueAt(i);
                if (!configs.isEmpty() && configs.get(0).networkId == wifiInfo.getNetworkId()) {
                    matchingConfigs.addAll(configs);
                    break;
                }
            }
        }

        //没有对应的配置,请求置空
        if (matchingConfigs.isEmpty()) {
            mNetworkRequestEntry = null;
            return;
        }

        //entry为空或者key与当前的不同
        final StandardWifiEntryKey entryKey = new StandardWifiEntryKey(matchingConfigs.get(0));
        if (mNetworkRequestEntry == null
                || !mNetworkRequestEntry.getStandardWifiEntryKey().equals(entryKey)) {
            mNetworkRequestEntry = new NetworkRequestEntry(mInjector, mContext, mMainHandler,
                    entryKey, mWifiManager, false /* forSavedNetworksPage */);
            mNetworkRequestEntry.updateConfig(matchingConfigs);
            updateNetworkRequestEntryScans(mScanResultUpdater.getScanResults());
        }
        mNetworkRequestEntry.updateConnectionInfo(wifiInfo, networkInfo);
    }

4.3.SavedNetworkTracker

public class SavedNetworkTracker extends BaseWifiTracker {
    protected void handleOnStart() {
    //补充1
        updateStandardWifiEntryConfigs(mWifiManager.getConfiguredNetworks());
        //补充2
        updatePasspointWifiEntryConfigs(mWifiManager.getPasspointConfigurations());
        //更新扫描结果
        conditionallyUpdateScanResults(true /* lastScanSucceeded */);
        //获取当前连接的网络信息
        final WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
        final Network currentNetwork = mWifiManager.getCurrentNetwork();
        mCurrentNetworkInfo = mConnectivityManager.getNetworkInfo(currentNetwork);
        updateConnectionInfo(wifiInfo, mCurrentNetworkInfo);
        //补充3
        updateWifiEntries();

        handleNetworkCapabilitiesChanged(
                mConnectivityManager.getNetworkCapabilities(currentNetwork));
        handleLinkPropertiesChanged(mConnectivityManager.getLinkProperties(currentNetwork));
        if (mConnectedWifiEntry != null) {
            mConnectedWifiEntry.setIsDefaultNetwork(mIsWifiDefaultRoute);
            mConnectedWifiEntry.setIsLowQuality(mIsWifiValidated && mIsCellDefaultRoute);
        }
    }

>1.updateStandardWifiEntryConfigs

更新已保存的wifi连接配置

    private void updateStandardWifiEntryConfigs(@NonNull List<WifiConfiguration> configs) {

        final Map<StandardWifiEntryKey, List<WifiConfiguration>> wifiConfigsByKey = configs.stream()
                .filter(config -> !config.carrierMerged)
                .collect(Collectors.groupingBy(StandardWifiEntryKey::new));

        //
        mStandardWifiEntryCache.removeIf(entry -> {
            //
            entry.updateConfig(wifiConfigsByKey.remove(entry.getStandardWifiEntryKey()));
            //
            return !entry.isSaved();
        });

        //
        for (StandardWifiEntryKey key : wifiConfigsByKey.keySet()) {
            mStandardWifiEntryCache.add(new StandardWifiEntry(mInjector, mContext, mMainHandler,
                    key, wifiConfigsByKey.get(key), null, mWifiManager,
                    true /* forSavedNetworksPage */));
        }
    }

>2.updatePasspointWifiEntryConfigs

更新用户安装的passpoint config

    private void updatePasspointWifiEntryConfigs(@NonNull List<PasspointConfiguration> configs) {

        final Map<String, PasspointConfiguration> passpointConfigsByKey =
                configs.stream().collect(toMap(
                        (config) -> uniqueIdToPasspointWifiEntryKey(config.getUniqueId()),
                        Function.identity()));

        //
        mPasspointWifiEntryCache.entrySet().removeIf((entry) -> {
            final PasspointWifiEntry wifiEntry = entry.getValue();
            final String key = wifiEntry.getKey();
            final PasspointConfiguration cachedConfig = passpointConfigsByKey.remove(key);
            if (cachedConfig != null) {
                wifiEntry.updatePasspointConfig(cachedConfig);
                return false;
            } else {
                return true;
            }
        });

        // Create new entry for each unmatched config
        for (String key : passpointConfigsByKey.keySet()) {
            mPasspointWifiEntryCache.put(key,
                    new PasspointWifiEntry(mInjector, mContext, mMainHandler,
                            passpointConfigsByKey.get(key), mWifiManager,
                            true /* forSavedNetworksPage */));
        }
    }

>3.updateWifiEntries

    private void updateWifiEntries() {
        synchronized (mLock) {
            mConnectedWifiEntry = null;
            for (WifiEntry entry : mStandardWifiEntryCache) {
                if (entry.getConnectedState() != CONNECTED_STATE_DISCONNECTED) {
                    mConnectedWifiEntry = entry;
                }
            }
            for (WifiEntry entry : mSubscriptionWifiEntries) {
                if (entry.getConnectedState() != CONNECTED_STATE_DISCONNECTED) {
                    mConnectedWifiEntry = entry;
                }
            }
            if (mConnectedWifiEntry != null) {
                mConnectedWifiEntry.setIsDefaultNetwork(mIsWifiDefaultRoute);
            }
            mSavedWifiEntries.clear();
            mSavedWifiEntries.addAll(mStandardWifiEntryCache);
            Collections.sort(mSavedWifiEntries, WifiEntry.TITLE_COMPARATOR);
            mSubscriptionWifiEntries.clear();
            mSubscriptionWifiEntries.addAll(mPasspointWifiEntryCache.values());
            Collections.sort(mSubscriptionWifiEntries, WifiEntry.TITLE_COMPARATOR);

        }
        notifyOnSavedWifiEntriesChanged();
        notifyOnSubscriptionWifiEntriesChanged();
    }

4.4.ScanResultUtil

>1.validate

扫描结果数据是否有效,下边3个不能为空

    private static boolean validate(@Nullable ScanResult scanResult) {
        return scanResult != null && scanResult.SSID != null
                && scanResult.capabilities != null && scanResult.BSSID != null;
    }

>2.isScanResultForOpenNetwork

是否是开放性的网络,就是看capabilities的值,不包含下边任何一种的就是开放性的

    public static boolean isScanResultForOpenNetwork(@NonNull ScanResult scanResult) {
        return (!(isScanResultForWepNetwork(scanResult) || isScanResultForPskNetwork(scanResult)
                || isScanResultForEapNetwork(scanResult) || isScanResultForSaeNetwork(scanResult)
                || isScanResultForWpa3EnterpriseTransitionNetwork(scanResult)
                || isScanResultForWpa3EnterpriseOnlyNetwork(scanResult)
                || isScanResultForWapiPskNetwork(scanResult)
                || isScanResultForWapiCertNetwork(scanResult)
                || isScanResultForEapSuiteBNetwork(scanResult)
                || isScanResultForDppNetwork(scanResult)
                || isScanResultForUnknownAkmNetwork(scanResult)));
    }