WifiSettingStore: Migrate to settings config store

Migrate all @hide Settings.Global flags to the new wifi settings
store. There is a one time migration performed for all the
existing keys in Settings to Shared preferences (triggered if
nothing exists in our shared preferences on bootup).

Also, move the WifiConfigManager.loadFromConfigStore() earler in the
boot sequence to allow the read of "scan always available" setting when
wifi is started.

Bug: 148514485
Test: atest com.android.server.wifi
Test: Device boots up and connects to wifi networks.
Test: Manual inspection of the config store file after migration.
Test: Will verify with presubmit ACTS tests.
Change-Id: Ie52494d688106f7e09ea4b9f7933dfa0f6b1dc95

6 files changed, 182 insertions, 42 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java b/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
index 7c3cc9cdf..41b6b66a9 100644
--- a/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
@@ -20,6 +20,7 @@ import static android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREG
 
 import static com.android.server.wifi.ScanRequestProxy.SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS;
 import static com.android.server.wifi.ScanRequestProxy.SCAN_REQUEST_THROTTLE_TIME_WINDOW_FG_APPS_MS;
+import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_SCAN_THROTTLE_ENABLED;
 
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
@@ -38,7 +39,6 @@ import android.os.IBinder;
 import android.os.UserHandle;
 import android.os.WorkSource;
 import android.os.test.TestLooper;
-import android.provider.Settings;
 
 import androidx.test.filters.SmallTest;
 
@@ -85,7 +85,7 @@ public class ScanRequestProxyTest extends WifiBaseTest {
     @Mock private WifiPermissionsUtil mWifiPermissionsUtil;
     @Mock private WifiMetrics mWifiMetrics;
     @Mock private Clock mClock;
-    @Mock private FrameworkFacade mFrameworkFacade;
+    @Mock private WifiSettingsConfigStore mWifiSettingsConfigStore;
     @Mock private WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
     @Mock private IScanResultsCallback mScanResultsCallback;
     @Mock private IScanResultsCallback mAnotherScanResultsCallback;
@@ -138,14 +138,13 @@ public class ScanRequestProxyTest extends WifiBaseTest {
                         new int[]{WifiScanner.WIFI_BAND_BOTH_WITH_DFS});
 
         // Scan throttling is enabled by default.
-        when(mFrameworkFacade.getIntegerSetting(
-                eq(mContext), eq(Settings.Global.WIFI_SCAN_THROTTLE_ENABLED), anyInt()))
-                .thenReturn(1);
+        when(mWifiSettingsConfigStore.getBoolean(eq(WIFI_SCAN_THROTTLE_ENABLED), anyBoolean()))
+                .thenReturn(true);
         mLooper = new TestLooper();
         mScanRequestProxy =
             new ScanRequestProxy(mContext, mAppOps, mActivityManager, mWifiInjector,
                     mWifiConfigManager, mWifiPermissionsUtil, mWifiMetrics, mClock,
-                    mFrameworkFacade, new Handler(mLooper.getLooper()));
+                    new Handler(mLooper.getLooper()), mWifiSettingsConfigStore);
         when(mScanResultsCallback.asBinder()).thenReturn(mBinder);
         when(mAnotherScanResultsCallback.asBinder()).thenReturn(mAnotherBinder);
     }
