diff --git a/src/com/android/settings/network/AdaptiveConnectivityTogglePreference.kt b/src/com/android/settings/network/AdaptiveConnectivityTogglePreference.kt
index e1aea8519aa..4ce854672f9 100644
--- a/src/com/android/settings/network/AdaptiveConnectivityTogglePreference.kt
+++ b/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(
-        ADAPTIVE_CONNECTIVITY_ENABLED,
-        R.string.adaptive_connectivity_main_switch_title,
-    ),
-    MainSwitchPreferenceBinding,
-    Preference.OnPreferenceChangeListener {
+    MainSwitchPreference(KEY, R.string.adaptive_connectivity_main_switch_title) {
 
-    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) {
-        super.bind(preference, metadata)
-        preference.onPreferenceChangeListener = this
+    @Suppress("UNCHECKED_CAST")
+    private class AdaptiveConnectivityToggleStorage(
+        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 {
-        val isChecked = newValue as Boolean
-        preference.context
-            .getSystemService(WifiManager::class.java)
-            ?.setWifiScoringEnabled(isChecked)
-        return true
+    companion object {
+        const val KEY = ADAPTIVE_CONNECTIVITY_ENABLED
+        const val DEFAULT_VALUE = true
     }
 }
 // LINT.ThenChange(AdaptiveConnectivityTogglePreferenceController.java)
diff --git a/tests/robotests/src/com/android/settings/network/AdaptiveConnectivityTogglePreferenceTest.kt b/tests/robotests/src/com/android/settings/network/AdaptiveConnectivityTogglePreferenceTest.kt
index d85980efe67..c0ad07eec3b 100644
--- a/tests/robotests/src/com/android/settings/network/AdaptiveConnectivityTogglePreferenceTest.kt
+++ b/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
+import android.provider.Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED
 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
-    val setFlagsRule = SetFlagsRule()
+    private val mockWifiManager = mock<WifiManager>()
 
-    private val appContext: Context = spy(ApplicationProvider.getApplicationContext()){}
-
-    private val mockWifiManager: WifiManager = mock()
+    private val context: Context =
+        object : ContextWrapper(ApplicationProvider.getApplicationContext()) {
+            override fun getSystemService(name: String): Any? =
+                when {
+                    name == getSystemServiceName(WifiManager::class.java) -> mockWifiManager
+                    else -> super.getSystemService(name)
+                }
+        }
 
     private val adaptiveConnectivityTogglePreference = AdaptiveConnectivityTogglePreference()
 
-    @Before
-    fun setUp() {
-        whenever(appContext.getSystemService(WifiManager::class.java)).thenReturn(mockWifiManager)
+    @Test
+    fun switchClick_defaultDisabled_returnFalse() {
+        setAdaptiveConnectivityEnabled(false)
+
+        assertThat(getMainSwitchPreference().isChecked).isFalse()
     }
 
     @Test
-    fun setChecked_withTrue_shouldUpdateSetting() {
-        Settings.Secure.putInt(
-            appContext.contentResolver,
-            Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED, 0
-        )
+    fun switchClick_defaultEnabled_returnTrue() {
+        setAdaptiveConnectivityEnabled(true)
 
-        val mainSwitchPreference = getMainSwitchPreferenceCompat().apply { performClick() }
-
-        assertThat(mainSwitchPreference.isChecked).isTrue()
-        verify(mockWifiManager, atLeastOnce()).setWifiScoringEnabled(true)
+        assertThat(getMainSwitchPreference().isChecked).isTrue()
     }
 
     @Test
-    fun setChecked_withFalse_shouldUpdateSetting() {
-        Settings.Secure.putInt(
-            appContext.contentResolver,
-            Settings.Secure.ADAPTIVE_CONNECTIVITY_ENABLED, 1
-        )
+    fun setChecked_defaultEnabled_updatesCorrectly() {
+        val preference = getMainSwitchPreference()
+        assertThat(preference.isChecked).isTrue()
 
-        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 =
-        adaptiveConnectivityTogglePreference.createAndBindWidget(appContext)
+    private fun getMainSwitchPreference(): MainSwitchPreference =
+        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)