diff --git a/res/values/strings.xml b/res/values/strings.xml index ce2e3985b4e..bd4b12b8c79 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -12769,6 +12769,13 @@ Enable freeform windows + + Enable desktop experience features + + Enable Desktop View on the device and on secondary displays. + + Enable Desktop View on secondary displays. + Enable freeform windows on secondary display diff --git a/res/xml/development_settings.xml b/res/xml/development_settings.xml index 6ac175d85bd..7b32941cb2b 100644 --- a/res/xml/development_settings.xml +++ b/res/xml/development_settings.xml @@ -755,6 +755,10 @@ android:key="enable_freeform_support" android:title="@string/enable_freeform_support" /> + + diff --git a/src/com/android/settings/development/DesktopExperiencePreferenceController.java b/src/com/android/settings/development/DesktopExperiencePreferenceController.java new file mode 100644 index 00000000000..28e92fcdac5 --- /dev/null +++ b/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); + } +} diff --git a/src/com/android/settings/development/DesktopModePreferenceController.java b/src/com/android/settings/development/DesktopModePreferenceController.java index 492686ead65..8012d31b9f6 100644 --- a/src/com/android/settings/development/DesktopModePreferenceController.java +++ b/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 diff --git a/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceController.java b/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceController.java index 2bce9ad32bd..899b921e47f 100644 --- a/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceController.java +++ b/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; diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java index 70a905909e9..fe1e0281e18 100644 --- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java +++ b/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)); diff --git a/src/com/android/settings/development/FreeformWindowsPreferenceController.java b/src/com/android/settings/development/FreeformWindowsPreferenceController.java index c02ffa7d00f..6cf1563bce5 100644 --- a/src/com/android/settings/development/FreeformWindowsPreferenceController.java +++ b/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 diff --git a/tests/robotests/src/com/android/settings/development/DesktopExperiencePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/DesktopExperiencePreferenceControllerTest.java new file mode 100644 index 00000000000..26a802629d7 --- /dev/null +++ b/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)); + } +} diff --git a/tests/robotests/src/com/android/settings/development/DesktopModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/DesktopModePreferenceControllerTest.java index b9f56215de1..de7faa11e29 100644 --- a/tests/robotests/src/com/android/settings/development/DesktopModePreferenceControllerTest.java +++ b/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 */); diff --git a/tests/robotests/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceControllerTest.java index 3691d12e899..c4e8f489ca5 100644 --- a/tests/robotests/src/com/android/settings/development/DesktopModeSecondaryDisplayPreferenceControllerTest.java +++ b/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 diff --git a/tests/robotests/src/com/android/settings/development/FreeformWindowsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/FreeformWindowsPreferenceControllerTest.java index 978380ecfdd..cf32ae83e00 100644 --- a/tests/robotests/src/com/android/settings/development/FreeformWindowsPreferenceControllerTest.java +++ b/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);