Merge "Add the new Desktop Experience dev options" into main

res/values/strings.xml

@@ -12769,6 +12769,13 @@
     <!-- Title for a toggle that enables freeform windows. Freeform windows enables users to freely arrange and resize overlapping apps. [CHAR LIMIT=50] -->
     <string name="enable_desktop_mode">Enable freeform windows</string>
 
+    <!-- Title for a toggle that enables desktop experience features. This includes desktop view and connected displays. [CHAR LIMIT=50] -->
+    <string name="enable_desktop_experience_features">Enable desktop experience features</string>
+    <!-- Summary for a toggle that enables desktop experience features when the device itself can show the desktop (but it is not available without the developer option). [CHAR LIMIT=NONE] -->
+    <string name="enable_desktop_experience_features_summary_with_desktop">Enable Desktop View on the device and on secondary displays.</string>
+    <!-- Summary for a toggle that enables desktop experience features when desktop views don't need to be enable. [CHAR LIMIT=NONE] -->
+    <string name="enable_desktop_experience_features_summary_without_desktop">Enable Desktop View on secondary displays.</string>
+
     <!-- Title for a toggle that enables freeform windows on secondary display. Freeform windows enables users to freely arrange and resize overlapping apps. [CHAR LIMIT=50] -->
     <string name="enable_desktop_mode_on_secondary_display">Enable freeform windows on secondary display</string>
 

res/xml/development_settings.xml

@@ -755,6 +755,10 @@
             android:key="enable_freeform_support"
             android:title="@string/enable_freeform_support" />
 
+        <SwitchPreferenceCompat
+            android:key="override_desktop_experience_features"
+            android:title="@string/enable_desktop_experience_features"/>
+
         <SwitchPreferenceCompat
             android:key="force_desktop_mode_on_external_displays"
             android:title="@string/enable_desktop_mode_on_secondary_display"/>

src/com/android/settings/development/DesktopExperiencePreferenceController.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2025 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.settings.development;
+
+import static android.provider.Settings.Global.DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_OFF;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_ON;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_UNSET;
+import static android.window.DesktopModeFlags.ToggleOverride.fromSetting;
+
+import android.content.Context;
+import android.provider.Settings;
+import android.window.DesktopModeFlags;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.preference.Preference;
+import androidx.preference.TwoStatePreference;
+
+import com.android.settings.R;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.development.DeveloperOptionsPreferenceController;
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus;
+
+public class DesktopExperiencePreferenceController extends DeveloperOptionsPreferenceController
+        implements Preference.OnPreferenceChangeListener,
+        PreferenceControllerMixin, RebootConfirmationDialogHost {
+    private static final String OVERRIDE_DESKTOP_EXPERIENCE_FEATURES_KEY =
+            "override_desktop_experience_features";
+
+    @Nullable
+    private final DevelopmentSettingsDashboardFragment mFragment;
+
+    public DesktopExperiencePreferenceController(
+            Context context, @Nullable DevelopmentSettingsDashboardFragment fragment) {
+        super(context);
+        mFragment = fragment;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return DesktopModeStatus.canShowDesktopExperienceDevOption(mContext);
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return OVERRIDE_DESKTOP_EXPERIENCE_FEATURES_KEY;
+    }
+
+    @Override
+    public boolean onPreferenceChange(@NonNull Preference preference, Object newValue) {
+        final boolean isEnabled = (Boolean) newValue;
+        Settings.Global.putInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES,
+                isEnabled ? OVERRIDE_ON.getSetting() : OVERRIDE_OFF.getSetting());
+        if (mFragment != null) {
+            RebootConfirmationDialogFragment.show(
+                    mFragment, R.string.reboot_dialog_override_desktop_mode, this);
+        }
+        return true;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+        // Use overridden state, if not present, then use default state
+        final int overrideInt = Settings.Global.getInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, OVERRIDE_UNSET.getSetting());
+        final DesktopModeFlags.ToggleOverride toggleOverride = fromSetting(overrideInt,
+                OVERRIDE_UNSET);
+        final boolean shouldDevOptionBeEnabled = switch (toggleOverride) {
+            case OVERRIDE_OFF, OVERRIDE_UNSET -> false;
+            case OVERRIDE_ON -> true;
+        };
+        ((TwoStatePreference) mPreference).setChecked(shouldDevOptionBeEnabled);
+    }
+
+    @Override
+    protected void onDeveloperOptionsSwitchDisabled() {
+        super.onDeveloperOptionsSwitchDisabled();
+        Settings.Global.putInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, OVERRIDE_UNSET.getSetting());
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        if (DesktopModeStatus.isDeviceEligibleForDesktopMode(mContext)
+                && !DesktopModeFlags.ENABLE_DESKTOP_WINDOWING_MODE.isTrue()) {
+            return mContext.getString(
+                    R.string.enable_desktop_experience_features_summary_with_desktop);
+        }
+        return mContext.getString(
+                R.string.enable_desktop_experience_features_summary_without_desktop);
+    }
+}

