Merge "Move windowing mode switching to DesktopDisplayModeCtrl" into main (b301c93e) · Commits · e / os / android_frameworks_base

libs/WindowManager/Shell/src/com/android/wm/shell/dagger/WMShellModule.java

+24 −8

Original line number	Diff line number	Diff line
		@@ -84,6 +84,7 @@ import com.android.wm.shell.desktopmode.CloseDesktopTaskTransitionHandler;
		import com.android.wm.shell.desktopmode.DefaultDragToDesktopTransitionHandler;
		import com.android.wm.shell.desktopmode.DesktopActivityOrientationChangeHandler;
		import com.android.wm.shell.desktopmode.DesktopDisplayEventHandler;
		import com.android.wm.shell.desktopmode.DesktopDisplayModeController;
		import com.android.wm.shell.desktopmode.DesktopImmersiveController;
		import com.android.wm.shell.desktopmode.DesktopMinimizationTransitionHandler;
		import com.android.wm.shell.desktopmode.DesktopMixedTransitionHandler;
		@@ -1256,13 +1257,10 @@ public abstract class WMShellModule {
		static Optional<DesktopDisplayEventHandler> provideDesktopDisplayEventHandler(
		Context context,
		ShellInit shellInit,
		Transitions transitions,
		DisplayController displayController,
		RootTaskDisplayAreaOrganizer rootTaskDisplayAreaOrganizer,
		IWindowManager windowManager,
		Optional<DesktopUserRepositories> desktopUserRepositories,
		Optional<DesktopTasksController> desktopTasksController,
		ShellTaskOrganizer shellTaskOrganizer
		Optional<DesktopDisplayModeController> desktopDisplayModeController
		) {
		if (!DesktopModeStatus.canEnterDesktopMode(context)) {
		return Optional.empty();
		@@ -1271,13 +1269,10 @@ public abstract class WMShellModule {
		new DesktopDisplayEventHandler(
		context,
		shellInit,
		transitions,
		displayController,
		rootTaskDisplayAreaOrganizer,
		windowManager,
		desktopUserRepositories.get(),
		desktopTasksController.get(),
		shellTaskOrganizer));
		desktopDisplayModeController.get()));
		}

		@WMSingleton
		@@ -1407,6 +1402,27 @@ public abstract class WMShellModule {
		return new DesktopModeUiEventLogger(uiEventLogger, packageManager);
		}

		@WMSingleton
		@Provides
		static Optional<DesktopDisplayModeController> provideDesktopDisplayModeController(
		Context context,
		Transitions transitions,
		RootTaskDisplayAreaOrganizer rootTaskDisplayAreaOrganizer,
		IWindowManager windowManager,
		ShellTaskOrganizer shellTaskOrganizer
		) {
		if (!DesktopModeStatus.canEnterDesktopMode(context)) {
		return Optional.empty();
		}
		return Optional.of(
		new DesktopDisplayModeController(
		context,
		transitions,
		rootTaskDisplayAreaOrganizer,
		windowManager,
		shellTaskOrganizer));
		}

		//
		// App zoom out
		//

libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopDisplayEventHandler.kt

+3 −78

