759 lines
32 KiB
Kotlin
759 lines
32 KiB
Kotlin
/*
|
|
* Copyright (C) 2021 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 android.net
|
|
|
|
import android.content.pm.PackageManager
|
|
import android.net.ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE
|
|
import android.net.ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE_AVOID
|
|
import android.net.ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE_IGNORE
|
|
import android.net.ConnectivitySettingsManager.CAPTIVE_PORTAL_MODE_PROMPT
|
|
import android.net.ConnectivitySettingsManager.CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS
|
|
import android.net.ConnectivitySettingsManager.DATA_ACTIVITY_TIMEOUT_MOBILE
|
|
import android.net.ConnectivitySettingsManager.DATA_ACTIVITY_TIMEOUT_WIFI
|
|
import android.net.ConnectivitySettingsManager.DNS_RESOLVER_MAX_SAMPLES
|
|
import android.net.ConnectivitySettingsManager.DNS_RESOLVER_MIN_SAMPLES
|
|
import android.net.ConnectivitySettingsManager.DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS
|
|
import android.net.ConnectivitySettingsManager.DNS_RESOLVER_SUCCESS_THRESHOLD_PERCENT
|
|
import android.net.ConnectivitySettingsManager.MOBILE_DATA_ALWAYS_ON
|
|
import android.net.ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI
|
|
import android.net.ConnectivitySettingsManager.NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT
|
|
import android.net.ConnectivitySettingsManager.NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS
|
|
import android.net.ConnectivitySettingsManager.PRIVATE_DNS_DEFAULT_MODE
|
|
import android.net.ConnectivitySettingsManager.PRIVATE_DNS_MODE_OFF
|
|
import android.net.ConnectivitySettingsManager.PRIVATE_DNS_MODE_OPPORTUNISTIC
|
|
import android.net.ConnectivitySettingsManager.WIFI_ALWAYS_REQUESTED
|
|
import android.net.ConnectivitySettingsManager.getCaptivePortalMode
|
|
import android.net.ConnectivitySettingsManager.getConnectivityKeepPendingIntentDuration
|
|
import android.net.ConnectivitySettingsManager.getDnsResolverSampleRanges
|
|
import android.net.ConnectivitySettingsManager.getDnsResolverSampleValidityDuration
|
|
import android.net.ConnectivitySettingsManager.getDnsResolverSuccessThresholdPercent
|
|
import android.net.ConnectivitySettingsManager.getIngressRateLimitInBytesPerSecond
|
|
import android.net.ConnectivitySettingsManager.getMobileDataActivityTimeout
|
|
import android.net.ConnectivitySettingsManager.getMobileDataAlwaysOn
|
|
import android.net.ConnectivitySettingsManager.getNetworkAvoidBadWifi
|
|
import android.net.ConnectivitySettingsManager.getNetworkSwitchNotificationMaximumDailyCount
|
|
import android.net.ConnectivitySettingsManager.getNetworkSwitchNotificationRateDuration
|
|
import android.net.ConnectivitySettingsManager.getPrivateDnsDefaultMode
|
|
import android.net.ConnectivitySettingsManager.getWifiAlwaysRequested
|
|
import android.net.ConnectivitySettingsManager.getWifiDataActivityTimeout
|
|
import android.net.ConnectivitySettingsManager.setCaptivePortalMode
|
|
import android.net.ConnectivitySettingsManager.setConnectivityKeepPendingIntentDuration
|
|
import android.net.ConnectivitySettingsManager.setDnsResolverSampleRanges
|
|
import android.net.ConnectivitySettingsManager.setDnsResolverSampleValidityDuration
|
|
import android.net.ConnectivitySettingsManager.setDnsResolverSuccessThresholdPercent
|
|
import android.net.ConnectivitySettingsManager.setIngressRateLimitInBytesPerSecond
|
|
import android.net.ConnectivitySettingsManager.setMobileDataActivityTimeout
|
|
import android.net.ConnectivitySettingsManager.setMobileDataAlwaysOn
|
|
import android.net.ConnectivitySettingsManager.setNetworkAvoidBadWifi
|
|
import android.net.ConnectivitySettingsManager.setNetworkSwitchNotificationMaximumDailyCount
|
|
import android.net.ConnectivitySettingsManager.setNetworkSwitchNotificationRateDuration
|
|
import android.net.ConnectivitySettingsManager.setPrivateDnsDefaultMode
|
|
import android.net.ConnectivitySettingsManager.setWifiAlwaysRequested
|
|
import android.net.ConnectivitySettingsManager.setWifiDataActivityTimeout
|
|
import android.net.ConnectivitySettingsManager.shouldShowAvoidBadWifiToggle
|
|
import android.net.platform.flags.Flags
|
|
import android.os.Build
|
|
import android.os.PersistableBundle
|
|
import android.platform.test.annotations.AppModeFull
|
|
import android.platform.test.annotations.RequiresFlagsEnabled
|
|
import android.platform.test.flag.junit.CheckFlagsRule
|
|
import android.platform.test.flag.junit.DeviceFlagsValueProvider
|
|
import android.provider.Settings
|
|
import android.telephony.CarrierConfigManager
|
|
import android.telephony.SubscriptionManager
|
|
import android.util.Range
|
|
import androidx.test.InstrumentationRegistry
|
|
import androidx.test.filters.SmallTest
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.getAvoidBadWifiSettingKey
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.getNetworkAvoidBadWifiSetting
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.getNetworkLegacyGlobalAvoidBadWifiSetting
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.getPrivateDnsModeAsString
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.setNetworkAvoidBadWifiSetting
|
|
import com.android.net.module.util.ConnectivitySettingsUtils.setNetworkLegacyGlobalAvoidBadWifiSetting
|
|
import com.android.testutils.ConnectivityModuleTest
|
|
import com.android.testutils.DevSdkIgnoreRule
|
|
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
|
|
import com.android.testutils.DevSdkIgnoreRunner
|
|
import com.android.testutils.com.android.testutils.CarrierConfigRule
|
|
import java.time.Duration
|
|
import java.util.Objects
|
|
import junit.framework.Assert.assertEquals
|
|
import junit.framework.Assert.assertFalse
|
|
import junit.framework.Assert.assertTrue
|
|
import kotlin.test.assertFailsWith
|
|
import org.junit.Assume.assumeTrue
|
|
import org.junit.Rule
|
|
import org.junit.Test
|
|
import org.junit.runner.RunWith
|
|
|
|
/**
|
|
* Tests for [ConnectivitySettingsManager].
|
|
*
|
|
* Build, install and run with:
|
|
* atest android.net.ConnectivitySettingsManagerTest
|
|
*/
|
|
@RunWith(DevSdkIgnoreRunner::class)
|
|
@IgnoreUpTo(Build.VERSION_CODES.R)
|
|
@SmallTest
|
|
@AppModeFull(reason = "WRITE_SECURE_SETTINGS permission can't be granted to instant apps")
|
|
class ConnectivitySettingsManagerTest {
|
|
private val instrumentation = InstrumentationRegistry.getInstrumentation()
|
|
private val context = instrumentation.context
|
|
private val resolver = context.contentResolver
|
|
|
|
private val defaultDuration = Duration.ofSeconds(0L)
|
|
private val testTime1 = 5L
|
|
private val testTime2 = 10L
|
|
private val settingsTypeGlobal = "global"
|
|
private val settingsTypeSecure = "secure"
|
|
|
|
private val defaultSubId = SubscriptionManager.getDefaultSubscriptionId()
|
|
|
|
/*** Reset setting value or delete setting if the setting was not existed before testing. */
|
|
private fun resetSettings(names: Array<String>, type: String, values: Array<String?>) {
|
|
for (i in names.indices) {
|
|
if (Objects.equals(values[i], null)) {
|
|
instrumentation.uiAutomation.executeShellCommand(
|
|
"settings delete $type ${names[i]}"
|
|
)
|
|
} else {
|
|
if (settingsTypeSecure.equals(type)) {
|
|
Settings.Secure.putString(resolver, names[i], values[i])
|
|
} else {
|
|
Settings.Global.putString(resolver, names[i], values[i])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun assertAvoidBadWifiSettingEquals(expect: Array<Pair<Int, String?>>) {
|
|
for ((subId, value) in expect) {
|
|
assertEquals(value, getNetworkAvoidBadWifiSetting(context, subId))
|
|
}
|
|
}
|
|
|
|
fun <T> testIntSetting(
|
|
names: Array<String>,
|
|
type: String,
|
|
value1: T,
|
|
value2: T,
|
|
getter: () -> T,
|
|
setter: (value: T) -> Unit,
|
|
testIntValues: IntArray
|
|
) {
|
|
val originals: Array<String?> = Array(names.size) { i ->
|
|
if (settingsTypeSecure.equals(type)) {
|
|
Settings.Secure.getString(resolver, names[i])
|
|
} else {
|
|
Settings.Global.getString(resolver, names[i])
|
|
}
|
|
}
|
|
|
|
try {
|
|
for (i in names.indices) {
|
|
if (settingsTypeSecure.equals(type)) {
|
|
Settings.Secure.putString(resolver, names[i], testIntValues[i].toString())
|
|
} else {
|
|
Settings.Global.putString(resolver, names[i], testIntValues[i].toString())
|
|
}
|
|
}
|
|
assertEquals(value1, getter())
|
|
|
|
setter(value2)
|
|
assertEquals(value2, getter())
|
|
} finally {
|
|
resetSettings(names, type, originals)
|
|
}
|
|
}
|
|
|
|
fun overrideAvoidBadWifiCarrierConfig(
|
|
avoidBadWifi: Boolean? = null,
|
|
showAvoidBadWifiToggle: Boolean? = null
|
|
) {
|
|
// Override carrier config to ignore entitlement check.
|
|
val bundle = PersistableBundle()
|
|
|
|
avoidBadWifi?.let { value ->
|
|
bundle.putBoolean(CarrierConfigManager.KEY_AVOID_BAD_WIFI_BOOL, value)
|
|
}
|
|
|
|
showAvoidBadWifiToggle?.let { value ->
|
|
bundle.putBoolean(CarrierConfigManager.KEY_SHOW_AVOID_BAD_WIFI_TOGGLE_BOOL, value)
|
|
}
|
|
|
|
mCarrierConfigRule.addConfigOverrides(defaultSubId, bundle)
|
|
}
|
|
|
|
@get:Rule
|
|
val mCarrierConfigRule: CarrierConfigRule = CarrierConfigRule()
|
|
|
|
@get:Rule
|
|
val ignoreRule = DevSdkIgnoreRule()
|
|
|
|
@get:Rule
|
|
val checkFlagsRule: CheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule()!!
|
|
|
|
@Test
|
|
fun testMobileDataActivityTimeout() {
|
|
testIntSetting(
|
|
names = arrayOf(DATA_ACTIVITY_TIMEOUT_MOBILE),
|
|
type = settingsTypeGlobal,
|
|
value1 = Duration.ofSeconds(testTime1),
|
|
value2 = Duration.ofSeconds(testTime2),
|
|
getter = { getMobileDataActivityTimeout(context, defaultDuration) },
|
|
setter = { setMobileDataActivityTimeout(context, it) },
|
|
testIntValues = intArrayOf(testTime1.toInt())
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun testWifiDataActivityTimeout() {
|
|
testIntSetting(
|
|
names = arrayOf(DATA_ACTIVITY_TIMEOUT_WIFI),
|
|
type = settingsTypeGlobal,
|
|
value1 = Duration.ofSeconds(testTime1),
|
|
value2 = Duration.ofSeconds(testTime2),
|
|
getter = { getWifiDataActivityTimeout(context, defaultDuration) },
|
|
setter = { setWifiDataActivityTimeout(context, it) },
|
|
testIntValues = intArrayOf(testTime1.toInt())
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun testDnsResolverSampleValidityDuration() {
|
|
testIntSetting(
|
|
names = arrayOf(DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS),
|
|
type = settingsTypeGlobal,
|
|
value1 = Duration.ofSeconds(testTime1),
|
|
value2 = Duration.ofSeconds(testTime2),
|
|
getter = { getDnsResolverSampleValidityDuration(context, defaultDuration) },
|
|
setter = { setDnsResolverSampleValidityDuration(context, it) },
|
|
testIntValues = intArrayOf(testTime1.toInt())
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setDnsResolverSampleValidityDuration(context, Duration.ofSeconds(-1L)) }
|
|
}
|
|
|
|
@Test
|
|
fun testDnsResolverSuccessThresholdPercent() {
|
|
testIntSetting(
|
|
names = arrayOf(DNS_RESOLVER_SUCCESS_THRESHOLD_PERCENT),
|
|
type = settingsTypeGlobal,
|
|
value1 = 5,
|
|
value2 = 10,
|
|
getter = { getDnsResolverSuccessThresholdPercent(context, 0 /* def */) },
|
|
setter = { setDnsResolverSuccessThresholdPercent(context, it) },
|
|
testIntValues = intArrayOf(5)
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setDnsResolverSuccessThresholdPercent(context, -1) }
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setDnsResolverSuccessThresholdPercent(context, 120) }
|
|
}
|
|
|
|
@Test
|
|
fun testDnsResolverSampleRanges() {
|
|
testIntSetting(
|
|
names = arrayOf(DNS_RESOLVER_MIN_SAMPLES, DNS_RESOLVER_MAX_SAMPLES),
|
|
type = settingsTypeGlobal,
|
|
value1 = Range(1, 63),
|
|
value2 = Range(2, 62),
|
|
getter = { getDnsResolverSampleRanges(context) },
|
|
setter = { setDnsResolverSampleRanges(context, it) },
|
|
testIntValues = intArrayOf(1, 63)
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setDnsResolverSampleRanges(context, Range(-1, 62)) }
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setDnsResolverSampleRanges(context, Range(2, 65)) }
|
|
}
|
|
|
|
@Test
|
|
fun testNetworkSwitchNotificationMaximumDailyCount() {
|
|
testIntSetting(
|
|
names = arrayOf(NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT),
|
|
type = settingsTypeGlobal,
|
|
value1 = 5,
|
|
value2 = 15,
|
|
getter = { getNetworkSwitchNotificationMaximumDailyCount(context, 0 /* def */) },
|
|
setter = { setNetworkSwitchNotificationMaximumDailyCount(context, it) },
|
|
testIntValues = intArrayOf(5)
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setNetworkSwitchNotificationMaximumDailyCount(context, -1) }
|
|
}
|
|
|
|
@Test
|
|
fun testNetworkSwitchNotificationRateDuration() {
|
|
testIntSetting(
|
|
names = arrayOf(NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS),
|
|
type = settingsTypeGlobal,
|
|
value1 = Duration.ofMillis(testTime1),
|
|
value2 = Duration.ofMillis(testTime2),
|
|
getter = { getNetworkSwitchNotificationRateDuration(context, defaultDuration) },
|
|
setter = { setNetworkSwitchNotificationRateDuration(context, it) },
|
|
testIntValues = intArrayOf(testTime1.toInt())
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setNetworkSwitchNotificationRateDuration(context, Duration.ofMillis(-1L)) }
|
|
}
|
|
|
|
@Test
|
|
fun testCaptivePortalMode() {
|
|
testIntSetting(
|
|
names = arrayOf(CAPTIVE_PORTAL_MODE),
|
|
type = settingsTypeGlobal,
|
|
value1 = CAPTIVE_PORTAL_MODE_AVOID,
|
|
value2 = CAPTIVE_PORTAL_MODE_PROMPT,
|
|
getter = { getCaptivePortalMode(context, CAPTIVE_PORTAL_MODE_IGNORE) },
|
|
setter = { setCaptivePortalMode(context, it) },
|
|
testIntValues = intArrayOf(CAPTIVE_PORTAL_MODE_AVOID)
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setCaptivePortalMode(context, 5 /* mode */) }
|
|
}
|
|
|
|
@Test
|
|
fun testPrivateDnsDefaultMode() {
|
|
val original = Settings.Global.getString(resolver, PRIVATE_DNS_DEFAULT_MODE)
|
|
|
|
try {
|
|
val mode = getPrivateDnsModeAsString(PRIVATE_DNS_MODE_OPPORTUNISTIC)
|
|
Settings.Global.putString(resolver, PRIVATE_DNS_DEFAULT_MODE, mode)
|
|
assertEquals(mode, getPrivateDnsDefaultMode(context))
|
|
|
|
setPrivateDnsDefaultMode(context, PRIVATE_DNS_MODE_OFF)
|
|
assertEquals(
|
|
getPrivateDnsModeAsString(PRIVATE_DNS_MODE_OFF),
|
|
getPrivateDnsDefaultMode(context)
|
|
)
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(PRIVATE_DNS_DEFAULT_MODE),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(original)
|
|
)
|
|
}
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setPrivateDnsDefaultMode(context, -1) }
|
|
}
|
|
|
|
@Test
|
|
fun testConnectivityKeepPendingIntentDuration() {
|
|
testIntSetting(
|
|
names = arrayOf(CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS),
|
|
type = settingsTypeSecure,
|
|
value1 = Duration.ofMillis(testTime1),
|
|
value2 = Duration.ofMillis(testTime2),
|
|
getter = { getConnectivityKeepPendingIntentDuration(context, defaultDuration) },
|
|
setter = { setConnectivityKeepPendingIntentDuration(context, it) },
|
|
testIntValues = intArrayOf(testTime1.toInt())
|
|
)
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expect fail but argument accepted.") {
|
|
setConnectivityKeepPendingIntentDuration(context, Duration.ofMillis(-1L)) }
|
|
}
|
|
|
|
@Test
|
|
fun testMobileDataAlwaysOn() {
|
|
testIntSetting(
|
|
names = arrayOf(MOBILE_DATA_ALWAYS_ON),
|
|
type = settingsTypeGlobal,
|
|
value1 = false,
|
|
value2 = true,
|
|
getter = { getMobileDataAlwaysOn(context, true /* def */) },
|
|
setter = { setMobileDataAlwaysOn(context, it) },
|
|
testIntValues = intArrayOf(0)
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun testWifiAlwaysRequested() {
|
|
testIntSetting(
|
|
names = arrayOf(WIFI_ALWAYS_REQUESTED),
|
|
type = settingsTypeGlobal,
|
|
value1 = false,
|
|
value2 = true,
|
|
getter = { getWifiAlwaysRequested(context, true /* def */) },
|
|
setter = { setWifiAlwaysRequested(context, it) },
|
|
testIntValues = intArrayOf(0)
|
|
)
|
|
}
|
|
|
|
@ConnectivityModuleTest // get/setIngressRateLimitInBytesPerSecond was added via module update
|
|
@Test
|
|
fun testInternetNetworkRateLimitInBytesPerSecond() {
|
|
val defaultRate = getIngressRateLimitInBytesPerSecond(context)
|
|
val testRate = 1000L
|
|
setIngressRateLimitInBytesPerSecond(context, testRate)
|
|
assertEquals(testRate, getIngressRateLimitInBytesPerSecond(context))
|
|
|
|
setIngressRateLimitInBytesPerSecond(context, defaultRate)
|
|
assertEquals(defaultRate, getIngressRateLimitInBytesPerSecond(context))
|
|
|
|
assertFailsWith<IllegalArgumentException>("Expected failure, but setting accepted") {
|
|
setIngressRateLimitInBytesPerSecond(context, -10)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testSetNetworkAvoidBadWifiWithSettings() {
|
|
val testSubId = 1000
|
|
val orgDefaultSubIdSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgTestSubIdSetting = getNetworkAvoidBadWifiSetting(context, testSubId)
|
|
val orgLegacySetting = getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
try {
|
|
// initialize NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI and NETWORK_AVOID_BAD_WIFI to null
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, null)
|
|
|
|
// test with if new key NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI is set.
|
|
// format: key: "network_carrier_aware_avoid_bad_wifi/{subId}"
|
|
// value: "value"
|
|
// and if old key NETWORK_AVOID_BAD_WIFI is set as well.
|
|
// format: "value"
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
defaultSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_AVOID
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(Pair(defaultSubId, "1"))
|
|
)
|
|
assertEquals(
|
|
"1",
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
defaultSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_IGNORE
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(Pair(defaultSubId, "0"))
|
|
)
|
|
assertEquals(
|
|
"0",
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
testSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_AVOID
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(
|
|
Pair(defaultSubId, "0"),
|
|
Pair(testSubId, "1")
|
|
)
|
|
)
|
|
assertEquals(
|
|
"1",
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
testSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_IGNORE
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(
|
|
Pair(defaultSubId, "0"),
|
|
Pair(testSubId, "0")
|
|
)
|
|
)
|
|
assertEquals(
|
|
"0",
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
testSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_PROMPT
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(
|
|
Pair(defaultSubId, "0"),
|
|
Pair(testSubId, null)
|
|
)
|
|
)
|
|
assertEquals(
|
|
null,
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
|
|
setNetworkAvoidBadWifi(
|
|
context,
|
|
defaultSubId,
|
|
ConnectivitySettingsManager.NETWORK_AVOID_BAD_WIFI_PROMPT
|
|
)
|
|
assertAvoidBadWifiSettingEquals(
|
|
arrayOf(
|
|
Pair(defaultSubId, null),
|
|
Pair(testSubId, null)
|
|
)
|
|
)
|
|
assertEquals(
|
|
null,
|
|
getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
)
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
getAvoidBadWifiSettingKey(testSubId),
|
|
NETWORK_AVOID_BAD_WIFI
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgDefaultSubIdSetting,
|
|
orgTestSubIdSetting,
|
|
orgLegacySetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testGetNetworkAvoidBadWifiWithCarrierAwareSettings() {
|
|
val testSubId = 1000
|
|
val orgDefaultSubIdSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgTestSubIdSetting = getNetworkAvoidBadWifiSetting(context, testSubId)
|
|
try {
|
|
// initialize NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI to null
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, null)
|
|
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, "0")
|
|
assertFalse(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
// test the default value for other subId is not affected
|
|
assertTrue(getNetworkAvoidBadWifi(context, testSubId))
|
|
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, "1")
|
|
assertTrue(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
// test the default value for other subId is not affected
|
|
assertTrue(getNetworkAvoidBadWifi(context, testSubId))
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
getAvoidBadWifiSettingKey(testSubId)
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgDefaultSubIdSetting,
|
|
orgTestSubIdSetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testGetNetworkAvoidBadWifiWithSettings() {
|
|
val testSubId = 1000
|
|
val orgDefaultSubIdSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgTestSubIdSetting = getNetworkAvoidBadWifiSetting(context, testSubId)
|
|
val orgLegacySetting = getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
try {
|
|
// test if NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI is not set,
|
|
// then it check NETWORK_AVOID_BAD_WIFI for backward compatibility.
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, "0")
|
|
assertFalse(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
assertFalse(getNetworkAvoidBadWifi(context, testSubId))
|
|
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, "1")
|
|
assertTrue(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
assertTrue(getNetworkAvoidBadWifi(context, testSubId))
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
getAvoidBadWifiSettingKey(testSubId),
|
|
NETWORK_AVOID_BAD_WIFI
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgDefaultSubIdSetting,
|
|
orgTestSubIdSetting,
|
|
orgLegacySetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testGetNetworkAvoidBadWifiWithCarrierConfig() {
|
|
assumeTrue(
|
|
"skip test if device does not support telephony subscription feature",
|
|
context.packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY_SUBSCRIPTION)
|
|
)
|
|
|
|
val orgCarrierAwareSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgSetting = getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
try {
|
|
// unset the global settings, then it depends on the carrier config
|
|
mCarrierConfigRule.acquireCarrierPrivilege(defaultSubId)
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, null)
|
|
|
|
// default should be true if no carrier config key is set
|
|
assertTrue(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = true)
|
|
assertTrue(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = false)
|
|
assertFalse(getNetworkAvoidBadWifi(context, defaultSubId))
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
NETWORK_AVOID_BAD_WIFI
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgCarrierAwareSetting,
|
|
orgSetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testShouldShowAvoidBadWifiToggleWithSettings() {
|
|
val orgCarrierAwareSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgSetting = getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
try {
|
|
// unset the NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI, and NETWORK_AVOID_BAD_WIFI,
|
|
// it should be false since no carrier config is set
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, null)
|
|
assertFalse(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// if any global settings is set, it should display the toggle.
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, "1")
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, "0")
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// unset the NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI,
|
|
// then it check NETWORK_AVOID_BAD_WIFI for backward compatibility.
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, "1")
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, "0")
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
NETWORK_AVOID_BAD_WIFI
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgCarrierAwareSetting,
|
|
orgSetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IgnoreUpTo(Build.VERSION_CODES.BAKLAVA)
|
|
@RequiresFlagsEnabled(Flags.FLAG_AVOID_BAD_WIFI_FROM_CARRIER_CONFIG)
|
|
fun testShouldShowAvoidBadWifiToggleWithCarrierConfig() {
|
|
assumeTrue(
|
|
"skip test if device does not support telephony subscription feature",
|
|
context.packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY_SUBSCRIPTION)
|
|
)
|
|
val orgCarrierAwareSetting = getNetworkAvoidBadWifiSetting(context, defaultSubId)
|
|
val orgSetting = getNetworkLegacyGlobalAvoidBadWifiSetting(context)
|
|
try {
|
|
// unset both NETWORK_CARRIER_AWARE_AVOID_BAD_WIFI and KEY_AVOID_BAD_WIFI_BOOL settings,
|
|
// then it depends on the carrier config
|
|
mCarrierConfigRule.acquireCarrierPrivilege(defaultSubId)
|
|
setNetworkAvoidBadWifiSetting(context, defaultSubId, null)
|
|
setNetworkLegacyGlobalAvoidBadWifiSetting(context, null)
|
|
|
|
// default should be false if KEY_AVOID_BAD_WIFI_BOOL is not set
|
|
assertFalse(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// if KEY_AVOID_BAD_WIFI_BOOL is true, then check KEY_SHOW_AVOID_BAD_WIFI_TOGGLE_BOOL
|
|
// default should be false if KEY_SHOW_AVOID_BAD_WIFI_TOGGLE_BOOL is not set
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = true)
|
|
assertFalse(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// it should be true if KEY_AVOID_BAD_WIFI_BOOL is false
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = false)
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// Even if the carrier says not to show the toggle, when the carrier says
|
|
// not to avoid bad wifi it should be shown.
|
|
// This is because it should not be possible to force a device to be stuck on bad wifi
|
|
// and not give the user an option to change this.
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = false, showAvoidBadWifiToggle = false)
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = false, showAvoidBadWifiToggle = true)
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
// if KEY_AVOID_BAD_WIFI_BOOL is true, then check KEY_SHOW_AVOID_BAD_WIFI_TOGGLE_BOOL
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = true, showAvoidBadWifiToggle = false)
|
|
assertFalse(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
|
|
overrideAvoidBadWifiCarrierConfig(avoidBadWifi = true, showAvoidBadWifiToggle = true)
|
|
assertTrue(shouldShowAvoidBadWifiToggle(context, defaultSubId))
|
|
} finally {
|
|
resetSettings(
|
|
names = arrayOf(
|
|
getAvoidBadWifiSettingKey(defaultSubId),
|
|
NETWORK_AVOID_BAD_WIFI
|
|
),
|
|
type = settingsTypeGlobal,
|
|
values = arrayOf(
|
|
orgCarrierAwareSetting,
|
|
orgSetting
|
|
)
|
|
)
|
|
}
|
|
}
|
|
}
|