@@ -644,10 +643,8 @@ public class ScanRequestProxyTest extends WifiBaseTest {
     public void testSuccessiveScanRequestFromSameAppWhenThrottlingIsDisabledNotThrottled() {
         // Triggers the scan throttle setting registration.
         testEnableScanning();
-        // Disable scan throttling & invoke the content observer callback.
         mScanRequestProxy.setScanThrottleEnabled(false);
-        verify(mFrameworkFacade).setIntegerSetting(
-                eq(mContext), eq(Settings.Global.WIFI_SCAN_THROTTLE_ENABLED), anyInt());
+        verify(mWifiSettingsConfigStore).putBoolean(WIFI_SCAN_THROTTLE_ENABLED, false);
 
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
index 7601850eb..586ab3222 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
@@ -37,6 +37,7 @@ import static android.net.wifi.WifiManager.WIFI_STATE_DISABLED;
 
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
 import static com.android.server.wifi.LocalOnlyHotspotRequestInfo.HOTSPOT_NO_ERROR;
+import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_VERBOSE_LOGGING_ENABLED;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -304,6 +305,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
     @Mock ISuggestionConnectionStatusListener mSuggestionConnectionStatusListener;
     @Mock IOnWifiActivityEnergyInfoListener mOnWifiActivityEnergyInfoListener;
     @Mock IWifiConnectedNetworkScorer mWifiConnectedNetworkScorer;
+    @Mock WifiSettingsConfigStore mWifiSettingsConfigStore;
 
     WifiLog mLog = new LogcatLog(TAG);
 
@@ -374,6 +376,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
                 .thenReturn(mock(WifiNetworkScoreCache.class));
         when(mWifiInjector.getWifiThreadRunner())
                 .thenReturn(new WifiThreadRunner(new Handler(mLooper.getLooper())));
+        when(mWifiInjector.getSettingsConfigStore()).thenReturn(mWifiSettingsConfigStore);
         when(mClientModeImpl.syncStartSubscriptionProvisioning(anyInt(),
                 any(OsuProvider.class), any(IProvisioningCallback.class), any())).thenReturn(true);
         // Create an OSU provider that can be provisioned via an open OSU AP
@@ -1194,6 +1197,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
         when(mSettingsStore.isWifiToggleEnabled()).thenReturn(false);
         mWifiServiceImpl.checkAndStartWifi();
         mLooper.dispatchAll();
+        verify(mWifiConfigManager).loadFromStore();
         verify(mActiveModeWarden).start();
         verify(mActiveModeWarden, never()).wifiToggled();
     }
@@ -1211,6 +1215,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
                 anyInt(), anyInt())).thenReturn(PackageManager.PERMISSION_GRANTED);
         mWifiServiceImpl.checkAndStartWifi();
         mLooper.dispatchAll();
+        verify(mWifiConfigManager).loadFromStore();
         verify(mActiveModeWarden).start();
     }
 
@@ -3374,6 +3379,7 @@ public class WifiServiceImplTest extends WifiBaseTest {
         // before invocation.
         reset(mClientModeImpl);
         mWifiServiceImpl.enableVerboseLogging(1);
+        verify(mWifiSettingsConfigStore).putBoolean(WIFI_VERBOSE_LOGGING_ENABLED, true);
         verify(mClientModeImpl).enableVerboseLogging(anyInt());
     }
 
@@ -3390,6 +3396,8 @@ public class WifiServiceImplTest extends WifiBaseTest {
         // before invocation.
         reset(mClientModeImpl);
         mWifiServiceImpl.enableVerboseLogging(1);
+        verify(mWifiSettingsConfigStore, never()).putBoolean(
+                WIFI_VERBOSE_LOGGING_ENABLED, anyBoolean());
         verify(mClientModeImpl, never()).enableVerboseLogging(anyInt());
     }
 
@@ -5036,7 +5044,6 @@ public class WifiServiceImplTest extends WifiBaseTest {
         mWifiServiceImpl.handleBootCompleted();
         mLooper.dispatchAll();
 
-        verify(mWifiConfigManager).loadFromStore();
         verify(mPasspointManager).initializeProvisioner(any());
         verify(mClientModeImpl).handleBootCompleted();
     }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiSettingsConfigStoreTest.java b/tests/wifitests/src/com/android/server/wifi/WifiSettingsConfigStoreTest.java
