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
>2.打开wifi
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.图片
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)));
}