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

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();
+    }
 }

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);
+        when(mContext.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
-        final Context context = spy(ApplicationProvider.getApplicationContext());
+        when(mWifiManager.isWifiEnabled()).thenReturn(true);
-        doReturn(mWifiManager).when(context).getSystemService(Context.WIFI_SERVICE);
 
-        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);
+        final PreferenceManager preferenceManager = new PreferenceManager(mContext);
-        mScreen = preferenceManager.createPreferenceScreen(context);
+        mScreen = preferenceManager.createPreferenceScreen(mContext);
-        mPreference = new RestrictedSwitchPreference(context);
+        mPreference = new RestrictedSwitchPreference(mContext);
         mPreference.setKey(WifiSwitchPreferenceController.KEY);
         mScreen.addPreference(mPreference);
     }
@@ -73,22 +84,87 @@ public class WifiSwitchPreferenceControllerTest {
     }
 
     @Test
-    public void isChecked_wifiStateDisabled_returnFalse() {
+    public void displayPreference_wifiNotEnabled_preferenceNotChecked() {
-        doReturn(WifiManager.WIFI_STATE_DISABLED).when(mWifiManager).getWifiState();
+        when(mWifiManager.isWifiEnabled()).thenReturn(false);
 
         mController.displayPreference(mScreen);
-        mController.onStart();
 
         assertThat(mPreference.isChecked()).isFalse();
     }
 
     @Test
-    public void isChecked_wifiStateEnabled_returnTrue() {
+    public void displayPreference_wifiIsEnabled_preferenceIsChecked() {
-        doReturn(WifiManager.WIFI_STATE_ENABLED).when(mWifiManager).getWifiState();
+        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();
+    }
 }