com/android/server/wifi/NetworkSuggestionEvaluator.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.wifi;

 import android.annotation.NonNull;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiNetworkSuggestion;
 import android.util.LocalLog;
 import android.util.Log;

 import com.android.server.wifi.util.ScanResultUtil;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;

 import javax.annotation.Nullable;
 import javax.annotation.concurrent.NotThreadSafe;

 /**
  * Evaluator to pick the best network to connect to from the list of active network suggestions
  * provided by apps.
  * Note:
  * <li> This class is not thread safe and meant to be used only from {@link WifiNetworkSelector}.
  * </li>
  *
  * This is a non-optimal implementation which picks any network suggestion which matches
  * the scan result with the highest RSSI.
  * TODO: More advanced implementation will follow!
  * Params to consider for evaluating network suggestions:
  *  - Regular network evaluator params like security, band, RSSI, etc.
  *  - Priority of suggestions provided by a single app.
  *  - Whether the network suggestions requires user/app interaction or if it is metered.
  *  - Historical quality of suggestions provided by the corresponding app.
  */
 @NotThreadSafe
 public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEvaluator {
     private static final String TAG = "NetworkSuggestionEvaluator";

     private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
     private final WifiConfigManager mWifiConfigManager;
     private final LocalLog mLocalLog;

     NetworkSuggestionEvaluator(WifiNetworkSuggestionsManager networkSuggestionsManager,
             WifiConfigManager wifiConfigManager, LocalLog localLog) {
         mWifiNetworkSuggestionsManager = networkSuggestionsManager;
         mWifiConfigManager = wifiConfigManager;
         mLocalLog = localLog;
     }

     @Override
     public void update(List<ScanDetail> scanDetails) {
         // TODO(b/115504887): This could be used to re-evaluate any temporary blacklists.
     }

     @Override
     public WifiConfiguration evaluateNetworks(List<ScanDetail> scanDetails,
             WifiConfiguration currentNetwork, String currentBssid, boolean connected,
             boolean untrustedNetworkAllowed,
             @NonNull OnConnectableListener onConnectableListener) {
         MatchMetaInfo matchMetaInfo = new MatchMetaInfo();
         for (int i = 0; i < scanDetails.size(); i++) {
             ScanDetail scanDetail = scanDetails.get(i);
             ScanResult scanResult = scanDetail.getScanResult();
             // If the user previously forgot this network, don't select it.
             if (mWifiConfigManager.wasEphemeralNetworkDeleted(
                     ScanResultUtil.createQuotedSSID(scanResult.SSID))) {
                 mLocalLog.log("Ignoring disabled ephemeral SSID: "
                         + WifiNetworkSelector.toScanId(scanResult));
                 continue;
             }
             Set<WifiNetworkSuggestion> matchingNetworkSuggestions =
                     mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail(scanDetail);
             if (matchingNetworkSuggestions == null || matchingNetworkSuggestions.isEmpty()) {
                 continue;
             }
             // All matching suggestions have the same network credentials type. So, use any one of
             // them to lookup/add the credentials to WifiConfigManager.
             // Note: Apps could provide different credentials (password, ceritificate) for the same
             // network, need to handle that in the future.
             WifiNetworkSuggestion matchingNetworkSuggestion =
                     matchingNetworkSuggestions.stream().findAny().get();
             // Check if we already have a network with the same credentials in WifiConfigManager
             // database. If yes, we should check if the network is currently blacklisted.
             WifiConfiguration wCmConfiguredNetwork =
                     mWifiConfigManager.getConfiguredNetwork(
                             matchingNetworkSuggestion.wifiConfiguration.configKey());
             if (wCmConfiguredNetwork != null) {
                 if (!wCmConfiguredNetwork.getNetworkSelectionStatus().isNetworkEnabled()
                         && !mWifiConfigManager.tryEnableNetwork(wCmConfiguredNetwork.networkId)) {
                     mLocalLog.log("Ignoring blacklisted network: "
                             + WifiNetworkSelector.toNetworkString(wCmConfiguredNetwork));
                     continue;
                 }
             }
             matchMetaInfo.putAll(matchingNetworkSuggestions, wCmConfiguredNetwork, scanDetail);
         }
         // Return early on no match.
         if (matchMetaInfo.isEmpty()) {
             mLocalLog.log("did not see any matching network suggestions.");
             return null;
         }
         // Note: These matched sets should be very small & hence these additional manipulations that
         // follow should not be very expensive.
         PerNetworkSuggestionMatchMetaInfo candidate =
                 matchMetaInfo.findConnectableNetworksAndPickBest(onConnectableListener);
         if (candidate == null) { // should never happen.
             Log.wtf(TAG, "Unexepectedly got null");
             return null;
         }
         return candidate.wCmConfiguredNetwork;
     }

     // Add and enable this network to the central database (i.e WifiConfigManager).
     // Returns the copy of WifiConfiguration with the allocated network ID filled in.
     private WifiConfiguration addCandidateToWifiConfigManager(
             @NonNull WifiConfiguration wifiConfiguration, int uid, @NonNull String packageName) {
         // Mark the network ephemeral because we don't want these persisted by WifiConfigManager.
         wifiConfiguration.ephemeral = true;
         wifiConfiguration.fromWifiNetworkSuggestion = true;

         NetworkUpdateResult result =
                 mWifiConfigManager.addOrUpdateNetwork(wifiConfiguration, uid, packageName);
         if (!result.isSuccess()) {
             mLocalLog.log("Failed to add network suggestion");
             return null;
         }
         if (!mWifiConfigManager.updateNetworkSelectionStatus(result.getNetworkId(),
                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLE)) {
             mLocalLog.log("Failed to make network suggestion selectable");
             return null;
         }
         int candidateNetworkId = result.getNetworkId();
         return mWifiConfigManager.getConfiguredNetwork(candidateNetworkId);
     }

     @Override
     public @EvaluatorId int getId() {
         return EVALUATOR_ID_SUGGESTION;
     }

     @Override
     public String getName() {
         return TAG;
     }

     // Container classes to handle book-keeping while we're iterating through the scan list.
     private class PerNetworkSuggestionMatchMetaInfo {
         public final WifiNetworkSuggestion wifiNetworkSuggestion;
         public final ScanDetail matchingScanDetail;
         public WifiConfiguration wCmConfiguredNetwork; // Added to WifiConfigManager.

         PerNetworkSuggestionMatchMetaInfo(@NonNull WifiNetworkSuggestion wifiNetworkSuggestion,
                                           @Nullable WifiConfiguration wCmConfiguredNetwork,
                                           @NonNull ScanDetail matchingScanDetail) {
             this.wifiNetworkSuggestion = wifiNetworkSuggestion;
             this.wCmConfiguredNetwork = wCmConfiguredNetwork;
             this.matchingScanDetail = matchingScanDetail;
         }
     }

     private class PerAppMatchMetaInfo {
         public final List<PerNetworkSuggestionMatchMetaInfo> networkInfos = new ArrayList<>();

         /**
          * Add the network suggestion & associated info to this package meta info.
          */
         public void put(WifiNetworkSuggestion wifiNetworkSuggestion,
                         WifiConfiguration matchingWifiConfiguration,
                         ScanDetail matchingScanDetail) {
             networkInfos.add(new PerNetworkSuggestionMatchMetaInfo(
                     wifiNetworkSuggestion, matchingWifiConfiguration, matchingScanDetail));
         }

         /**
          * Pick the highest priority networks among the current match info candidates for this
          * app.
          */
         public List<PerNetworkSuggestionMatchMetaInfo> getHighestPriorityNetworks() {
             // Partition the list to a map of network suggestions keyed in by the priorities.
             // There can be multiple networks with the same priority, hence a list in the value.
             Map<Integer, List<PerNetworkSuggestionMatchMetaInfo>> matchedNetworkInfosPerPriority =
                     networkInfos.stream()
                             .collect(Collectors.toMap(
                                     e -> e.wifiNetworkSuggestion.wifiConfiguration.priority,
                                     e -> Arrays.asList(e),
                                     (v1, v2) -> { // concatenate networks with the same priority.
                                         List<PerNetworkSuggestionMatchMetaInfo> concatList =
                                                 new ArrayList<>(v1);
                                         concatList.addAll(v2);
                                         return concatList;
                                     }));
             if (matchedNetworkInfosPerPriority.isEmpty()) { // should never happen.
                 Log.wtf(TAG, "Unexepectedly got empty");
                 return Collections.EMPTY_LIST;
             }
             // Return the list associated with the highest priority value.
             return matchedNetworkInfosPerPriority.get(Collections.max(
                     matchedNetworkInfosPerPriority.keySet()));
         }
     }

     private class MatchMetaInfo {
         private Map<String, PerAppMatchMetaInfo> mAppInfos = new HashMap<>();

         /**
          * Add all the network suggestion & associated info.
          */
         public void putAll(Set<WifiNetworkSuggestion> wifiNetworkSuggestions,
                            WifiConfiguration wCmConfiguredNetwork,
                            ScanDetail matchingScanDetail) {
             // Separate the suggestions into buckets for each app to allow sorting based on
             // priorities set by app.
             for (WifiNetworkSuggestion wifiNetworkSuggestion : wifiNetworkSuggestions) {
                 PerAppMatchMetaInfo appInfo = mAppInfos.computeIfAbsent(
                         wifiNetworkSuggestion.suggestorPackageName, k -> new PerAppMatchMetaInfo());
                 appInfo.put(wifiNetworkSuggestion, wCmConfiguredNetwork, matchingScanDetail);
             }
         }

         /**
          * Are there any matched candidates?
          */
         public boolean isEmpty() {
             return mAppInfos.isEmpty();
         }

         /**
          * Find all the connectable networks and pick the best network among the current match info
          * candidates.
          *
          * Among the highest priority suggestions from different packages, choose the suggestion
          * with the highest RSSI.
          * Note: This should need to be replaced by a more sophisticated algorithm.
          */
         public PerNetworkSuggestionMatchMetaInfo findConnectableNetworksAndPickBest(
                 @NonNull OnConnectableListener onConnectableListener) {
             List<PerNetworkSuggestionMatchMetaInfo> allMatchedNetworkInfos = new ArrayList<>();
             for (PerAppMatchMetaInfo appInfo : mAppInfos.values()) {
                 List<PerNetworkSuggestionMatchMetaInfo> matchedNetworkInfos =
                         appInfo.getHighestPriorityNetworks();
                 for (PerNetworkSuggestionMatchMetaInfo matchedNetworkInfo : matchedNetworkInfos) {
                     // if the network does not already exist in WifiConfigManager, add now.
                     if (matchedNetworkInfo.wCmConfiguredNetwork == null) {
                         matchedNetworkInfo.wCmConfiguredNetwork = addCandidateToWifiConfigManager(
                                 matchedNetworkInfo.wifiNetworkSuggestion.wifiConfiguration,
                                 matchedNetworkInfo.wifiNetworkSuggestion.suggestorUid,
                                 matchedNetworkInfo.wifiNetworkSuggestion.suggestorPackageName);
                         if (matchedNetworkInfo.wCmConfiguredNetwork == null) continue;
                         mLocalLog.log(String.format("network suggestion candidate %s (new)",
                                 WifiNetworkSelector.toNetworkString(
                                         matchedNetworkInfo.wCmConfiguredNetwork)));
                     } else {
                         mLocalLog.log(String.format("network suggestion candidate %s (existing)",
                                 WifiNetworkSelector.toNetworkString(
                                         matchedNetworkInfo.wCmConfiguredNetwork)));
                     }
                     allMatchedNetworkInfos.add(matchedNetworkInfo);
                     // Invoke onConnectable for the best networks from each app.
                     onConnectableListener.onConnectable(
                             matchedNetworkInfo.matchingScanDetail,
                             matchedNetworkInfo.wCmConfiguredNetwork,
                             0);
                 }
             }
             PerNetworkSuggestionMatchMetaInfo networkInfo = allMatchedNetworkInfos
                     .stream()
                     .max(Comparator.comparing(e -> e.matchingScanDetail.getScanResult().level))
                     .orElse(null);
             if (networkInfo == null) { // should never happen.
                 Log.wtf(TAG, "Unexepectedly got null");
                 return null;
             }
             return networkInfo;
         }
     }

 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.wifi;

	import android.annotation.NonNull;
	import android.net.wifi.ScanResult;
	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiNetworkSuggestion;
	import android.util.LocalLog;
	import android.util.Log;

	import com.android.server.wifi.util.ScanResultUtil;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.stream.Collectors;

	import javax.annotation.Nullable;
	import javax.annotation.concurrent.NotThreadSafe;

	/**
	* Evaluator to pick the best network to connect to from the list of active network suggestions
	* provided by apps.
	* Note:
	* <li> This class is not thread safe and meant to be used only from {@link WifiNetworkSelector}.
	* </li>
	*
	* This is a non-optimal implementation which picks any network suggestion which matches
	* the scan result with the highest RSSI.
	* TODO: More advanced implementation will follow!
	* Params to consider for evaluating network suggestions:
	* - Regular network evaluator params like security, band, RSSI, etc.
	* - Priority of suggestions provided by a single app.
	* - Whether the network suggestions requires user/app interaction or if it is metered.
	* - Historical quality of suggestions provided by the corresponding app.
	*/
	@NotThreadSafe
	public class NetworkSuggestionEvaluator implements WifiNetworkSelector.NetworkEvaluator {
	private static final String TAG = "NetworkSuggestionEvaluator";

	private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
	private final WifiConfigManager mWifiConfigManager;
	private final LocalLog mLocalLog;

	NetworkSuggestionEvaluator(WifiNetworkSuggestionsManager networkSuggestionsManager,
	WifiConfigManager wifiConfigManager, LocalLog localLog) {
	mWifiNetworkSuggestionsManager = networkSuggestionsManager;
	mWifiConfigManager = wifiConfigManager;
	mLocalLog = localLog;
	}

	@Override
	public void update(List<ScanDetail> scanDetails) {
	// TODO(b/115504887): This could be used to re-evaluate any temporary blacklists.
	}

	@Override
	public WifiConfiguration evaluateNetworks(List<ScanDetail> scanDetails,
	WifiConfiguration currentNetwork, String currentBssid, boolean connected,
	boolean untrustedNetworkAllowed,
	@NonNull OnConnectableListener onConnectableListener) {
	MatchMetaInfo matchMetaInfo = new MatchMetaInfo();
	for (int i = 0; i < scanDetails.size(); i++) {
	ScanDetail scanDetail = scanDetails.get(i);
	ScanResult scanResult = scanDetail.getScanResult();
	// If the user previously forgot this network, don't select it.
	if (mWifiConfigManager.wasEphemeralNetworkDeleted(
	ScanResultUtil.createQuotedSSID(scanResult.SSID))) {
	mLocalLog.log("Ignoring disabled ephemeral SSID: "
	+ WifiNetworkSelector.toScanId(scanResult));
	continue;
	}
	Set<WifiNetworkSuggestion> matchingNetworkSuggestions =
	mWifiNetworkSuggestionsManager.getNetworkSuggestionsForScanDetail(scanDetail);
	if (matchingNetworkSuggestions == null \|\| matchingNetworkSuggestions.isEmpty()) {
	continue;
	}
	// All matching suggestions have the same network credentials type. So, use any one of
	// them to lookup/add the credentials to WifiConfigManager.
	// Note: Apps could provide different credentials (password, ceritificate) for the same
	// network, need to handle that in the future.
	WifiNetworkSuggestion matchingNetworkSuggestion =
	matchingNetworkSuggestions.stream().findAny().get();
	// Check if we already have a network with the same credentials in WifiConfigManager
	// database. If yes, we should check if the network is currently blacklisted.
	WifiConfiguration wCmConfiguredNetwork =
	mWifiConfigManager.getConfiguredNetwork(
	matchingNetworkSuggestion.wifiConfiguration.configKey());
	if (wCmConfiguredNetwork != null) {
	if (!wCmConfiguredNetwork.getNetworkSelectionStatus().isNetworkEnabled()
	&& !mWifiConfigManager.tryEnableNetwork(wCmConfiguredNetwork.networkId)) {
	mLocalLog.log("Ignoring blacklisted network: "
	+ WifiNetworkSelector.toNetworkString(wCmConfiguredNetwork));
	continue;
	}
	}
	matchMetaInfo.putAll(matchingNetworkSuggestions, wCmConfiguredNetwork, scanDetail);
	}
	// Return early on no match.
	if (matchMetaInfo.isEmpty()) {
	mLocalLog.log("did not see any matching network suggestions.");
	return null;
	}
	// Note: These matched sets should be very small & hence these additional manipulations that
	// follow should not be very expensive.
	PerNetworkSuggestionMatchMetaInfo candidate =
	matchMetaInfo.findConnectableNetworksAndPickBest(onConnectableListener);
	if (candidate == null) { // should never happen.
	Log.wtf(TAG, "Unexepectedly got null");
	return null;
	}
	return candidate.wCmConfiguredNetwork;
	}

	// Add and enable this network to the central database (i.e WifiConfigManager).
	// Returns the copy of WifiConfiguration with the allocated network ID filled in.
	private WifiConfiguration addCandidateToWifiConfigManager(
	@NonNull WifiConfiguration wifiConfiguration, int uid, @NonNull String packageName) {
	// Mark the network ephemeral because we don't want these persisted by WifiConfigManager.
	wifiConfiguration.ephemeral = true;
	wifiConfiguration.fromWifiNetworkSuggestion = true;

	NetworkUpdateResult result =
	mWifiConfigManager.addOrUpdateNetwork(wifiConfiguration, uid, packageName);
	if (!result.isSuccess()) {
	mLocalLog.log("Failed to add network suggestion");
	return null;
	}
	if (!mWifiConfigManager.updateNetworkSelectionStatus(result.getNetworkId(),
	WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLE)) {
	mLocalLog.log("Failed to make network suggestion selectable");
	return null;
	}
	int candidateNetworkId = result.getNetworkId();
	return mWifiConfigManager.getConfiguredNetwork(candidateNetworkId);
	}

	@Override
	public @EvaluatorId int getId() {
	return EVALUATOR_ID_SUGGESTION;
	}

	@Override
	public String getName() {
	return TAG;
	}

	// Container classes to handle book-keeping while we're iterating through the scan list.
	private class PerNetworkSuggestionMatchMetaInfo {
	public final WifiNetworkSuggestion wifiNetworkSuggestion;
	public final ScanDetail matchingScanDetail;
	public WifiConfiguration wCmConfiguredNetwork; // Added to WifiConfigManager.

	PerNetworkSuggestionMatchMetaInfo(@NonNull WifiNetworkSuggestion wifiNetworkSuggestion,
	@Nullable WifiConfiguration wCmConfiguredNetwork,
	@NonNull ScanDetail matchingScanDetail) {
	this.wifiNetworkSuggestion = wifiNetworkSuggestion;
	this.wCmConfiguredNetwork = wCmConfiguredNetwork;
	this.matchingScanDetail = matchingScanDetail;
	}
	}

	private class PerAppMatchMetaInfo {
	public final List<PerNetworkSuggestionMatchMetaInfo> networkInfos = new ArrayList<>();

	/**
	* Add the network suggestion & associated info to this package meta info.
	*/
	public void put(WifiNetworkSuggestion wifiNetworkSuggestion,
	WifiConfiguration matchingWifiConfiguration,
	ScanDetail matchingScanDetail) {
	networkInfos.add(new PerNetworkSuggestionMatchMetaInfo(
	wifiNetworkSuggestion, matchingWifiConfiguration, matchingScanDetail));
	}

	/**
	* Pick the highest priority networks among the current match info candidates for this
	* app.
	*/
	public List<PerNetworkSuggestionMatchMetaInfo> getHighestPriorityNetworks() {
	// Partition the list to a map of network suggestions keyed in by the priorities.
	// There can be multiple networks with the same priority, hence a list in the value.
	Map<Integer, List<PerNetworkSuggestionMatchMetaInfo>> matchedNetworkInfosPerPriority =
	networkInfos.stream()
	.collect(Collectors.toMap(
	e -> e.wifiNetworkSuggestion.wifiConfiguration.priority,
	e -> Arrays.asList(e),
	(v1, v2) -> { // concatenate networks with the same priority.
	List<PerNetworkSuggestionMatchMetaInfo> concatList =
	new ArrayList<>(v1);
	concatList.addAll(v2);
	return concatList;
	}));
	if (matchedNetworkInfosPerPriority.isEmpty()) { // should never happen.
	Log.wtf(TAG, "Unexepectedly got empty");
	return Collections.EMPTY_LIST;
	}
	// Return the list associated with the highest priority value.
	return matchedNetworkInfosPerPriority.get(Collections.max(
	matchedNetworkInfosPerPriority.keySet()));
	}
	}

	private class MatchMetaInfo {
	private Map<String, PerAppMatchMetaInfo> mAppInfos = new HashMap<>();

	/**
	* Add all the network suggestion & associated info.
	*/
	public void putAll(Set<WifiNetworkSuggestion> wifiNetworkSuggestions,
	WifiConfiguration wCmConfiguredNetwork,
	ScanDetail matchingScanDetail) {
	// Separate the suggestions into buckets for each app to allow sorting based on
	// priorities set by app.
	for (WifiNetworkSuggestion wifiNetworkSuggestion : wifiNetworkSuggestions) {
	PerAppMatchMetaInfo appInfo = mAppInfos.computeIfAbsent(
	wifiNetworkSuggestion.suggestorPackageName, k -> new PerAppMatchMetaInfo());
	appInfo.put(wifiNetworkSuggestion, wCmConfiguredNetwork, matchingScanDetail);
	}
	}

	/**
	* Are there any matched candidates?
	*/
	public boolean isEmpty() {
	return mAppInfos.isEmpty();
	}

	/**
	* Find all the connectable networks and pick the best network among the current match info
	* candidates.
	*
	* Among the highest priority suggestions from different packages, choose the suggestion
	* with the highest RSSI.
	* Note: This should need to be replaced by a more sophisticated algorithm.
	*/
	public PerNetworkSuggestionMatchMetaInfo findConnectableNetworksAndPickBest(
	@NonNull OnConnectableListener onConnectableListener) {
	List<PerNetworkSuggestionMatchMetaInfo> allMatchedNetworkInfos = new ArrayList<>();
	for (PerAppMatchMetaInfo appInfo : mAppInfos.values()) {
	List<PerNetworkSuggestionMatchMetaInfo> matchedNetworkInfos =
	appInfo.getHighestPriorityNetworks();
	for (PerNetworkSuggestionMatchMetaInfo matchedNetworkInfo : matchedNetworkInfos) {
	// if the network does not already exist in WifiConfigManager, add now.
	if (matchedNetworkInfo.wCmConfiguredNetwork == null) {
	matchedNetworkInfo.wCmConfiguredNetwork = addCandidateToWifiConfigManager(
	matchedNetworkInfo.wifiNetworkSuggestion.wifiConfiguration,
	matchedNetworkInfo.wifiNetworkSuggestion.suggestorUid,
	matchedNetworkInfo.wifiNetworkSuggestion.suggestorPackageName);
	if (matchedNetworkInfo.wCmConfiguredNetwork == null) continue;
	mLocalLog.log(String.format("network suggestion candidate %s (new)",
	WifiNetworkSelector.toNetworkString(
	matchedNetworkInfo.wCmConfiguredNetwork)));
	} else {
	mLocalLog.log(String.format("network suggestion candidate %s (existing)",
	WifiNetworkSelector.toNetworkString(
	matchedNetworkInfo.wCmConfiguredNetwork)));
	}
	allMatchedNetworkInfos.add(matchedNetworkInfo);
	// Invoke onConnectable for the best networks from each app.
	onConnectableListener.onConnectable(
	matchedNetworkInfo.matchingScanDetail,
	matchedNetworkInfo.wCmConfiguredNetwork,
	0);
	}
	}
	PerNetworkSuggestionMatchMetaInfo networkInfo = allMatchedNetworkInfos
	.stream()
	.max(Comparator.comparing(e -> e.matchingScanDetail.getScanResult().level))
	.orElse(null);
	if (networkInfo == null) { // should never happen.
	Log.wtf(TAG, "Unexepectedly got null");
	return null;
	}
	return networkInfo;
	}
	}

	}