new file mode 100644
index 000000000..22cb7f435
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/WifiSettingsConfigStoreTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2019 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 static com.android.server.wifi.WifiSettingsConfigStore.WIFI_VERBOSE_LOGGING_ENABLED;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.validateMockitoUsage;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.test.TestLooper;
+import android.util.Xml;
+
+import androidx.test.filters.SmallTest;
+
+import com.android.internal.util.FastXmlSerializer;
+import com.android.server.wifi.util.XmlUtil;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * Unit tests for {@link com.android.server.wifi.WifiSettingsConfigStore}.
+ */
+@SmallTest
+public class WifiSettingsConfigStoreTest extends WifiBaseTest {
+    @Mock
+    private Context mContext;
+    @Mock
+    private WifiConfigStore mWifiConfigStore;
+    @Mock
+    private WifiConfigManager mWifiConfigManager;
+
+    private TestLooper mLooper;
+    private WifiSettingsConfigStore mWifiSettingsConfigStore;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+
+        mLooper = new TestLooper();
+        mWifiSettingsConfigStore =
+                new WifiSettingsConfigStore(mContext, new Handler(mLooper.getLooper()),
+                        mWifiConfigManager, mWifiConfigStore);
+    }
+
+    /**
+     * Called after each test
+     */
+    @After
+    public void cleanup() {
+        validateMockitoUsage();
+    }
+
+    @Test
+    public void testSetterGetter() {
+        assertFalse(mWifiSettingsConfigStore.getBoolean(WIFI_VERBOSE_LOGGING_ENABLED, false));
+        mWifiSettingsConfigStore.putBoolean(WIFI_VERBOSE_LOGGING_ENABLED, true);
+        mLooper.dispatchAll();
+        assertTrue(mWifiSettingsConfigStore.getBoolean(WIFI_VERBOSE_LOGGING_ENABLED, false));
+        verify(mWifiConfigManager).saveToStore(true);
+    }
+
+    @Test
+    public void testChangeListener() {
+        WifiSettingsConfigStore.OnSettingsChangedListener listener = mock(
+                WifiSettingsConfigStore.OnSettingsChangedListener.class);
+        mWifiSettingsConfigStore.registerChangeListener(WIFI_VERBOSE_LOGGING_ENABLED, listener,
+                new Handler(mLooper.getLooper()));
+
+        mWifiSettingsConfigStore.putBoolean(WIFI_VERBOSE_LOGGING_ENABLED, true);
+        mLooper.dispatchAll();
+
+        verify(listener).onSettingsChanged(WIFI_VERBOSE_LOGGING_ENABLED, true);
+    }
+
+    @Test
+    public void testSaveAndLoadFromStore() throws Exception {
+        ArgumentCaptor<WifiConfigStore.StoreData> storeDataCaptor = ArgumentCaptor.forClass(
+                WifiConfigStore.StoreData.class);
+        verify(mWifiConfigStore).registerStoreData(storeDataCaptor.capture());
+        assertNotNull(storeDataCaptor.getValue());
+
+        XmlPullParser in = createSettingsTestXmlForParsing(WIFI_VERBOSE_LOGGING_ENABLED, true);
+
+        storeDataCaptor.getValue().resetData();
+        storeDataCaptor.getValue().deserializeData(in, in.getDepth(), -1, null);
+
+        assertTrue(mWifiSettingsConfigStore.getBoolean(WIFI_VERBOSE_LOGGING_ENABLED, false));
+    }
+
+    private XmlPullParser createSettingsTestXmlForParsing(String key, Object value)
+            throws Exception {
+        Map<String, Object> settings = new HashMap<>();
+        // Serialize
+        settings.put(key, value);
+        final XmlSerializer out = new FastXmlSerializer();
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        out.setOutput(outputStream, StandardCharsets.UTF_8.name());
+        XmlUtil.writeDocumentStart(out, "Test");
+        XmlUtil.writeNextValue(out, "Values", settings);
+        XmlUtil.writeDocumentEnd(out, "Test");
+
+        // Start Deserializing
+        final XmlPullParser in = Xml.newPullParser();
+        ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
+        in.setInput(inputStream, StandardCharsets.UTF_8.name());
+        XmlUtil.gotoDocumentStart(in, "Test");
+        return in;
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
index 3e4089056..9675ad89a 100644
--- a/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/aware/WifiAwareServiceImplTest.java
@@ -19,11 +19,9 @@ package com.android.server.wifi.aware;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -51,8 +49,8 @@ import android.util.SparseIntArray;
 
 import androidx.test.filters.SmallTest;
 
-import com.android.server.wifi.FrameworkFacade;
 import com.android.server.wifi.WifiBaseTest;
+import com.android.server.wifi.WifiSettingsConfigStore;
 import com.android.server.wifi.util.NetdWrapper;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.server.wifi.util.WifiPermissionsWrapper;
@@ -103,7 +101,7 @@ public class WifiAwareServiceImplTest extends WifiBaseTest {
     @Mock private WifiPermissionsUtil mWifiPermissionsUtil;
     @Mock private WifiPermissionsWrapper mPermissionsWrapperMock;
     @Mock
-    FrameworkFacade mFrameworkFacade;
+    WifiSettingsConfigStore mWifiSettingsConfigStore;
 
     /**
      * Using instead of spy to avoid native crash failures - possibly due to
@@ -135,8 +133,6 @@ public class WifiAwareServiceImplTest extends WifiBaseTest {
         mMockLooper = new TestLooper();
 
         when(mHandlerThreadMock.getLooper()).thenReturn(mMockLooper.getLooper());
-        doNothing().when(mFrameworkFacade).registerContentObserver(eq(mContextMock), any(),
-                anyBoolean(), any());
 
         AppOpsManager appOpsMock = mock(AppOpsManager.class);
         when(mContextMock.getSystemService(Context.APP_OPS_SERVICE)).thenReturn(appOpsMock);
@@ -152,7 +148,8 @@ public class WifiAwareServiceImplTest extends WifiBaseTest {
         mDut = new WifiAwareServiceImplSpy(mContextMock);
         mDut.fakeUid = mDefaultUid;
         mDut.start(mHandlerThreadMock, mAwareStateManagerMock, mWifiAwareShellCommandMock,
-                mAwareMetricsMock, mWifiPermissionsUtil, mPermissionsWrapperMock, mFrameworkFacade,
+                mAwareMetricsMock, mWifiPermissionsUtil, mPermissionsWrapperMock,
+                mWifiSettingsConfigStore,
                 mock(WifiAwareNativeManager.class), mock(WifiAwareNativeApi.class),
                 mock(WifiAwareNativeCallback.class), mock(NetdWrapper.class));
         mMockLooper.dispatchAll();
diff --git a/tests/wifitests/src/com/android/server/wifi/p2p/WifiP2pServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/p2p/WifiP2pServiceImplTest.java
index 5f22974a4..adfa025ca 100644
--- a/tests/wifitests/src/com/android/server/wifi/p2p/WifiP2pServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/p2p/WifiP2pServiceImplTest.java
@@ -16,6 +16,9 @@
 
 package com.android.server.wifi.p2p;
 
+import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_P2P_DEVICE_NAME;
+import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_P2P_PENDING_FACTORY_RESET;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
@@ -70,7 +73,6 @@ import android.os.Messenger;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.os.test.TestLooper;
-import android.provider.Settings;
 
 import androidx.test.filters.SmallTest;
 
@@ -79,6 +81,7 @@ import com.android.server.wifi.FrameworkFacade;
 import com.android.server.wifi.HalDeviceManager;
 import com.android.server.wifi.WifiBaseTest;
 import com.android.server.wifi.WifiInjector;
+import com.android.server.wifi.WifiSettingsConfigStore;
 import com.android.server.wifi.proto.nano.WifiMetricsProto.P2pConnectionEvent;
 import com.android.server.wifi.util.NetdWrapper;
 import com.android.server.wifi.util.WifiPermissionsUtil;
@@ -141,6 +144,7 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
     @Mock WifiInjector mWifiInjector;
     @Mock WifiManager mMockWifiManager;
     @Mock WifiPermissionsUtil mWifiPermissionsUtil;
+    @Mock WifiSettingsConfigStore mWifiSettingsConfigStore;
     @Mock WifiPermissionsWrapper mWifiPermissionsWrapper;
     @Mock WifiP2pNative mWifiNative;
     @Mock WifiP2pServiceInfo mTestWifiP2pServiceInfo;
@@ -706,10 +710,10 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
 
         when(mContext.getPackageManager()).thenReturn(mPackageManager);
         when(mContext.getResources()).thenReturn(mResources);
-        when(mFrameworkFacade.getStringSetting(any(),
-                eq(Settings.Global.WIFI_P2P_DEVICE_NAME))).thenReturn(thisDeviceName);
-        when(mFrameworkFacade.getIntegerSetting(any(),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), eq(0))).thenReturn(0);
+        when(mWifiSettingsConfigStore.getString(eq(WIFI_P2P_DEVICE_NAME), any()))
+                .thenReturn(thisDeviceName);
+        when(mWifiSettingsConfigStore.getBoolean(
+                eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(false))).thenReturn(false);
         when(mHandlerThread.getLooper()).thenReturn(mLooper.getLooper());
         if (supported) {
             when(mPackageManager.hasSystemFeature(eq(PackageManager.FEATURE_WIFI_DIRECT)))
@@ -727,6 +731,7 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
         when(mWifiInjector.getWifiP2pNative()).thenReturn(mWifiNative);
         when(mWifiInjector.getWifiP2pServiceHandlerThread()).thenReturn(mHandlerThread);
         when(mWifiInjector.getWifiPermissionsUtil()).thenReturn(mWifiPermissionsUtil);
+        when(mWifiInjector.getSettingsConfigStore()).thenReturn(mWifiSettingsConfigStore);
         // enable all permissions, disable specific permissions in tests
         when(mWifiPermissionsUtil.checkNetworkSettingsPermission(anyInt())).thenReturn(true);
         when(mWifiPermissionsUtil.checkNetworkStackPermission(anyInt())).thenReturn(true);
@@ -2723,13 +2728,11 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
 
         mTestThisDevice.deviceName = "another-name";
         when(mWifiNative.setDeviceName(anyString())).thenReturn(true);
-        when(mFrameworkFacade.setStringSetting(
-                any(), eq(Settings.Global.WIFI_P2P_DEVICE_NAME), anyString())).thenReturn(true);
         sendSetDeviceNameMsg(mClientMessenger, mTestThisDevice);
         verify(mWifiNative).setDeviceName(eq(mTestThisDevice.deviceName));
         verify(mWifiNative).setP2pSsidPostfix(eq("-" + mTestThisDevice.deviceName));
-        verify(mFrameworkFacade).setStringSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_DEVICE_NAME), eq(mTestThisDevice.deviceName));
+        verify(mWifiSettingsConfigStore).putString(
+                eq(WIFI_P2P_DEVICE_NAME), eq(mTestThisDevice.deviceName));
         checkSendThisDeviceChangedBroadcast();
         verify(mClientHandler).sendMessage(mMessageCaptor.capture());
         Message message = mMessageCaptor.getValue();
@@ -3172,8 +3175,7 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
                 eq(UserManager.DISALLOW_NETWORK_RESET), any());
         verify(mUserManager).hasUserRestrictionForUser(eq(UserManager.DISALLOW_CONFIG_WIFI), any());
         verify(mWifiNative, atLeastOnce()).p2pListNetworks(any());
-        verify(mFrameworkFacade).setIntegerSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), eq(0));
+        verify(mWifiSettingsConfigStore).putBoolean(eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(false));
         verify(mClientHandler).sendMessage(mMessageCaptor.capture());
         Message message = mMessageCaptor.getValue();
         assertEquals(WifiP2pManager.FACTORY_RESET_SUCCEEDED, message.what);
@@ -3201,15 +3203,14 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
                 eq(UserManager.DISALLOW_NETWORK_RESET), any());
         verify(mUserManager).hasUserRestrictionForUser(eq(UserManager.DISALLOW_CONFIG_WIFI), any());
         verify(mWifiNative, never()).p2pListNetworks(any());
-        verify(mFrameworkFacade).setIntegerSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), eq(1));
+        verify(mWifiSettingsConfigStore).putBoolean(eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(true));
         verify(mClientHandler).sendMessage(mMessageCaptor.capture());
         Message message = mMessageCaptor.getValue();
         assertEquals(WifiP2pManager.FACTORY_RESET_SUCCEEDED, message.what);
 
         // Move to enabled state
-        when(mFrameworkFacade.getIntegerSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), anyInt())).thenReturn(1);
+        when(mWifiSettingsConfigStore.getBoolean(
+                eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(false))).thenReturn(true);
         forceP2pEnabled(mClient1);
         verify(mWifiInjector, times(2)).getUserManager();
         verify(mPackageManager, times(2)).getNameForUid(anyInt());
@@ -3219,10 +3220,8 @@ public class WifiP2pServiceImplTest extends WifiBaseTest {
         verify(mUserManager, times(2)).hasUserRestrictionForUser(
                 eq(UserManager.DISALLOW_CONFIG_WIFI), any());
         verify(mWifiNative, atLeastOnce()).p2pListNetworks(any());
-        verify(mFrameworkFacade).getIntegerSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), eq(0));
-        verify(mFrameworkFacade).setIntegerSetting(eq(mContext),
-                eq(Settings.Global.WIFI_P2P_PENDING_FACTORY_RESET), eq(0));
+        verify(mWifiSettingsConfigStore).getBoolean(eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(false));
+        verify(mWifiSettingsConfigStore).putBoolean(eq(WIFI_P2P_PENDING_FACTORY_RESET), eq(false));
         checkSendP2pPersistentGroupsChangedBroadcast();
     }
 
diff --git a/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
index e5c922d5a..ec08f4100 100644
--- a/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
@@ -31,7 +31,6 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -72,9 +71,9 @@ import android.util.Pair;
 import androidx.test.filters.SmallTest;
 
 import com.android.server.wifi.Clock;
-import com.android.server.wifi.FrameworkFacade;
 import com.android.server.wifi.MockResources;
 import com.android.server.wifi.WifiBaseTest;
+import com.android.server.wifi.WifiSettingsConfigStore;
 import com.android.server.wifi.proto.nano.WifiMetricsProto;
 import com.android.server.wifi.util.WifiPermissionsUtil;
 import com.android.wifi.resources.R;
@@ -156,7 +155,7 @@ public class RttServiceImplTest extends WifiBaseTest {
     public IRttCallback mockCallback;
 
     @Mock
-    FrameworkFacade mFrameworkFacade;
+    WifiSettingsConfigStore mWifiSettingsConfigStore;
 
     /**
      * Using instead of spy to avoid native crash failures - possibly due to
@@ -196,8 +195,6 @@ public class RttServiceImplTest extends WifiBaseTest {
                 R.integer.config_wifiRttBackgroundExecGapMs, BACKGROUND_PROCESS_EXEC_GAP_MS);
 
         mAlarmManager = new TestAlarmManager();
-        doNothing().when(mFrameworkFacade).registerContentObserver(eq(mockContext), any(),
-                anyBoolean(), any());
         when(mockContext.getSystemService(Context.ALARM_SERVICE))
                 .thenReturn(mAlarmManager.getAlarmManager());
         mInOrder = inOrder(mAlarmManager.getAlarmManager(), mockContext);
@@ -225,7 +222,7 @@ public class RttServiceImplTest extends WifiBaseTest {
         doAnswer(mBinderUnlinkToDeathCounter).when(mockIbinder).unlinkToDeath(any(), anyInt());
 
         mDut.start(mMockLooper.getLooper(), mockClock, mockAwareManager, mockNative,
-                mockMetrics, mockPermissionUtil, mFrameworkFacade);
+                mockMetrics, mockPermissionUtil, mWifiSettingsConfigStore);
         mMockLooper.dispatchAll();
         ArgumentCaptor<BroadcastReceiver> bcastRxCaptor = ArgumentCaptor.forClass(
                 BroadcastReceiver.class);