From 22c8bf81e10437fe05101144587238d5fd9cc05d Mon Sep 17 00:00:00 2001 From: Weng Su Date: Thu, 7 Apr 2022 11:33:08 +0800 Subject: [PATCH] Restrict Wi-Fi toggle in Internet Settings - Disable Wi-Fi toggle when user is not allowed to change Wi-Fi state. - Show restriction message in Wi-Fi toggle summary. - See the result screenshot in b/203168097#comment24 Bug: 203168097 Test: manual test atest -c WifiSwitchPreferenceControllerTest Change-Id: I3cfe2f4f0e855dde91a82babe3a03005c3985d59 --- .../WifiSwitchPreferenceController.java | 32 ++++- .../WifiSwitchPreferenceControllerTest.java | 114 +++++++++++++++--- 2 files changed, 124 insertions(+), 22 deletions(-) diff --git a/src/com/android/settings/network/WifiSwitchPreferenceController.java b/src/com/android/settings/network/WifiSwitchPreferenceController.java index 38ad0ebbefc..da69f4ff95a 100644 --- a/src/com/android/settings/network/WifiSwitchPreferenceController.java +++ b/src/com/android/settings/network/WifiSwitchPreferenceController.java @@ -16,19 +16,25 @@ package com.android.settings.network; +import static com.android.settingslib.wifi.WifiEnterpriseRestrictionUtils.isChangeWifiStateAllowed; + import android.content.Context; +import android.net.wifi.WifiManager; import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleObserver; import androidx.lifecycle.OnLifecycleEvent; import androidx.preference.PreferenceScreen; +import com.android.settings.R; import com.android.settings.overlay.FeatureFactory; import com.android.settings.widget.GenericSwitchController; import com.android.settings.wifi.WifiEnabler; import com.android.settingslib.RestrictedSwitchPreference; import com.android.settingslib.core.AbstractPreferenceController; +import com.google.common.annotations.VisibleForTesting; + /** * This controller helps to manage the state of wifi switch preference. */ @@ -37,9 +43,12 @@ public class WifiSwitchPreferenceController extends AbstractPreferenceController public static final String KEY = "main_toggle_wifi"; - private RestrictedSwitchPreference mPreference; + @VisibleForTesting + boolean mIsChangeWifiStateAllowed; + @VisibleForTesting + WifiEnabler mWifiEnabler; - private WifiEnabler mWifiEnabler; + private RestrictedSwitchPreference mPreference; public WifiSwitchPreferenceController(Context context, Lifecycle lifecycle) { super(context); @@ -48,6 +57,7 @@ public class WifiSwitchPreferenceController extends AbstractPreferenceController } lifecycle.addObserver(this); + mIsChangeWifiStateAllowed = isChangeWifiStateAllowed(context); } @Override @@ -64,12 +74,22 @@ public class WifiSwitchPreferenceController extends AbstractPreferenceController public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); mPreference = screen.findPreference(getPreferenceKey()); + if (mPreference == null) return; + + mPreference.setChecked(isWifiEnabled()); + if (!mIsChangeWifiStateAllowed) { + mPreference.setEnabled(false); + mPreference.setSummary(R.string.not_allowed_by_ent); + } } /** Lifecycle.Event.ON_START */ @OnLifecycleEvent(Lifecycle.Event.ON_START) public void onStart() { - if (mPreference != null) { + // Don't use WifiEnabler when user is not allowed to change Wi-Fi state, + // Because the preference needs to be disabled when the user is not allowed to change the + // Wi-Fi state, but WifiEnabler will enable the preference when the Wi-Fi state changes. + if (mPreference != null && mIsChangeWifiStateAllowed) { mWifiEnabler = new WifiEnabler(mContext, new GenericSwitchController(mPreference), FeatureFactory.getFactory(mContext).getMetricsFeatureProvider()); } @@ -98,4 +118,10 @@ public class WifiSwitchPreferenceController extends AbstractPreferenceController mWifiEnabler.pause(); } } + + private boolean isWifiEnabled() { + WifiManager wifiManager = mContext.getSystemService(WifiManager.class); + if (wifiManager == null) return false; + return wifiManager.isWifiEnabled(); + } } diff --git a/tests/unit/src/com/android/settings/network/WifiSwitchPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/WifiSwitchPreferenceControllerTest.java index 1244db81c76..add0094c8b6 100644 --- a/tests/unit/src/com/android/settings/network/WifiSwitchPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/WifiSwitchPreferenceControllerTest.java @@ -18,9 +18,9 @@ package com.android.settings.network; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; import android.content.Context; import android.net.wifi.WifiManager; @@ -31,38 +31,49 @@ import androidx.preference.PreferenceScreen; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.wifi.WifiEnabler; import com.android.settingslib.RestrictedSwitchPreference; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; @RunWith(AndroidJUnit4.class) public class WifiSwitchPreferenceControllerTest { + @Rule + public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + @Spy + Context mContext = ApplicationProvider.getApplicationContext(); + @Mock + WifiManager mWifiManager; + @Mock + WifiEnabler mWifiEnabler; + private PreferenceScreen mScreen; private RestrictedSwitchPreference mPreference; private WifiSwitchPreferenceController mController; - @Mock - private WifiManager mWifiManager; - @Before public void setUp() { - MockitoAnnotations.initMocks(this); - final Context context = spy(ApplicationProvider.getApplicationContext()); - doReturn(mWifiManager).when(context).getSystemService(Context.WIFI_SERVICE); + when(mContext.getSystemService(WifiManager.class)).thenReturn(mWifiManager); + when(mWifiManager.isWifiEnabled()).thenReturn(true); - mController = new WifiSwitchPreferenceController(context, mock(Lifecycle.class)); + mController = new WifiSwitchPreferenceController(mContext, mock(Lifecycle.class)); + mController.mIsChangeWifiStateAllowed = true; + mController.mWifiEnabler = mWifiEnabler; if (Looper.myLooper() == null) { Looper.prepare(); } - final PreferenceManager preferenceManager = new PreferenceManager(context); - mScreen = preferenceManager.createPreferenceScreen(context); - mPreference = new RestrictedSwitchPreference(context); + final PreferenceManager preferenceManager = new PreferenceManager(mContext); + mScreen = preferenceManager.createPreferenceScreen(mContext); + mPreference = new RestrictedSwitchPreference(mContext); mPreference.setKey(WifiSwitchPreferenceController.KEY); mScreen.addPreference(mPreference); } @@ -73,22 +84,87 @@ public class WifiSwitchPreferenceControllerTest { } @Test - public void isChecked_wifiStateDisabled_returnFalse() { - doReturn(WifiManager.WIFI_STATE_DISABLED).when(mWifiManager).getWifiState(); + public void displayPreference_wifiNotEnabled_preferenceNotChecked() { + when(mWifiManager.isWifiEnabled()).thenReturn(false); mController.displayPreference(mScreen); - mController.onStart(); assertThat(mPreference.isChecked()).isFalse(); } @Test - public void isChecked_wifiStateEnabled_returnTrue() { - doReturn(WifiManager.WIFI_STATE_ENABLED).when(mWifiManager).getWifiState(); + public void displayPreference_wifiIsEnabled_preferenceIsChecked() { + when(mWifiManager.isWifiEnabled()).thenReturn(true); mController.displayPreference(mScreen); - mController.onStart(); assertThat(mPreference.isChecked()).isTrue(); } + + @Test + public void displayPreference_disallowChangeWifiState_preferenceNotEnabled() { + mController.mIsChangeWifiStateAllowed = false; + + mController.displayPreference(mScreen); + + assertThat(mPreference.isEnabled()).isFalse(); + } + + @Test + public void displayPreference_allowChangeWifiState_preferenceIsEnabled() { + mController.mIsChangeWifiStateAllowed = true; + + mController.displayPreference(mScreen); + + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void onStart_disallowChangeWifiState_wifiEnablerNotCreated() { + mController.mIsChangeWifiStateAllowed = false; + mController.displayPreference(mScreen); + mController.mWifiEnabler = null; + + mController.onStart(); + + assertThat(mController.mWifiEnabler).isNull(); + } + + @Test + public void onStart_allowChangeWifiState_createWifiEnabler() { + mController.mIsChangeWifiStateAllowed = true; + mController.displayPreference(mScreen); + mController.mWifiEnabler = null; + + mController.onStart(); + + assertThat(mController.mWifiEnabler).isNotNull(); + } + + @Test + public void onStop_wifiEnablerIsCreated_teardownWifiEnabler() { + mController.mWifiEnabler = mWifiEnabler; + + mController.onStop(); + + verify(mWifiEnabler).teardownSwitchController(); + } + + @Test + public void onResume_wifiEnablerIsCreated_wifiEnablerResume() { + mController.mWifiEnabler = mWifiEnabler; + + mController.onResume(); + + verify(mWifiEnabler).resume(mContext); + } + + @Test + public void onPause_wifiEnablerIsCreated_wifiEnablerPause() { + mController.mWifiEnabler = mWifiEnabler; + + mController.onPause(); + + verify(mWifiEnabler).pause(); + } }