Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 53854039 authored by Toshiki Kikuchi's avatar Toshiki Kikuchi
Browse files

Move windowing mode switching to DesktopDisplayModeCtrl 

This CL is a pure refactor to move out the display windowing mode
switching-related logic to DesktopDisplayModeCtrl.
More related logic is incoming so separating the class prevents the
original handler from getting too complicated.

Flag: com.android.window.flags.enable_display_windowing_mode_switching
Bug: 397557203
Test: DesktopDisplayModeControllerTest

Change-Id: Ib4323517e31ca8ebb79642b84a6b937e85c12363
parent 6b3d33e2

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

+24 −8
Original line number Diff line number Diff line
@@ -82,6 +82,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;
@@ -1230,13 +1231,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();
@@ -1245,13 +1243,10 @@ public abstract class WMShellModule { 
                new DesktopDisplayEventHandler(

                        context,

                        shellInit,

                        transitions,

                        displayController,

                        rootTaskDisplayAreaOrganizer,

                        windowManager,

                        desktopUserRepositories.get(),

                        desktopTasksController.get(),

                        shellTaskOrganizer));

                        desktopDisplayModeController.get()));

    }



    @WMSingleton
@@ -1381,6 +1376,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.