fix(magnification): make always on toggle unavailable when capabilities is window only

As b/328787031, we make the MagnificationAlwaysOnPreferenceController observe the magnification capabilities then update the preference enabled state. Therefore, when changing the capabilities to window mode only, the preference will become unavailable.

We use the bug-fix flag to verify the fix with rollout process.

Bug: 328787031
Flag: ACONFIG com.android.settings.accessibility.hide_magnification_always_on_toggle_when_window_mode_only DEVELOPMENT
Test: manually flip the flag
      atest MagnificationCapabilitiesTest
      atest ToggleScreenMagnificationPreferenceFragmentTest
      atest MagnificationAlwaysOnPreferenceControllerTest
Change-Id: I1a25f80131d84ecdd927030e40a18ebb32b7862f

tests/robotests/src/com/android/settings/accessibility/MagnificationAlwaysOnPreferenceControllerTest.java

@@ -17,6 +17,7 @@
 package com.android.settings.accessibility;
 
 import static com.android.settings.accessibility.AccessibilityUtil.State.OFF;
+import static com.android.settings.accessibility.MagnificationCapabilities.MagnificationMode;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -25,6 +26,9 @@ import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 
 import android.content.Context;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 
 import androidx.preference.PreferenceManager;
@@ -33,31 +37,42 @@ import androidx.preference.SwitchPreference;
 import androidx.test.core.app.ApplicationProvider;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowContentResolver;
 
 @RunWith(RobolectricTestRunner.class)
 public class MagnificationAlwaysOnPreferenceControllerTest {
 
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
     private static final String KEY_ALWAYS_ON =
             Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED;
 
-    private final Context mContext = ApplicationProvider.getApplicationContext();
-    private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext));
-    private final MagnificationAlwaysOnPreferenceController mController =
-            new MagnificationAlwaysOnPreferenceController(mContext,
-                    MagnificationAlwaysOnPreferenceController.PREF_KEY);
+    private Context mContext;
+    private ShadowContentResolver mShadowContentResolver;
+    private SwitchPreference mSwitchPreference;
+    private MagnificationAlwaysOnPreferenceController mController;
 
     @Before
     public void setUp() {
+        mContext = ApplicationProvider.getApplicationContext();
+        mShadowContentResolver = Shadow.extract(mContext.getContentResolver());
+
         final PreferenceManager preferenceManager = new PreferenceManager(mContext);
         final PreferenceScreen screen = preferenceManager.createPreferenceScreen(mContext);
+        mSwitchPreference = spy(new SwitchPreference(mContext));
         mSwitchPreference.setKey(MagnificationAlwaysOnPreferenceController.PREF_KEY);
         screen.addPreference(mSwitchPreference);
-        mController.displayPreference(screen);
 
+        mController = new MagnificationAlwaysOnPreferenceController(mContext,
+                MagnificationAlwaysOnPreferenceController.PREF_KEY);
+        mController.displayPreference(screen);
         mController.updateState(mSwitchPreference);
+
         reset(mSwitchPreference);
     }
 
@@ -80,4 +95,57 @@ public class MagnificationAlwaysOnPreferenceControllerTest {
         assertThat(mController.isChecked()).isFalse();
         assertThat(mSwitchPreference.isChecked()).isFalse();
     }
+
+    @Test
+    @EnableFlags(Flags.FLAG_HIDE_MAGNIFICATION_ALWAYS_ON_TOGGLE_WHEN_WINDOW_MODE_ONLY)
+    public void onResume_flagOn_verifyRegisterCapabilityObserver() {
+        mController.onResume();
+        assertThat(mShadowContentResolver.getContentObservers(
+                Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_MAGNIFICATION_CAPABILITY)))
+                .hasSize(1);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_HIDE_MAGNIFICATION_ALWAYS_ON_TOGGLE_WHEN_WINDOW_MODE_ONLY)
+    public void onPause_flagOn_verifyUnregisterCapabilityObserver() {
+        mController.onResume();
+        mController.onPause();
+        assertThat(mShadowContentResolver.getContentObservers(
+                Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_MAGNIFICATION_CAPABILITY)))
+                .isEmpty();
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_HIDE_MAGNIFICATION_ALWAYS_ON_TOGGLE_WHEN_WINDOW_MODE_ONLY)
+    public void updateState_windowModeOnlyAndFlagOff_preferenceIsAvailable() {
+        MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.WINDOW);
+
+        mController.updateState(mSwitchPreference);
+        assertThat(mSwitchPreference.isEnabled()).isTrue();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_HIDE_MAGNIFICATION_ALWAYS_ON_TOGGLE_WHEN_WINDOW_MODE_ONLY)
+    public void updateState_windowModeOnlyAndFlagOn_preferenceBecomesUnavailable() {
+        MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.WINDOW);
+
+        mController.updateState(mSwitchPreference);
+        assertThat(mSwitchPreference.isEnabled()).isFalse();
+    }
+
+    @Test
+    public void updateState_fullscreenModeOnly_preferenceIsAvailable() {
+        MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.FULLSCREEN);
+
+        mController.updateState(mSwitchPreference);
+        assertThat(mSwitchPreference.isEnabled()).isTrue();
+    }
+
+    @Test
+    public void updateState_switchMode_preferenceIsAvailable() {
+        MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
+
+        mController.updateState(mSwitchPreference);
+        assertThat(mSwitchPreference.isEnabled()).isTrue();
+    }
 }