src/com/android/settings/development/DesktopModePreferenceController.java

@@ -57,7 +57,8 @@ public class DesktopModePreferenceController extends DeveloperOptionsPreferenceC
 
     @Override
     public boolean isAvailable() {
-        return DesktopModeStatus.canShowDesktopModeDevOption(mContext);
+        return DesktopModeStatus.canShowDesktopModeDevOption(mContext)
+                && !DesktopModeStatus.canShowDesktopExperienceDevOption(mContext);
     }
 
     @Override

src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceController.java

@@ -30,6 +30,7 @@ import androidx.preference.TwoStatePreference;
 import com.android.settings.R;
 import com.android.settings.core.PreferenceControllerMixin;
 import com.android.settingslib.development.DeveloperOptionsPreferenceController;
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus;
 
 /**
  * Preference controller to control Desktop mode features on secondary display
@@ -61,6 +62,11 @@ public class DesktopModeSecondaryDisplayPreferenceController extends
         return ENABLE_DESKTOP_MODE_ON_SECONDARY_DISPLAY;
     }
 
+    @Override
+    public boolean isAvailable() {
+        return !DesktopModeStatus.canShowDesktopExperienceDevOption(mContext);
+    }
+
     @Override
     public boolean onPreferenceChange(Preference preference, Object newValue) {
         final boolean isEnabled = (Boolean) newValue;

src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java

@@ -802,6 +802,7 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra
         controllers.add(new FreeformWindowsPreferenceController(context, fragment));
         controllers.add(new DesktopModePreferenceController(context, fragment));
         controllers.add(new DesktopModeSecondaryDisplayPreferenceController(context, fragment));
+        controllers.add(new DesktopExperiencePreferenceController(context, fragment));
         controllers.add(new NonResizableMultiWindowPreferenceController(context));
         controllers.add(new ShortcutManagerThrottlingPreferenceController(context));
         controllers.add(new EnableGnssRawMeasFullTrackingPreferenceController(context));

src/com/android/settings/development/FreeformWindowsPreferenceController.java

@@ -29,6 +29,7 @@ import androidx.preference.TwoStatePreference;
 import com.android.settings.R;
 import com.android.settings.core.PreferenceControllerMixin;
 import com.android.settingslib.development.DeveloperOptionsPreferenceController;
+import com.android.wm.shell.shared.desktopmode.DesktopModeStatus;
 
 public class FreeformWindowsPreferenceController extends DeveloperOptionsPreferenceController
         implements Preference.OnPreferenceChangeListener, PreferenceControllerMixin,
@@ -54,7 +55,9 @@ public class FreeformWindowsPreferenceController extends DeveloperOptionsPrefere
     public boolean isAvailable() {
         // When devices have the system feature FEATURE_FREEFORM_WINDOW_MANAGEMENT, freeform
         // mode is enabled automatically, and this toggle is not needed.
-        return !mContext.getPackageManager().hasSystemFeature(FEATURE_FREEFORM_WINDOW_MANAGEMENT);
+        return !mContext.getPackageManager().hasSystemFeature(FEATURE_FREEFORM_WINDOW_MANAGEMENT)
+                && !DesktopModeStatus.canShowDesktopExperienceDevOption(mContext)
+                && !DesktopModeStatus.canShowDesktopModeDevOption(mContext);
     }
 
     @Override

tests/robotests/src/com/android/settings/development/DesktopExperiencePreferenceControllerTest.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2025 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.settings.development;
+
+import static android.provider.Settings.Global.DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_OFF;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_ON;
+import static android.window.DesktopModeFlags.ToggleOverride.OVERRIDE_UNSET;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.res.Resources;
+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.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.FragmentTransaction;
+import androidx.preference.PreferenceScreen;
+import androidx.preference.SwitchPreference;
+import androidx.test.core.app.ApplicationProvider;
+
+import com.android.settings.R;
+import com.android.window.flags.Flags;
+
+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.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowSystemProperties;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {
+        com.android.settings.testutils.shadow.ShadowFragment.class,
+})
+@EnableFlags(Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION)
+public class DesktopExperiencePreferenceControllerTest {
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    @Mock
+    private SwitchPreference mPreference;
+    @Mock
+    private PreferenceScreen mScreen;
+    @Mock
+    private DevelopmentSettingsDashboardFragment mFragment;
+    @Mock
+    private FragmentActivity mActivity;
+    @Mock
+    private FragmentManager mFragmentManager;
+    @Mock
+    private FragmentTransaction mTransaction;
+
+    private Resources mResources;
+    private Context mContext;
+    private DesktopExperiencePreferenceController mController;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = spy(ApplicationProvider.getApplicationContext());
+        doReturn(mTransaction).when(mFragmentManager).beginTransaction();
+        doReturn(mFragmentManager).when(mActivity).getSupportFragmentManager();
+        doReturn(mActivity).when(mFragment).getActivity();
+
+        mResources = spy(mContext.getResources());
+        when(mContext.getResources()).thenReturn(mResources);
+
+        mController = new DesktopExperiencePreferenceController(mContext, mFragment);
+
+        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+        mController.displayPreference(mScreen);
+
+        // Set desktop mode available
+        when(mResources.getBoolean(com.android.internal.R.bool.config_isDesktopModeSupported))
+                .thenReturn(true);
+        ShadowSystemProperties.override("persist.wm.debug.desktop_mode_enforce_device_restrictions",
+                "false");
+    }
+
+    @Test
+    public void isAvailable_returnsTrue() {
+        mController = spy(mController);
+
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void onPreferenceChange_switchEnabled_putsSettingsOverrideOnAndTriggersRestart() {
+        mController.onPreferenceChange(mPreference, true /* new value */);
+
+        final int mode = Settings.Global.getInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, -1 /* default */);
+        assertThat(mode).isEqualTo(OVERRIDE_ON.getSetting());
+        verify(mTransaction).add(any(RebootConfirmationDialogFragment.class), any());
+    }
+
+    @Test
+    public void onPreferenceChange_switchDisabled_putsSettingsOverrideOffAndTriggersRestart() {
+        mController.onPreferenceChange(mPreference, false /* new value */);
+
+        int mode = Settings.Global.getInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, -1 /* default */);
+        assertThat(mode).isEqualTo(OVERRIDE_OFF.getSetting());
+        verify(mTransaction).add(any(RebootConfirmationDialogFragment.class), any());
+    }
+
+    @Test
+    public void updateState_overrideOn_checksPreference() {
+        Settings.Global.putInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, OVERRIDE_ON.getSetting());
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setChecked(true);
+    }
+
+    @Test
+    public void updateState_overrideOff_unchecksPreference() {
+        Settings.Global.putInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, OVERRIDE_OFF.getSetting());
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setChecked(false);
+    }
+
+    @Test
+    public void updateState_noOverride_noNewSettingsOverride() {
+        // Set no override
+        Settings.Global.putString(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, null);
+
+        mController.updateState(mPreference);
+
+        int mode = Settings.Global.getInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, -2 /* default */);
+        assertThat(mode).isEqualTo(-2);
+    }
+
+    @Test
+    public void onDeveloperOptionsSwitchDisabled_putsSettingsOverrideOff() {
+        mController.onDeveloperOptionsSwitchDisabled();
+
+        final int mode = Settings.Global.getInt(mContext.getContentResolver(),
+                DEVELOPMENT_OVERRIDE_DESKTOP_EXPERIENCE_FEATURES, -2 /* default */);
+        assertThat(mode).isEqualTo(OVERRIDE_UNSET.getSetting());
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
+    public void updateState_whenDesktopModeAvailableButNotEnabled_checkSummary() {
+        SwitchPreference pref = new SwitchPreference(mContext);
+
+        mController.updateState(pref);
+
+        assertThat(pref.getSummary()).isEqualTo(mContext.getString(
+                R.string.enable_desktop_experience_features_summary_with_desktop));
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
+    public void updateState_whenDesktopModeAvailableAndEnabled_checkSummary() {
+        SwitchPreference pref = new SwitchPreference(mContext);
+
+        mController.updateState(pref);
+
+        assertThat(pref.getSummary()).isEqualTo(mContext.getString(
+                R.string.enable_desktop_experience_features_summary_without_desktop));
+    }
+}

tests/robotests/src/com/android/settings/development/DesktopModePreferenceControllerTest.java

@@ -125,6 +125,14 @@ public class DesktopModePreferenceControllerTest {
         assertThat(mController.isAvailable()).isTrue();
     }
 
+    @EnableFlags(Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION)
+    @Test
+    public void isAvailable_whenDesktopExperienceDevOptionIsEnabled_returnsFalse() {
+        mController = spy(mController);
+
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
     @Test
     public void onPreferenceChange_switchEnabled_putsSettingsOverrideOnAndTriggersRestart() {
         mController.onPreferenceChange(mPreference, true /* new value */);

tests/robotests/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceControllerTest.java

@@ -26,11 +26,13 @@ import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 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.fragment.app.FragmentActivity;
@@ -39,7 +41,10 @@ import androidx.fragment.app.FragmentTransaction;
 import androidx.preference.PreferenceScreen;
 import androidx.preference.SwitchPreference;
 
+import com.android.window.flags.Flags;
+
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -54,8 +59,9 @@ import org.robolectric.annotation.Config;
 })
 public class DesktopModeSecondaryDisplayPreferenceControllerTest {
 
-    private static final String ENG_BUILD_TYPE = "eng";
-    private static final String USER_BUILD_TYPE = "user";
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
     private static final int SETTING_VALUE_INVALID = -1;
 
     @Mock
@@ -86,20 +92,16 @@ public class DesktopModeSecondaryDisplayPreferenceControllerTest {
         mController.displayPreference(mScreen);
     }
 
+    @DisableFlags(Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION)
     @Test
-    public void isAvailable_engBuild_shouldBeTrue() {
-        mController = spy(mController);
-        doReturn(ENG_BUILD_TYPE).when(mController).getBuildType();
-
+    public void isAvailable_whenDesktopExperienceDevOptionIsDisabled_shouldBeTrue() {
         assertThat(mController.isAvailable()).isTrue();
     }
 
+    @EnableFlags(Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION)
     @Test
-    public void isAvailable_userBuild_shouldBeTrue() {
-        mController = spy(mController);
-        doReturn(USER_BUILD_TYPE).when(mController).getBuildType();
-
-        assertThat(mController.isAvailable()).isTrue();
+    public void isAvailable_whenDesktopExperienceDevOptionIsEnabled_shouldBeFalse() {
+        assertThat(mController.isAvailable()).isFalse();
     }
 
     @Test

tests/robotests/src/com/android/settings/development/FreeformWindowsPreferenceControllerTest.java

@@ -25,12 +25,15 @@ import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.content.pm.PackageManager;
+import android.content.res.Resources;
+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.fragment.app.FragmentActivity;
@@ -39,7 +42,11 @@ import androidx.fragment.app.FragmentTransaction;
 import androidx.preference.PreferenceScreen;
 import androidx.preference.SwitchPreference;
 
+import com.android.internal.R;
+import com.android.window.flags.Flags;
+
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -53,11 +60,16 @@ import org.robolectric.annotation.Config;
 })
 public class FreeformWindowsPreferenceControllerTest {
 
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
     @Mock
     Context mContext;
     @Mock
     private PackageManager mPackageManager;
     @Mock
+    private Resources mResources;
+    @Mock
     private SwitchPreference mPreference;
     @Mock
     private PreferenceScreen mScreen;
@@ -78,23 +90,46 @@ public class FreeformWindowsPreferenceControllerTest {
         doReturn(mTransaction).when(mFragmentManager).beginTransaction();
         doReturn(mFragmentManager).when(mActivity).getSupportFragmentManager();
         doReturn(mActivity).when(mFragment).getActivity();
+        doReturn(true).when(mResources).getBoolean(R.bool.config_isDesktopModeSupported);
         mController = new FreeformWindowsPreferenceController(mContext, mFragment);
         when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
         when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        when(mContext.getResources()).thenReturn(mResources);
         mController.displayPreference(mScreen);
     }
 
+    @DisableFlags({Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION,
+            Flags.FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION})
+    @Test
+    public void isAvailable_whenDesktopDevOptionsAreDisabled_returnsTrue() {
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @EnableFlags(Flags.FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
+    @Test
+    public void isAvailable_whenDesktopWindowingDevOptionIsEnabled_returnsFalse() {
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @EnableFlags(Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION)
+    @Test
+    public void isAvailable_whenDesktopExperienceDevOptionIsEnabled_returnsFalse() {
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @DisableFlags({Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION,
+            Flags.FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION})
     @Test
     public void isAvailable_deviceHasFreeformWindowSystemFeature_returnsFalse() {
-        mController = spy(mController);
         when(mPackageManager.hasSystemFeature(FEATURE_FREEFORM_WINDOW_MANAGEMENT)).thenReturn(true);
 
         assertThat(mController.isAvailable()).isFalse();
     }
 
+    @DisableFlags({Flags.FLAG_SHOW_DESKTOP_EXPERIENCE_DEV_OPTION,
+            Flags.FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION})
     @Test
     public void isAvailable_deviceDoesNotHaveFreeformWindowSystemFeature_returnsTrue() {
-        mController = spy(mController);
         when(mPackageManager.hasSystemFeature(FEATURE_FREEFORM_WINDOW_MANAGEMENT)).thenReturn(
                 false);