Merge changes I0e41dc95,If170fd4e into rvc-dev

* changes:
  Add overlay to control if ignore saved open network
  [Suggestion] Ignore open saved network

7 files changed, 418 insertions, 11 deletions

diff --git a/service/java/com/android/server/wifi/SavedNetworkNominator.java b/service/java/com/android/server/wifi/SavedNetworkNominator.java
index a3039096e..6480237ef 100644
--- a/service/java/com/android/server/wifi/SavedNetworkNominator.java
+++ b/service/java/com/android/server/wifi/SavedNetworkNominator.java
@@ -39,16 +39,19 @@ public class SavedNetworkNominator implements WifiNetworkSelector.NetworkNominat
     private final WifiCarrierInfoManager mWifiCarrierInfoManager;
     private final PasspointNetworkNominateHelper mPasspointNetworkNominateHelper;
     private final WifiPermissionsUtil mWifiPermissionsUtil;
+    private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
 
     SavedNetworkNominator(WifiConfigManager configManager,
             PasspointNetworkNominateHelper nominateHelper, LocalLog localLog,
             WifiCarrierInfoManager wifiCarrierInfoManager,
-            WifiPermissionsUtil wifiPermissionsUtil) {
+            WifiPermissionsUtil wifiPermissionsUtil,
+            WifiNetworkSuggestionsManager wifiNetworkSuggestionsManager) {
         mWifiConfigManager = configManager;
         mPasspointNetworkNominateHelper = nominateHelper;
         mLocalLog = localLog;
         mWifiCarrierInfoManager = wifiCarrierInfoManager;
         mWifiPermissionsUtil = wifiPermissionsUtil;
+        mWifiNetworkSuggestionsManager = wifiNetworkSuggestionsManager;
     }
 
     private void localLog(String log) {
@@ -155,6 +158,14 @@ public class SavedNetworkNominator implements WifiNetworkSelector.NetworkNominat
                 continue;
             }
 
+            if (mWifiNetworkSuggestionsManager
+                    .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network,
+                            scanDetails)) {
+                localLog("Open Network " + WifiNetworkSelector.toNetworkString(network)
+                        + " has a secure network suggestion from same carrier.");
+                continue;
+            }
+
             onConnectableListener.onConnectable(scanDetail,
                     mWifiConfigManager.getConfiguredNetwork(network.networkId));
         }
diff --git a/service/java/com/android/server/wifi/WifiInjector.java b/service/java/com/android/server/wifi/WifiInjector.java
index b56d37a2c..5dc3296c9 100644
--- a/service/java/com/android/server/wifi/WifiInjector.java
+++ b/service/java/com/android/server/wifi/WifiInjector.java
@@ -310,7 +310,7 @@ public class WifiInjector {
                         mConnectivityLocalLog);
         mSavedNetworkNominator = new SavedNetworkNominator(
                 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager,
-                mWifiPermissionsUtil);
+                mWifiPermissionsUtil, mWifiNetworkSuggestionsManager);
         mNetworkSuggestionNominator = new NetworkSuggestionNominator(mWifiNetworkSuggestionsManager,
                 mWifiConfigManager, nominateHelper, mConnectivityLocalLog, mWifiCarrierInfoManager);
         mScoredNetworkNominator = new ScoredNetworkNominator(mContext, wifiHandler,
diff --git a/service/java/com/android/server/wifi/WifiNetworkSuggestionsManager.java b/service/java/com/android/server/wifi/WifiNetworkSuggestionsManager.java
index 685df0757..b83af52f2 100644
--- a/service/java/com/android/server/wifi/WifiNetworkSuggestionsManager.java
+++ b/service/java/com/android/server/wifi/WifiNetworkSuggestionsManager.java
@@ -1967,19 +1967,23 @@ public class WifiNetworkSuggestionsManager {
             if (suggestion == null || suggestion.wifiConfiguration == null) {
                 continue;
             }
-            if (suggestion.passpointConfiguration != null) {
-                filteredScanResults.put(suggestion,
-                        mWifiInjector.getPasspointManager().getMatchingScanResults(
-                                suggestion.passpointConfiguration, scanResults));
-            } else {
-                filteredScanResults.put(suggestion,
-                        getMatchingScanResults(suggestion.wifiConfiguration, scanResults));
-            }
+            filteredScanResults.put(suggestion,
+                    getMatchingScanResultsForSuggestion(suggestion, scanResults));
         }
 
         return filteredScanResults;
     }
 
