[Catalyst] Create datastore for AdaptiveConnectivityToggle.

Bug: 368355361
Flag: com.android.settings.flags.catalyst_adaptive_connectivity
Test: atest AdaptiveConnectivityTogglePreferenceTest AdaptiveConnectivityScreenTest
NO_IFTTT=no added logic

Change-Id: I8c1f78bb89c24903e2672d619605a0249924b05a

src/com/android/settings/network/AdaptiveConnectivityTogglePreference.kt

@@ -19,35 +19,43 @@ package com.android.settings.network
 import android.content.Context
 import android.net.wifi.WifiManager
 import android.provider.Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED
-import androidx.preference.Preference
 import com.android.settings.R
+import com.android.settingslib.datastore.KeyValueStore
+import com.android.settingslib.datastore.KeyedObservableDelegate
 import com.android.settingslib.datastore.SettingsSecureStore
+import com.android.settingslib.datastore.SettingsStore
 import com.android.settingslib.metadata.MainSwitchPreference
-import com.android.settingslib.metadata.PreferenceMetadata
-import com.android.settingslib.preference.MainSwitchPreferenceBinding
 
 // LINT.IfChange
 class AdaptiveConnectivityTogglePreference :
-    MainSwitchPreference(
+    MainSwitchPreference(KEY, R.string.adaptive_connectivity_main_switch_title) {
-        ADAPTIVE_CONNECTIVITY_ENABLED,
-        R.string.adaptive_connectivity_main_switch_title,
-    ),
-    MainSwitchPreferenceBinding,
-    Preference.OnPreferenceChangeListener {
 
-    override fun storage(context: Context) = SettingsSecureStore.get(context)
+    override fun storage(context: Context): KeyValueStore =
+        AdaptiveConnectivityToggleStorage(context, SettingsSecureStore.get(context))
 
-    override fun bind(preference: Preference, metadata: PreferenceMetadata) {
+    @Suppress("UNCHECKED_CAST")
-        super.bind(preference, metadata)
+    private class AdaptiveConnectivityToggleStorage(
-        preference.onPreferenceChangeListener = this
+        private val context: Context,
+        private val settingsStore: SettingsStore,
+    ) : KeyedObservableDelegate<String>(settingsStore), KeyValueStore {
+
+        override fun contains(key: String) = settingsStore.contains(KEY)
+
+        override fun <T : Any> getDefaultValue(key: String, valueType: Class<T>) =
+            DEFAULT_VALUE as T
+
+        override fun <T : Any> getValue(key: String, valueType: Class<T>) =
+            (settingsStore.getBoolean(key) ?: DEFAULT_VALUE) as T
+
+        override fun <T : Any> setValue(key: String, valueType: Class<T>, value: T?) {
+            settingsStore.setBoolean(key, value as Boolean)
+            context.getSystemService(WifiManager::class.java)?.setWifiScoringEnabled(value)
+        }
     }
 
-    override fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {
+    companion object {
-        val isChecked = newValue as Boolean
+        const val KEY = ADAPTIVE_CONNECTIVITY_ENABLED
-        preference.context
+        const val DEFAULT_VALUE = true
-            .getSystemService(WifiManager::class.java)
-            ?.setWifiScoringEnabled(isChecked)
-        return true
     }
 }
 // LINT.ThenChange(AdaptiveConnectivityTogglePreferenceController.java)

tests/robotests/src/com/android/settings/network/AdaptiveConnectivityTogglePreferenceTest.kt

@@ -17,68 +17,90 @@
 package com.android.settings.network
 
 import android.content.Context
+import android.content.ContextWrapper
 import android.net.wifi.WifiManager
-import android.platform.test.flag.junit.SetFlagsRule
+import android.provider.Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED
-import android.provider.Settings
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.settingslib.preference.createAndBindWidget
 import com.android.settingslib.widget.MainSwitchPreference
 import com.google.common.truth.Truth.assertThat
-import org.junit.Before
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.mockito.kotlin.atLeastOnce
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.spy
 import org.mockito.kotlin.verify
-import org.mockito.kotlin.whenever
 
 // LINT.IfChange
 @RunWith(AndroidJUnit4::class)
 class AdaptiveConnectivityTogglePreferenceTest {
-    @get:Rule
+    private val mockWifiManager = mock<WifiManager>()
-    val setFlagsRule = SetFlagsRule()
 
-    private val appContext: Context = spy(ApplicationProvider.getApplicationContext()){}
+    private val context: Context =
-
+        object : ContextWrapper(ApplicationProvider.getApplicationContext()) {
-    private val mockWifiManager: WifiManager = mock()
+            override fun getSystemService(name: String): Any? =
+                when {
+                    name == getSystemServiceName(WifiManager::class.java) -> mockWifiManager
+                    else -> super.getSystemService(name)
+                }
+        }
 
     private val adaptiveConnectivityTogglePreference = AdaptiveConnectivityTogglePreference()
 
-    @Before
+    @Test
-    fun setUp() {
+    fun switchClick_defaultDisabled_returnFalse() {
-        whenever(appContext.getSystemService(WifiManager::class.java)).thenReturn(mockWifiManager)
+        setAdaptiveConnectivityEnabled(false)
+
+        assertThat(getMainSwitchPreference().isChecked).isFalse()
     }
 
     @Test
-    fun setChecked_withTrue_shouldUpdateSetting() {
+    fun switchClick_defaultEnabled_returnTrue() {
-        Settings.Secure.putInt(
+        setAdaptiveConnectivityEnabled(true)
-            appContext.contentResolver,
-            Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED, 0
-        )
 
-        val mainSwitchPreference = getMainSwitchPreferenceCompat().apply { performClick() }
+        assertThat(getMainSwitchPreference().isChecked).isTrue()
-
-        assertThat(mainSwitchPreference.isChecked).isTrue()
-        verify(mockWifiManager, atLeastOnce()).setWifiScoringEnabled(true)
     }
 
     @Test
-    fun setChecked_withFalse_shouldUpdateSetting() {
+    fun setChecked_defaultEnabled_updatesCorrectly() {
-        Settings.Secure.putInt(
+        val preference = getMainSwitchPreference()
-            appContext.contentResolver,
+        assertThat(preference.isChecked).isTrue()
-            Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED, 1
-        )
 
-        val mainSwitchPreference = getMainSwitchPreferenceCompat().apply { performClick() }
+        preference.performClick()
 
-        assertThat(mainSwitchPreference.isChecked).isFalse()
+        assertThat(preference.isChecked).isFalse()
+
+        preference.performClick()
+
+        assertThat(preference.isChecked).isTrue()
+    }
+
+    @Test
+    fun storeSetTrue_wifiManagerSetWifiScoringEnabled() {
+        setAdaptiveConnectivityEnabled(true)
+
+        assertThat(getAdaptiveConnectivityEnabled()).isTrue()
+        verify(mockWifiManager).setWifiScoringEnabled(true)
+    }
+
+    @Test
+    fun storeSetFalse_wifiManagerSetWifiScoringDisabled() {
+        setAdaptiveConnectivityEnabled(false)
+
+        assertThat(getAdaptiveConnectivityEnabled()).isFalse()
         verify(mockWifiManager).setWifiScoringEnabled(false)
     }
 
-    private fun getMainSwitchPreferenceCompat(): MainSwitchPreference =
+    private fun getMainSwitchPreference(): MainSwitchPreference =
-        adaptiveConnectivityTogglePreference.createAndBindWidget(appContext)
+        adaptiveConnectivityTogglePreference.createAndBindWidget(context)
+
+    private fun setAdaptiveConnectivityEnabled(enabled: Boolean) =
+        adaptiveConnectivityTogglePreference
+            .storage(context)
+            .setValue(ADAPTIVE_CONNECTIVITY_ENABLED, Boolean::class.javaObjectType, enabled)
+
+    private fun getAdaptiveConnectivityEnabled() =
+        adaptiveConnectivityTogglePreference
+            .storage(context)
+            .getValue(ADAPTIVE_CONNECTIVITY_ENABLED, Boolean::class.javaObjectType)
 }
 // LINT.ThenChange(AdaptiveConnectivityTogglePreferenceControllerTest.java)