Original line number	Diff line number	Diff line
		@@ -16,41 +16,25 @@

		package com.android.wm.shell.desktopmode

		import android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD
		import android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM
		import android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED
		import android.app.WindowConfiguration.windowingModeToString
		import android.content.Context
		import android.provider.Settings
		import android.provider.Settings.Global.DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS
		import android.view.Display.DEFAULT_DISPLAY
		import android.view.IWindowManager
		import android.view.WindowManager.TRANSIT_CHANGE
		import android.window.DesktopExperienceFlags
		import android.window.WindowContainerTransaction
		import com.android.internal.protolog.ProtoLog
		import com.android.window.flags.Flags
		import com.android.wm.shell.RootTaskDisplayAreaOrganizer
		import com.android.wm.shell.ShellTaskOrganizer
		import com.android.wm.shell.common.DisplayController
		import com.android.wm.shell.common.DisplayController.OnDisplaysChangedListener
		import com.android.wm.shell.desktopmode.multidesks.OnDeskRemovedListener
		import com.android.wm.shell.protolog.ShellProtoLogGroup.WM_SHELL_DESKTOP_MODE
		import com.android.wm.shell.shared.desktopmode.DesktopModeStatus
		import com.android.wm.shell.sysui.ShellInit
		import com.android.wm.shell.transition.Transitions

		/** Handles display events in desktop mode */
		class DesktopDisplayEventHandler(
		private val context: Context,
		shellInit: ShellInit,
		private val transitions: Transitions,
		private val displayController: DisplayController,
		private val rootTaskDisplayAreaOrganizer: RootTaskDisplayAreaOrganizer,
		private val windowManager: IWindowManager,
		private val desktopUserRepositories: DesktopUserRepositories,
		private val desktopTasksController: DesktopTasksController,
		private val shellTaskOrganizer: ShellTaskOrganizer,
		private val desktopDisplayModeController: DesktopDisplayModeController,
		) : OnDisplaysChangedListener, OnDeskRemovedListener {

		private val desktopRepository: DesktopRepository
		@@ -70,7 +54,7 @@ class DesktopDisplayEventHandler(

		override fun onDisplayAdded(displayId: Int) {
		if (displayId != DEFAULT_DISPLAY) {
		refreshDisplayWindowingMode()
		desktopDisplayModeController.refreshDisplayWindowingMode()
		}

		if (!supportsDesks(displayId)) {
		@@ -88,7 +72,7 @@ class DesktopDisplayEventHandler(

		override fun onDisplayRemoved(displayId: Int) {
		if (displayId != DEFAULT_DISPLAY) {
		refreshDisplayWindowingMode()
		desktopDisplayModeController.refreshDisplayWindowingMode()
		}

		// TODO: b/362720497 - move desks in closing display to the remaining desk.
		@@ -102,65 +86,6 @@ class DesktopDisplayEventHandler(
		}
		}

		private fun refreshDisplayWindowingMode() {
		if (!Flags.enableDisplayWindowingModeSwitching()) return
		// TODO: b/375319538 - Replace the check with a DisplayManager API once it's available.
		val isExtendedDisplayEnabled =
		0 !=
		Settings.Global.getInt(
		context.contentResolver,
		DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS,
		0,
		)
		if (!isExtendedDisplayEnabled) {
		// No action needed in mirror or projected mode.
		return
		}

		val hasNonDefaultDisplay =
		rootTaskDisplayAreaOrganizer.getDisplayIds().any { displayId ->
		displayId != DEFAULT_DISPLAY
		}
		val targetDisplayWindowingMode =
		if (hasNonDefaultDisplay) {
		WINDOWING_MODE_FREEFORM
		} else {
		// Use the default display windowing mode when no non-default display.
		windowManager.getWindowingMode(DEFAULT_DISPLAY)
		}
		val tdaInfo = rootTaskDisplayAreaOrganizer.getDisplayAreaInfo(DEFAULT_DISPLAY)
		requireNotNull(tdaInfo) { "DisplayAreaInfo of DEFAULT_DISPLAY must be non-null." }
		val currentDisplayWindowingMode = tdaInfo.configuration.windowConfiguration.windowingMode
		if (currentDisplayWindowingMode == targetDisplayWindowingMode) {
		// Already in the target mode.
		return
		}

		logV(
		"As an external display is connected, changing default display's windowing mode from" +
		" ${windowingModeToString(currentDisplayWindowingMode)}" +
		" to ${windowingModeToString(targetDisplayWindowingMode)}"
		)

		val wct = WindowContainerTransaction()
		wct.setWindowingMode(tdaInfo.token, targetDisplayWindowingMode)
		shellTaskOrganizer
		.getRunningTasks(DEFAULT_DISPLAY)
		.filter { it.activityType == ACTIVITY_TYPE_STANDARD }
		.forEach {
		// TODO: b/391965153 - Reconsider the logic under multi-desk window hierarchy
		when (it.windowingMode) {
		currentDisplayWindowingMode -> {
		wct.setWindowingMode(it.token, currentDisplayWindowingMode)
		}
		targetDisplayWindowingMode -> {
		wct.setWindowingMode(it.token, WINDOWING_MODE_UNDEFINED)
		}
		}
		}
		transitions.startTransition(TRANSIT_CHANGE, wct, /* handler= */ null)
		}

		// TODO: b/362720497 - connected/projected display considerations.
		private fun supportsDesks(displayId: Int): Boolean =
		DesktopModeStatus.canEnterDesktopMode(context)

libs/WindowManager/Shell/src/com/android/wm/shell/desktopmode/DesktopDisplayModeController.kt

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		/*
		* 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.wm.shell.desktopmode

		import android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD
		import android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM
		import android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED
		import android.app.WindowConfiguration.windowingModeToString
		import android.content.Context
		import android.provider.Settings
		import android.provider.Settings.Global.DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS
		import android.view.Display.DEFAULT_DISPLAY
		import android.view.IWindowManager
		import android.view.WindowManager.TRANSIT_CHANGE
		import android.window.WindowContainerTransaction
		import com.android.internal.protolog.ProtoLog
		import com.android.window.flags.Flags
		import com.android.wm.shell.RootTaskDisplayAreaOrganizer
		import com.android.wm.shell.ShellTaskOrganizer
		import com.android.wm.shell.protolog.ShellProtoLogGroup.WM_SHELL_DESKTOP_MODE
		import com.android.wm.shell.transition.Transitions

		/** Controls the display windowing mode in desktop mode */
		class DesktopDisplayModeController(
		private val context: Context,
		private val transitions: Transitions,
		private val rootTaskDisplayAreaOrganizer: RootTaskDisplayAreaOrganizer,
		private val windowManager: IWindowManager,
		private val shellTaskOrganizer: ShellTaskOrganizer,
		) {

		fun refreshDisplayWindowingMode() {
		if (!Flags.enableDisplayWindowingModeSwitching()) return
		// TODO: b/375319538 - Replace the check with a DisplayManager API once it's available.
		val isExtendedDisplayEnabled =
		0 !=
		Settings.Global.getInt(
		context.contentResolver,
		DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS,
		0,
		)
		if (!isExtendedDisplayEnabled) {
		// No action needed in mirror or projected mode.
		return
		}

		val hasNonDefaultDisplay =
		rootTaskDisplayAreaOrganizer.getDisplayIds().any { displayId ->
		displayId != DEFAULT_DISPLAY
		}
		val targetDisplayWindowingMode =
		if (hasNonDefaultDisplay) {
		WINDOWING_MODE_FREEFORM
		} else {
		// Use the default display windowing mode when no non-default display.
		windowManager.getWindowingMode(DEFAULT_DISPLAY)
		}
		val tdaInfo = rootTaskDisplayAreaOrganizer.getDisplayAreaInfo(DEFAULT_DISPLAY)
		requireNotNull(tdaInfo) { "DisplayAreaInfo of DEFAULT_DISPLAY must be non-null." }
		val currentDisplayWindowingMode = tdaInfo.configuration.windowConfiguration.windowingMode
		if (currentDisplayWindowingMode == targetDisplayWindowingMode) {
		// Already in the target mode.
		return
		}

		logV(
		"As an external display is connected, changing default display's windowing mode from" +
		" ${windowingModeToString(currentDisplayWindowingMode)}" +
		" to ${windowingModeToString(targetDisplayWindowingMode)}"
		)

		val wct = WindowContainerTransaction()
		wct.setWindowingMode(tdaInfo.token, targetDisplayWindowingMode)
		shellTaskOrganizer
		.getRunningTasks(DEFAULT_DISPLAY)
		.filter { it.activityType == ACTIVITY_TYPE_STANDARD }
		.forEach {
		// TODO: b/391965153 - Reconsider the logic under multi-desk window hierarchy
		when (it.windowingMode) {
		currentDisplayWindowingMode -> {
		wct.setWindowingMode(it.token, currentDisplayWindowingMode)
		}
		targetDisplayWindowingMode -> {
		wct.setWindowingMode(it.token, WINDOWING_MODE_UNDEFINED)
		}
		}
		}
		transitions.startTransition(TRANSIT_CHANGE, wct, /* handler= */ null)
		}

		private fun logV(msg: String, vararg arguments: Any?) {
		ProtoLog.v(WM_SHELL_DESKTOP_MODE, "%s: $msg", TAG, *arguments)
		}

		companion object {
		private const val TAG = "DesktopDisplayModeController"
		}
		}

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopDisplayEventHandlerTest.kt

+7 −163

Original line number	Diff line number	Diff line
		@@ -16,51 +16,28 @@

		package com.android.wm.shell.desktopmode

		import android.app.ActivityManager.RunningTaskInfo
		import android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM
		import android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN
		import android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED
		import android.content.ContentResolver
		import android.os.Binder
		import android.platform.test.annotations.EnableFlags
		import android.provider.Settings
		import android.provider.Settings.Global.DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS
		import android.testing.AndroidTestingRunner
		import android.view.Display.DEFAULT_DISPLAY
		import android.view.IWindowManager
		import android.view.WindowManager.TRANSIT_CHANGE
		import android.window.DisplayAreaInfo
		import android.window.WindowContainerTransaction
		import androidx.test.filters.SmallTest
		import com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession
		import com.android.dx.mockito.inline.extended.ExtendedMockito.never
		import com.android.dx.mockito.inline.extended.StaticMockitoSession
		import com.android.window.flags.Flags
		import com.android.wm.shell.MockToken
		import com.android.wm.shell.RootTaskDisplayAreaOrganizer
		import com.android.wm.shell.ShellTaskOrganizer
		import com.android.wm.shell.ShellTestCase
		import com.android.wm.shell.TestRunningTaskInfoBuilder
		import com.android.wm.shell.common.DisplayController
		import com.android.wm.shell.common.DisplayController.OnDisplaysChangedListener
		import com.android.wm.shell.common.ShellExecutor
		import com.android.wm.shell.shared.desktopmode.DesktopModeStatus
		import com.android.wm.shell.sysui.ShellInit
		import com.android.wm.shell.transition.Transitions
		import com.google.common.truth.Truth.assertThat
		import org.junit.After
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.ArgumentMatchers.isNull
		import org.mockito.Mock
		import org.mockito.Mockito.anyInt
		import org.mockito.Mockito.spy
		import org.mockito.Mockito.times
		import org.mockito.Mockito.verify
		import org.mockito.kotlin.any
		import org.mockito.kotlin.argumentCaptor
		import org.mockito.kotlin.eq
		import org.mockito.kotlin.whenever
		import org.mockito.quality.Strictness

		@@ -73,27 +50,18 @@ import org.mockito.quality.Strictness
		@RunWith(AndroidTestingRunner::class)
		class DesktopDisplayEventHandlerTest : ShellTestCase() {
		@Mock lateinit var testExecutor: ShellExecutor
		@Mock lateinit var transitions: Transitions
		@Mock lateinit var displayController: DisplayController
		@Mock lateinit var rootTaskDisplayAreaOrganizer: RootTaskDisplayAreaOrganizer
		@Mock private lateinit var mockWindowManager: IWindowManager
		@Mock private lateinit var mockDesktopUserRepositories: DesktopUserRepositories
		@Mock private lateinit var mockDesktopRepository: DesktopRepository
		@Mock private lateinit var mockDesktopTasksController: DesktopTasksController
		@Mock private lateinit var shellTaskOrganizer: ShellTaskOrganizer
		@Mock private lateinit var desktopDisplayModeController: DesktopDisplayModeController

		private lateinit var mockitoSession: StaticMockitoSession
		private lateinit var shellInit: ShellInit
		private lateinit var handler: DesktopDisplayEventHandler

		private val onDisplaysChangedListenerCaptor = argumentCaptor<OnDisplaysChangedListener>()
		private val runningTasks = mutableListOf<RunningTaskInfo>()
		private val externalDisplayId = 100
		private val freeformTask =
		TestRunningTaskInfoBuilder().setWindowingMode(WINDOWING_MODE_FREEFORM).build()
		private val fullscreenTask =
		TestRunningTaskInfoBuilder().setWindowingMode(WINDOWING_MODE_FULLSCREEN).build()
		private val defaultTDA = DisplayAreaInfo(MockToken().token(), DEFAULT_DISPLAY, 0)

		@Before
		fun setUp() {
		@@ -105,24 +73,15 @@ class DesktopDisplayEventHandlerTest : ShellTestCase() {

		shellInit = spy(ShellInit(testExecutor))
		whenever(mockDesktopUserRepositories.current).thenReturn(mockDesktopRepository)
		whenever(transitions.startTransition(anyInt(), any(), isNull())).thenAnswer { Binder() }
		whenever(rootTaskDisplayAreaOrganizer.getDisplayAreaInfo(DEFAULT_DISPLAY))
		.thenReturn(defaultTDA)
		handler =
		DesktopDisplayEventHandler(
		context,
		shellInit,
		transitions,
		displayController,
		rootTaskDisplayAreaOrganizer,
		mockWindowManager,
		mockDesktopUserRepositories,
		mockDesktopTasksController,
		shellTaskOrganizer,
		desktopDisplayModeController,
		)
		whenever(shellTaskOrganizer.getRunningTasks(anyInt())).thenAnswer { runningTasks }
		runningTasks.add(freeformTask)
		runningTasks.add(fullscreenTask)
		shellInit.init()
		verify(displayController)
		.addDisplayWindowListener(onDisplaysChangedListenerCaptor.capture())
		@@ -133,65 +92,6 @@ class DesktopDisplayEventHandlerTest : ShellTestCase() {
		mockitoSession.finishMocking()
		}

		private fun testDisplayWindowingModeSwitch(
		defaultWindowingMode: Int,
		extendedDisplayEnabled: Boolean,
		expectTransition: Boolean,
		) {
		defaultTDA.configuration.windowConfiguration.windowingMode = defaultWindowingMode
		whenever(mockWindowManager.getWindowingMode(anyInt())).thenAnswer { defaultWindowingMode }
		val settingsSession =
		ExtendedDisplaySettingsSession(
		context.contentResolver,
		if (extendedDisplayEnabled) 1 else 0,
		)

		settingsSession.use {
		connectExternalDisplay()
		defaultTDA.configuration.windowConfiguration.windowingMode = WINDOWING_MODE_FREEFORM
		disconnectExternalDisplay()

		if (expectTransition) {
		val arg = argumentCaptor<WindowContainerTransaction>()
		verify(transitions, times(2))
		.startTransition(eq(TRANSIT_CHANGE), arg.capture(), isNull())
		assertThat(arg.firstValue.changes[defaultTDA.token.asBinder()]?.windowingMode)
		.isEqualTo(WINDOWING_MODE_FREEFORM)
		assertThat(arg.secondValue.changes[defaultTDA.token.asBinder()]?.windowingMode)
		.isEqualTo(defaultWindowingMode)
		} else {
		verify(transitions, never()).startTransition(eq(TRANSIT_CHANGE), any(), isNull())
		}
		}
		}

		@Test
		fun displayWindowingModeSwitchOnDisplayConnected_extendedDisplayDisabled() {
		testDisplayWindowingModeSwitch(
		defaultWindowingMode = WINDOWING_MODE_FULLSCREEN,
		extendedDisplayEnabled = false,
		expectTransition = false,
		)
		}

		@Test
		fun displayWindowingModeSwitchOnDisplayConnected_fullscreenDisplay() {
		testDisplayWindowingModeSwitch(
		defaultWindowingMode = WINDOWING_MODE_FULLSCREEN,
		extendedDisplayEnabled = true,
		expectTransition = true,
		)
		}

		@Test
		fun displayWindowingModeSwitchOnDisplayConnected_freeformDisplay() {
		testDisplayWindowingModeSwitch(
		defaultWindowingMode = WINDOWING_MODE_FREEFORM,
		extendedDisplayEnabled = true,
		expectTransition = false,
		)
		}

		@Test
		fun testDisplayAdded_supportsDesks_createsDesk() {
		whenever(DesktopModeStatus.canEnterDesktopMode(context)).thenReturn(true)
		@@ -231,70 +131,14 @@ class DesktopDisplayEventHandlerTest : ShellTestCase() {
		}

		@Test
		fun displayWindowingModeSwitch_existingTasksOnConnected() {
		defaultTDA.configuration.windowConfiguration.windowingMode = WINDOWING_MODE_FULLSCREEN
		whenever(mockWindowManager.getWindowingMode(anyInt())).thenAnswer {
		WINDOWING_MODE_FULLSCREEN
		}

		ExtendedDisplaySettingsSession(context.contentResolver, 1).use {
		connectExternalDisplay()

		val arg = argumentCaptor<WindowContainerTransaction>()
		verify(transitions, times(1))
		.startTransition(eq(TRANSIT_CHANGE), arg.capture(), isNull())
		assertThat(arg.firstValue.changes[freeformTask.token.asBinder()]?.windowingMode)
		.isEqualTo(WINDOWING_MODE_UNDEFINED)
		assertThat(arg.firstValue.changes[fullscreenTask.token.asBinder()]?.windowingMode)
		.isEqualTo(WINDOWING_MODE_FULLSCREEN)
		}
		}

		@Test
		fun displayWindowingModeSwitch_existingTasksOnDisconnected() {
		defaultTDA.configuration.windowConfiguration.windowingMode = WINDOWING_MODE_FREEFORM
		whenever(mockWindowManager.getWindowingMode(anyInt())).thenAnswer {
		WINDOWING_MODE_FULLSCREEN
		}

		ExtendedDisplaySettingsSession(context.contentResolver, 1).use {
		disconnectExternalDisplay()

		val arg = argumentCaptor<WindowContainerTransaction>()
		verify(transitions, times(1))
		.startTransition(eq(TRANSIT_CHANGE), arg.capture(), isNull())
		assertThat(arg.firstValue.changes[freeformTask.token.asBinder()]?.windowingMode)
		.isEqualTo(WINDOWING_MODE_FREEFORM)
		assertThat(arg.firstValue.changes[fullscreenTask.token.asBinder()]?.windowingMode)
		.isEqualTo(WINDOWING_MODE_UNDEFINED)
		}
		}

		private fun connectExternalDisplay() {
		whenever(rootTaskDisplayAreaOrganizer.getDisplayIds())
		.thenReturn(intArrayOf(DEFAULT_DISPLAY, externalDisplayId))
		fun testConnectExternalDisplay() {
		onDisplaysChangedListenerCaptor.lastValue.onDisplayAdded(externalDisplayId)
		verify(desktopDisplayModeController).refreshDisplayWindowingMode()
		}

		private fun disconnectExternalDisplay() {
		whenever(rootTaskDisplayAreaOrganizer.getDisplayIds())
		.thenReturn(intArrayOf(DEFAULT_DISPLAY))
		@Test
		fun testDisconnectExternalDisplay() {
		onDisplaysChangedListenerCaptor.lastValue.onDisplayRemoved(externalDisplayId)
		}

		private class ExtendedDisplaySettingsSession(
		private val contentResolver: ContentResolver,
		private val overrideValue: Int,
		) : AutoCloseable {
		private val settingName = DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS
		private val initialValue = Settings.Global.getInt(contentResolver, settingName, 0)

		init {
		Settings.Global.putInt(contentResolver, settingName, overrideValue)
		}

		override fun close() {
		Settings.Global.putInt(contentResolver, settingName, initialValue)
		}
		verify(desktopDisplayModeController).refreshDisplayWindowingMode()
		}
		}

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/desktopmode/DesktopDisplayModeControllerTest.kt

0 → 100644

+223 −0

File added.

Preview size limit exceeded, changes collapsed.