+    private List<ScanResult> getMatchingScanResultsForSuggestion(WifiNetworkSuggestion suggestion,
+            List<ScanResult> scanResults) {
+        if (suggestion.passpointConfiguration != null) {
+            return mWifiInjector.getPasspointManager().getMatchingScanResults(
+                    suggestion.passpointConfiguration, scanResults);
+        } else {
+            return getMatchingScanResults(suggestion.wifiConfiguration, scanResults);
+        }
+    }
+
     /**
      * Get the filtered ScanResults which may be authenticated by the {@link WifiConfiguration}.
      * @param wifiConfiguration The instance of {@link WifiConfiguration}
@@ -2013,6 +2017,101 @@ public class WifiNetworkSuggestionsManager {
     }
 
     /**
+     * When a saved open network has a same network suggestion which is from app has
+     * NETWORK_CARRIER_PROVISIONING permission, also that app suggested secure network suggestion
+     * for same carrier with higher or equal priority and Auto-Join enabled, also that secure
+     * network is in the range. The saved open network will be ignored during the network selection.
+     * TODO (b/142035508): revert all these changes once we build infra needed to solve this.
+     * @param configuration Saved open network to check if it should be ignored.
+     * @param scanDetails Available ScanDetail nearby.
+     * @return True if the open network should be ignored, false otherwise.
+     */
+    public boolean shouldBeIgnoredBySecureSuggestionFromSameCarrier(
+            @NonNull WifiConfiguration configuration, List<ScanDetail> scanDetails) {
+        if (!mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable)) {
+            return false;
+        }
+        if (configuration == null || scanDetails == null || !configuration.isOpenNetwork()) {
+            return false;
+        }
+        Set<ExtendedWifiNetworkSuggestion> matchedExtSuggestions =
+                getNetworkSuggestionsForWifiConfiguration(configuration, null);
+        if (matchedExtSuggestions == null || matchedExtSuggestions.isEmpty()) {
+            return false;
+        }
+        matchedExtSuggestions = matchedExtSuggestions.stream().filter(ewns ->
+                mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(ewns.perAppInfo.uid))
+                .collect(Collectors.toSet());
+        if (matchedExtSuggestions.isEmpty()) {
+            return false;
+        }
+        for (ExtendedWifiNetworkSuggestion ewns : matchedExtSuggestions) {
+            if (hasSecureSuggestionFromSameCarrierAvailable(ewns, scanDetails)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasSecureSuggestionFromSameCarrierAvailable(
+            ExtendedWifiNetworkSuggestion extendedWifiNetworkSuggestion,
+            List<ScanDetail> scanDetails) {
+        boolean isOpenSuggestionMetered = WifiConfiguration.isMetered(
+                extendedWifiNetworkSuggestion.wns.wifiConfiguration, null);
+        Set<ExtendedWifiNetworkSuggestion> secureExtSuggestions = new HashSet<>();
+        for (ExtendedWifiNetworkSuggestion ewns : extendedWifiNetworkSuggestion.perAppInfo
+                .extNetworkSuggestions) {
+            // Open network and auto-join disable suggestion, ignore.
+            if (isOpenSuggestion(ewns) || !ewns.isAutojoinEnabled) {
+                continue;
+            }
+            // From different carrier as open suggestion, ignore.
+            if (getCarrierIdFromSuggestion(ewns)
+                    != getCarrierIdFromSuggestion(extendedWifiNetworkSuggestion)) {
+                continue;
+            }
+            // Secure and open has different meterness, ignore
+            if (WifiConfiguration.isMetered(ewns.wns.wifiConfiguration, null)
+                    != isOpenSuggestionMetered) {
+                continue;
+            }
+            // Low priority than open suggestion, ignore.
+            if (ewns.wns.wifiConfiguration.priority
+                    < extendedWifiNetworkSuggestion.wns.wifiConfiguration.priority) {
+                continue;
+            }
+            WifiConfiguration wcmConfig = mWifiConfigManager
+                    .getConfiguredNetwork(ewns.wns.wifiConfiguration.getKey());
+            // Network selection is disabled, ignore.
+            if (wcmConfig != null && !wcmConfig.getNetworkSelectionStatus().isNetworkEnabled()) {
+                continue;
+            }
+            secureExtSuggestions.add(ewns);
+        }
+
+        if (secureExtSuggestions.isEmpty()) {
+            return false;
+        }
+        List<ScanResult> scanResults = scanDetails.stream().map(ScanDetail::getScanResult)
+                .collect(Collectors.toList());
+        // Check if the secure suggestion is in the range.
+        for (ExtendedWifiNetworkSuggestion ewns : secureExtSuggestions) {
+            if (!getMatchingScanResultsForSuggestion(ewns.wns, scanResults).isEmpty()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isOpenSuggestion(ExtendedWifiNetworkSuggestion extendedWifiNetworkSuggestion) {
+        if (extendedWifiNetworkSuggestion.wns.passpointConfiguration != null) {
+            return false;
+        }
+        return extendedWifiNetworkSuggestion.wns.wifiConfiguration.isOpenNetwork();
+    }
+
+    /**
      * Dump of {@link WifiNetworkSuggestionsManager}.
      */
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
diff --git a/service/res/values/config.xml b/service/res/values/config.xml
index c58ab196b..5d8a47ca9 100644
--- a/service/res/values/config.xml
+++ b/service/res/values/config.xml
@@ -412,4 +412,6 @@
          cause the wifi stack to turn wifi off and wait for user input.
          Set to 0 to turn off recovery attempts and always turn off wifi on failures -->
     <integer translatable="false" name="config_wifiMaxNativeFailureSelfRecoveryPerHour">2</integer>
+    <!-- Ignore the open saved network if from carrier provisioning app, there is a same open suggestion and a secure suggestion from same carrier available -->
+    <bool translatable="false" name="config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable">true</bool>
 </resources>
diff --git a/service/res/values/overlayable.xml b/service/res/values/overlayable.xml
index 687b6b9e8..60454728d 100644
--- a/service/res/values/overlayable.xml
+++ b/service/res/values/overlayable.xml
@@ -129,6 +129,7 @@
           <item type="bool" name="config_wifiSaeUpgradeEnabled" />
           <item type="bool" name="config_wifiSaeUpgradeOffloadEnabled" />
           <item type="integer" name="config_wifiMaxNativeFailureSelfRecoveryPerHour" />
+          <item type="bool" name="config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable" />
           <!-- Params from config.xml that can be overlayed -->
 
           <!-- Params from strings.xml that can be overlayed -->
diff --git a/tests/wifitests/src/com/android/server/wifi/SavedNetworkNominatorTest.java b/tests/wifitests/src/com/android/server/wifi/SavedNetworkNominatorTest.java
index 839b2e5fe..2a42c77e5 100644
--- a/tests/wifitests/src/com/android/server/wifi/SavedNetworkNominatorTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/SavedNetworkNominatorTest.java
@@ -54,12 +54,15 @@ public class SavedNetworkNominatorTest extends WifiBaseTest {
         mLocalLog = new LocalLog(512);
         mSavedNetworkNominator = new SavedNetworkNominator(mWifiConfigManager,
                 mPasspointNetworkNominateHelper, mLocalLog, mWifiCarrierInfoManager,
-                mWifiPermissionsUtil);
+                mWifiPermissionsUtil, mWifiNetworkSuggestionsManager);
         when(mWifiCarrierInfoManager.isSimPresent(anyInt())).thenReturn(true);
         when(mWifiCarrierInfoManager.getBestMatchSubscriptionId(any())).thenReturn(VALID_SUBID);
         when(mWifiCarrierInfoManager.requiresImsiEncryption(VALID_SUBID)).thenReturn(true);
         when(mWifiCarrierInfoManager.isImsiEncryptionInfoAvailable(anyInt())).thenReturn(true);
         when(mWifiCarrierInfoManager.getMatchingSubId(TEST_CARRIER_ID)).thenReturn(VALID_SUBID);
+        when(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(any(), any()))
+                .thenReturn(false);
 
     }
 
@@ -84,6 +87,7 @@ public class SavedNetworkNominatorTest extends WifiBaseTest {
     @Mock private WifiCarrierInfoManager mWifiCarrierInfoManager;
     @Mock private PasspointNetworkNominateHelper mPasspointNetworkNominateHelper;
     @Mock private WifiPermissionsUtil mWifiPermissionsUtil;
+    @Mock private WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
     private LocalLog mLocalLog;
 
     /**
@@ -307,4 +311,34 @@ public class SavedNetworkNominatorTest extends WifiBaseTest {
                 .thenReturn(false);
         when(mWifiPermissionsUtil.checkNetworkSettingsPermission(anyInt())).thenReturn(true);
     }
+
+    @Test
+    public void testIgnoreOpenNetworkWithSameNetworkSuggestionHasSecureNetworkFromSameCarrier() {
+        String[] ssids = {"\"test1\""};
+        String[] bssids = {"6c:f3:7f:ae:8c:f3"};
+        int[] freqs = {2470};
+        String[] caps = {"[ESS]"};
+        int[] levels = {RSSI_LEVEL};
+        int[] securities = {SECURITY_NONE};
+
+        ScanDetailsAndWifiConfigs scanDetailsAndConfigs =
+                WifiNetworkSelectorTestUtil.setupScanDetailsAndConfigStore(ssids, bssids,
+                        freqs, caps, levels, securities, mWifiConfigManager, mClock);
+        List<ScanDetail> scanDetails = scanDetailsAndConfigs.getScanDetails();
+        WifiConfiguration[] savedConfigs = scanDetailsAndConfigs.getWifiConfigs();
+
+        when(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(any(), any()))
+                .thenReturn(true);
+        mSavedNetworkNominator.nominateNetworks(scanDetails,
+                null, null, true, false, mOnConnectableListener);
+        verify(mOnConnectableListener, never()).onConnectable(any(), any());
+
+        when(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(any(), any()))
+                .thenReturn(false);
+        mSavedNetworkNominator.nominateNetworks(scanDetails,
+                null, null, true, false, mOnConnectableListener);
+        verify(mOnConnectableListener).onConnectable(any(), any());
+    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSuggestionsManagerTest.java b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSuggestionsManagerTest.java
index 8fa2fa1aa..79c9c0a3e 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiNetworkSuggestionsManagerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiNetworkSuggestionsManagerTest.java
@@ -3719,6 +3719,266 @@ public class WifiNetworkSuggestionsManagerTest extends WifiBaseTest {
         verify(listener).onSuggestionsRemoved(networkSuggestionList1);
     }
 
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithoutSameOpenSuggestion() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Without same open suggestion in the framework, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithoutSecureSuggestion() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Without secure suggestion in the framework, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredWithoutCarrierProvisioningPermission() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiCarrierInfoManager.getCarrierIdForPackageWithCarrierPrivileges(anyString()))
+                .thenReturn(TEST_CARRIER_ID);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Without CarrierProvisioningPermission, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromDifferentCarrierId() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = VALID_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Open and secure suggestions have different carrierId, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithAutojoinDisabled() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, false);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Secure suggestions is auto-join disabled, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithDifferentMeterness() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        network2.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Secure suggestions is auto-join disabled, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithNetworkDisabled() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        WifiConfiguration wcmConfig = new WifiConfiguration(network2);
+        WifiConfiguration.NetworkSelectionStatus status =
+                mock(WifiConfiguration.NetworkSelectionStatus.class);
+        when(status.isNetworkEnabled()).thenReturn(false);
+        wcmConfig.setNetworkSelectionStatus(status);
+        when(mWifiConfigManager.getConfiguredNetwork(network2.getKey())).thenReturn(wcmConfig);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Secure suggestions is auto-join disabled, should not be ignored.
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldNotBeIgnoredBySecureSuggestionFromSameCarrierWithOverlayFalse() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(false);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Both open and secure suggestions with same carrierId,
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertFalse(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
+    @Test
+    public void testShouldBeIgnoredBySecureSuggestionFromSameCarrier() {
+        when(mResources.getBoolean(
+                R.bool.config_wifiIgnoreOpenSavedNetworkWhenSecureSuggestionAvailable))
+                .thenReturn(true);
+        when(mWifiPermissionsUtil.checkNetworkCarrierProvisioningPermission(anyInt()))
+                .thenReturn(true);
+        WifiConfiguration network1 = WifiConfigurationTestUtil.createOpenNetwork();
+        ScanDetail scanDetail1 = createScanDetailForNetwork(network1);
+        network1.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion1 = new WifiNetworkSuggestion(
+                network1, null, false, false, true, true);
+        WifiConfiguration network2 = WifiConfigurationTestUtil.createPskNetwork();
+        ScanDetail scanDetail2 = createScanDetailForNetwork(network2);
+        network2.carrierId = TEST_CARRIER_ID;
+        WifiNetworkSuggestion suggestion2 = new WifiNetworkSuggestion(
+                network2, null, false, false, true, true);
+
+        List<ScanDetail> scanDetails = Arrays.asList(scanDetail1, scanDetail2);
+        // Both open and secure suggestions with same carrierId,
+        List<WifiNetworkSuggestion> suggestionList = Arrays.asList(suggestion1, suggestion2);
+        assertEquals(WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS,
+                mWifiNetworkSuggestionsManager.add(suggestionList, TEST_UID_1,
+                        TEST_PACKAGE_1, TEST_FEATURE));
+        assertTrue(mWifiNetworkSuggestionsManager
+                .shouldBeIgnoredBySecureSuggestionFromSameCarrier(network1, scanDetails));
+    }
+
     /**
      * Helper function for creating a test configuration with user credential.
      *