tests/robotests/src/com/android/settings/accessibility/MagnificationCapabilitiesTest.java

@@ -18,7 +18,14 @@ package com.android.settings.accessibility;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
 import android.content.Context;
+import android.database.ContentObserver;
 
 import androidx.test.core.app.ApplicationProvider;
 
@@ -42,7 +49,6 @@ public final class MagnificationCapabilitiesTest {
         final int windowCapabilities = MagnificationCapabilities.getCapabilities(mContext);
         assertThat(windowCapabilities).isEqualTo(
                 MagnificationCapabilities.MagnificationMode.WINDOW);
-
     }
 
     @Test
@@ -63,4 +69,35 @@ public final class MagnificationCapabilitiesTest {
         assertThat(windowCapabilities).isEqualTo(
                 MagnificationCapabilities.MagnificationMode.FULLSCREEN);
     }
+
+    @Test
+    public void registerObserver_triggeredWhenCapabilitiesChanged() {
+        MagnificationCapabilities.setCapabilities(mContext,
+                MagnificationCapabilities.MagnificationMode.FULLSCREEN);
+
+        ContentObserver contentObserver =
+                spy(new ContentObserver(/* handler= */ null) {});
+
+        MagnificationCapabilities.registerObserver(mContext, contentObserver);
+        MagnificationCapabilities.setCapabilities(mContext,
+                MagnificationCapabilities.MagnificationMode.WINDOW);
+
+        verify(contentObserver).onChange(/* selfChange= */ anyBoolean(), /* uri= */ any());
+    }
+
+    @Test
+    public void unregisterObserver_neverTriggeredWhenCapabilitiesChanged() {
+        MagnificationCapabilities.setCapabilities(mContext,
+                MagnificationCapabilities.MagnificationMode.FULLSCREEN);
+
+        ContentObserver contentObserver =
+                spy(new ContentObserver(/* handler= */ null) {});
+
+        MagnificationCapabilities.registerObserver(mContext, contentObserver);
+        MagnificationCapabilities.unregisterObserver(mContext, contentObserver);
+        MagnificationCapabilities.setCapabilities(mContext,
+                MagnificationCapabilities.MagnificationMode.WINDOW);
+
+        verify(contentObserver, never()).onChange(/* selfChange= */ anyBoolean(), /* uri= */ any());
+    }
 }

tests/robotests/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentTest.java

@@ -816,6 +816,21 @@ public class ToggleScreenMagnificationPreferenceFragmentTest {
         assertThat(lifecycleObservers).comparingElementsUsing(instanceOf).contains(true);
     }
 
+    @Test
+    public void onCreateView_addTheAlwaysOnControllerToLifeCycleObserver() {
+        Correspondence instanceOf = Correspondence.transforming(
+                observer -> (observer instanceof MagnificationAlwaysOnPreferenceController),
+                "contains MagnificationAlwaysOnPreferenceController");
+
+        ToggleScreenMagnificationPreferenceFragment fragment = mFragController.create(
+                R.id.main_content, /* bundle= */ null).start().resume().get();
+
+        List<LifecycleObserver> lifecycleObservers = ReflectionHelpers.getField(
+                fragment.getSettingsLifecycle(), "mObservers");
+        assertThat(lifecycleObservers).isNotNull();
+        assertThat(lifecycleObservers).comparingElementsUsing(instanceOf).contains(true);
+    }
+
     @Test
     public void onCreateDialog_setDialogDelegate_invokeDialogDelegate() {
         ToggleScreenMagnificationPreferenceFragment fragment =