diff --git a/quickstep/src/com/android/launcher3/dagger/Modules.kt b/quickstep/src/com/android/launcher3/dagger/Modules.kt index 2456534020..fccbf2bff3 100644 --- a/quickstep/src/com/android/launcher3/dagger/Modules.kt +++ b/quickstep/src/com/android/launcher3/dagger/Modules.kt @@ -33,6 +33,7 @@ import com.android.quickstep.logging.StatsLogCompatManager.StatsLogCompatManager import com.android.quickstep.util.ChoreographerFrameRateTracker import com.android.quickstep.util.GestureExclusionManager import com.android.quickstep.util.SystemWindowManagerProxy +import com.android.systemui.shared.system.ActivityManagerWrapper import dagger.Binds import dagger.Module import dagger.Provides @@ -82,4 +83,9 @@ object StaticObjectModule { @Provides @JvmStatic fun provideRefreshRateTracker(): RefreshRateTracker = ChoreographerFrameRateTracker + + @Provides + @JvmStatic + fun provideActivityManagerWrapper(): ActivityManagerWrapper = + ActivityManagerWrapper.getInstance() } diff --git a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchController.java b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchController.java index da70bb9a76..7074a823de 100644 --- a/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchController.java +++ b/quickstep/src/com/android/launcher3/taskbar/KeyboardQuickSwitchController.java @@ -165,16 +165,18 @@ public final class KeyboardQuickSwitchController implements final boolean shouldShowDesktopTasks = mControllers.taskbarDesktopModeController .shouldShowDesktopTasksInTaskbar(); mExcludedTaskIds = taskIdsToExclude; - mTaskListChangeId = mModel.getTasks((tasks) -> { - processLoadedTasks(tasks, taskIdsToExclude); - mQuickSwitchViewController.updateQuickSwitchView( - mTasks, - wasOpenedFromTaskbar ? 0 : mNumHiddenTasks, - currentFocusIndexOverride, - mHasDesktopTask, - mWasDesktopTaskFilteredOut); - }, shouldShowDesktopTasks ? RecentsFilterState.EMPTY_FILTER - : RecentsFilterState.getDesktopTaskFilter()); + mTaskListChangeId = mModel.getTasks( + shouldShowDesktopTasks ? RecentsFilterState.EMPTY_FILTER + : RecentsFilterState.getDesktopTaskFilter(), + (tasks) -> { + processLoadedTasks(tasks, taskIdsToExclude); + mQuickSwitchViewController.updateQuickSwitchView( + mTasks, + wasOpenedFromTaskbar ? 0 : mNumHiddenTasks, + currentFocusIndexOverride, + mHasDesktopTask, + mWasDesktopTaskFilteredOut); + }); } mQuickSwitchViewController.updateLayoutForSurface(wasOpenedFromTaskbar, @@ -221,7 +223,8 @@ public final class KeyboardQuickSwitchController implements } mExcludedTaskIds = taskIdsToExclude; - mTaskListChangeId = mModel.getTasks((tasks) -> { + mTaskListChangeId = mModel.getTasks(shouldShowDesktopTasks ? RecentsFilterState.EMPTY_FILTER + : RecentsFilterState.getDesktopTaskFilter(), (tasks) -> { processLoadedTasks(tasks, taskIdsToExclude); // Check if the first task is running after the recents model has updated so that we use // the correct index. @@ -235,8 +238,7 @@ public final class KeyboardQuickSwitchController implements mHasDesktopTask, mWasDesktopTaskFilteredOut, wasOpenedFromTaskbar); - }, shouldShowDesktopTasks ? RecentsFilterState.EMPTY_FILTER - : RecentsFilterState.getDesktopTaskFilter()); + }); } private boolean shouldExcludeTask(GroupTask task, Set taskIdsToExclude) { diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarRecentAppsController.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarRecentAppsController.kt index 6e44bcd671..541cec7728 100644 --- a/quickstep/src/com/android/launcher3/taskbar/TaskbarRecentAppsController.kt +++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarRecentAppsController.kt @@ -242,26 +242,21 @@ class TaskbarRecentAppsController( private fun reloadRecentTasksIfNeeded() { if (!recentsModel.isTaskListValid(taskListChangeId)) { taskListChangeId = - recentsModel.getTasks( - { tasks -> - recentTasksLoaded = true - allRecentTasks = tasks - val oldRunningTaskdIds = runningTaskIds - val oldMinimizedTaskIds = minimizedTaskIds - desktopTasks = - allRecentTasks.filterIsInstance().flatMap { it.tasks } - val runningTasksChanged = oldRunningTaskdIds != runningTaskIds - val minimizedTasksChanged = oldMinimizedTaskIds != minimizedTaskIds - if ( - onRecentsOrHotseatChanged() || - runningTasksChanged || - minimizedTasksChanged - ) { - controllers.taskbarViewController.commitRunningAppsToUI() - } - }, - RecentsFilterState.EMPTY_FILTER, - ) + recentsModel.getTasks(RecentsFilterState.EMPTY_FILTER) { tasks -> + recentTasksLoaded = true + allRecentTasks = tasks + val oldRunningTaskdIds = runningTaskIds + val oldMinimizedTaskIds = minimizedTaskIds + desktopTasks = + allRecentTasks.filterIsInstance().flatMap { it.tasks } + val runningTasksChanged = oldRunningTaskdIds != runningTaskIds + val minimizedTasksChanged = oldMinimizedTaskIds != minimizedTaskIds + if ( + onRecentsOrHotseatChanged() || runningTasksChanged || minimizedTasksChanged + ) { + controllers.taskbarViewController.commitRunningAppsToUI() + } + } } } diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java index 475a6295db..9e11e70c95 100644 --- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java +++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java @@ -1592,4 +1592,9 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer, public LauncherActivityInterface getContainerInterface() { return LauncherActivityInterface.INSTANCE; } + + @Override + public SplitSelectStateController getSplitSelectStateController() { + return mSplitSelectStateController; + } } diff --git a/quickstep/src/com/android/quickstep/RecentsActivity.java b/quickstep/src/com/android/quickstep/RecentsActivity.java index fd1bd27a80..7261f410bf 100644 --- a/quickstep/src/com/android/quickstep/RecentsActivity.java +++ b/quickstep/src/com/android/quickstep/RecentsActivity.java @@ -242,6 +242,11 @@ public final class RecentsActivity extends StatefulActivity implem return FallbackActivityInterface.INSTANCE; } + @Override + public SplitSelectStateController getSplitSelectStateController() { + return mSplitSelectStateController; + } + @Override public FallbackRecentsView getOverviewPanel() { return mFallbackRecentsView; diff --git a/quickstep/src/com/android/quickstep/RecentsModel.java b/quickstep/src/com/android/quickstep/RecentsModel.java index dcb0a43c3c..001cd4f533 100644 --- a/quickstep/src/com/android/quickstep/RecentsModel.java +++ b/quickstep/src/com/android/quickstep/RecentsModel.java @@ -225,14 +225,14 @@ public class RecentsModel implements RecentTasksDataSource, TaskStackChangeListe /** * Fetches the list of recent tasks, based on a filter * + * @param filter Returns true if a GroupTask should be included into the list passed into + * callback. * @param callback The callback to receive the task plan once its complete or null. This is - * always called on the UI thread. - * @param filter Returns true if a GroupTask should be included into the list passed into - * callback. + * always called on the UI thread. * @return the request id associated with this call. */ - public int getTasks(@Nullable Consumer> callback, Predicate filter) { - return mTaskList.getTasks(/* loadKeysOnly= */ false, callback, filter); + public int getTasks(Predicate filter, @Nullable Consumer> callback) { + return mTaskList.getTasks(false /* loadKeysOnly */, callback, filter); } /** diff --git a/quickstep/src/com/android/quickstep/TouchInteractionService.java b/quickstep/src/com/android/quickstep/TouchInteractionService.java index 88691f3376..7c9db43fdf 100644 --- a/quickstep/src/com/android/quickstep/TouchInteractionService.java +++ b/quickstep/src/com/android/quickstep/TouchInteractionService.java @@ -77,6 +77,7 @@ import com.android.launcher3.Flags; import com.android.launcher3.Launcher; import com.android.launcher3.LauncherPrefs; import com.android.launcher3.anim.AnimatedFloat; +import com.android.launcher3.dagger.LauncherComponentProvider; import com.android.launcher3.desktop.DesktopAppLaunchTransitionManager; import com.android.launcher3.statehandlers.DesktopVisibilityController; import com.android.launcher3.statemanager.StatefulActivity; @@ -817,7 +818,8 @@ public class TouchInteractionService extends Service { mOverviewCommandHelper = new OverviewCommandHelper(this, mOverviewComponentObserver, mDisplayRepository, mTaskbarManager, mTaskAnimationManagerRepository); - mActionCornerHandler = new ActionCornerHandler(mOverviewCommandHelper); + mActionCornerHandler = LauncherComponentProvider.get( + this).getActionCornerHandlerFactory().create(mOverviewCommandHelper); mUserUnlocked = true; mInputConsumer.registerInputConsumer(); mDeviceStateRepository.forEach(/* createIfAbsent= */ true, deviceState -> diff --git a/quickstep/src/com/android/quickstep/actioncorner/ActionCornerHandler.kt b/quickstep/src/com/android/quickstep/actioncorner/ActionCornerHandler.kt index e99b393176..8f7d69e3d6 100644 --- a/quickstep/src/com/android/quickstep/actioncorner/ActionCornerHandler.kt +++ b/quickstep/src/com/android/quickstep/actioncorner/ActionCornerHandler.kt @@ -16,24 +16,185 @@ package com.android.quickstep.actioncorner +import android.app.ActivityOptions +import android.content.Context +import android.window.SplashScreen +import com.android.launcher3.concurrent.annotations.LightweightBackground +import com.android.launcher3.dagger.ApplicationContext +import com.android.launcher3.util.ActivityOptionsWrapper +import com.android.launcher3.util.RunnableList +import com.android.launcher3.util.SplitConfigurationOptions import com.android.quickstep.OverviewCommandHelper +import com.android.quickstep.OverviewCommandHelper.CommandType import com.android.quickstep.OverviewCommandHelper.CommandType.TOGGLE_OVERVIEW_PREVIOUS +import com.android.quickstep.OverviewComponentObserver +import com.android.quickstep.RecentsModel +import com.android.quickstep.TopTaskTracker +import com.android.quickstep.util.AnimUtils +import com.android.quickstep.util.GroupTask +import com.android.quickstep.util.SingleTask +import com.android.quickstep.util.SplitTask +import com.android.quickstep.views.RecentsViewContainer +import com.android.systemui.shared.system.ActivityManagerWrapper import com.android.systemui.shared.system.actioncorner.ActionCornerConstants.Action import com.android.systemui.shared.system.actioncorner.ActionCornerConstants.HOME import com.android.systemui.shared.system.actioncorner.ActionCornerConstants.OVERVIEW +import com.android.wm.shell.shared.GroupedTaskInfo +import com.android.wm.shell.shared.split.SplitScreenConstants +import dagger.assisted.Assisted +import dagger.assisted.AssistedFactory +import dagger.assisted.AssistedInject +import java.util.concurrent.Executor +import java.util.function.Predicate /** * Handles actions triggered from action corners that are mapped to specific functionalities. * Launcher supports both overview and home actions. */ -class ActionCornerHandler(private val overviewCommandHelper: OverviewCommandHelper) { +class ActionCornerHandler +@AssistedInject +constructor( + @ApplicationContext private val context: Context, + private val overviewComponentObserver: OverviewComponentObserver, + private val topTaskTracker: TopTaskTracker, + private val recentsModel: RecentsModel, + private val activityManagerWrapper: ActivityManagerWrapper, + @LightweightBackground private val executor: Executor, + @Assisted private val overviewCommandHelper: OverviewCommandHelper, +) { + @AssistedFactory + interface Factory { + fun create(overviewCommandHelper: OverviewCommandHelper): ActionCornerHandler + } + + private val displayToPreviousScreenMap = HashMap() fun handleAction(@Action action: Int, displayId: Int) { when (action) { // TODO(b/410798748): handle projected mode when launching overview OVERVIEW -> overviewCommandHelper.addCommandsForAllDisplays(TOGGLE_OVERVIEW_PREVIOUS) - HOME -> {} // TODO(b/409036363): handle HOME action + HOME -> handleHomeAction(displayId) else -> {} } } + + private fun handleHomeAction(displayId: Int) { + val topTask = + topTaskTracker.getCachedTopTask(/* filterOnlyVisibleRecents= */ false, displayId) + val groupTask = + topTask.getPlaceholderGroupedTaskInfo(topTaskTracker.runningSplitTaskIds) ?: return + if (!groupTask.isBaseType(GroupedTaskInfo.TYPE_DESK)) { + if ( + topTask.isHomeTask && + getRecentsViewContainer(displayId)?.isRecentsViewVisible == false + ) { + goToPreviousScreen(displayId) + } else { + storeCurrentScreen(displayId, groupTask) + overviewCommandHelper.addCommand(CommandType.HOME, displayId) + } + } else { + // TODO: handle desktop task + } + } + + private fun goToPreviousScreen(displayId: Int) { + val previousScreen = displayToPreviousScreenMap[displayId] + if (previousScreen is PreviousScreen.OverviewScreen) { + overviewCommandHelper.addCommand(CommandType.TOGGLE, displayId) + displayToPreviousScreenMap.remove(displayId) + } else { + // Get it from recentsModel so we have the latest split bound for split task. It also + // checks if the stored task is valid, it would not go to previous screen if the stored + // task is not the latest task. + recentsModel.getTasks(Predicate { it.displayId == displayId }) { + val latestTask = it.last() + val isSameAsStoredTask = + when (previousScreen) { + is PreviousScreen.SingleTaskScreen -> { + latestTask is SingleTask && + latestTask.task.key.id == previousScreen.taskId + } + + is PreviousScreen.SplitTaskScreen -> { + latestTask is SplitTask && + latestTask.topLeftTask.key.id == previousScreen.taskId1 && + latestTask.bottomRightTask.key.id == previousScreen.taskId2 + } + + else -> { + false + } + } + if (isSameAsStoredTask) { + launchGroupTask(latestTask, displayId) + } else { + // Remove the stored task as it is outdated. + displayToPreviousScreenMap.remove(displayId) + } + } + } + } + + private fun storeCurrentScreen(displayId: Int, groupTask: GroupedTaskInfo) { + if (getRecentsViewContainer(displayId)?.isRecentsViewVisible == true) { + displayToPreviousScreenMap[displayId] = PreviousScreen.OverviewScreen + } else { + if (groupTask.isBaseType(GroupedTaskInfo.TYPE_SPLIT)) { + displayToPreviousScreenMap[displayId] = + PreviousScreen.SplitTaskScreen( + groupTask.taskInfo1!!.taskId, + groupTask.taskInfo2!!.taskId, + ) + } else if (groupTask.isBaseType(GroupedTaskInfo.TYPE_FULLSCREEN)) { + displayToPreviousScreenMap[displayId] = + PreviousScreen.SingleTaskScreen(groupTask.taskInfo1!!.taskId) + } + } + } + + private fun launchGroupTask(task: GroupTask, displayId: Int) { + when (task) { + is SingleTask -> + executor.execute { + val activityOptions: ActivityOptions = + makeDefaultActivityOptions(displayId) ?: return@execute + activityManagerWrapper.startActivityFromRecents( + task.task.key.id, + activityOptions, + ) + } + is SplitTask -> { + val splitSelectStateController = + getRecentsViewContainer(displayId)?.splitSelectStateController + splitSelectStateController?.launchExistingSplitPair( + /* groupedTaskView= */ null, + task.topLeftTask.key.id, + task.bottomRightTask.key.id, + SplitConfigurationOptions.STAGE_POSITION_TOP_OR_LEFT, + /* callback= */ { splitSelectStateController.resetState() }, + /* freezeTaskList= */ false, + task.splitBounds?.snapPosition ?: SplitScreenConstants.SNAP_TO_2_50_50, + ) + } + } + } + + private fun getRecentsViewContainer(displayId: Int): RecentsViewContainer? = + overviewComponentObserver.getContainerInterface(displayId)?.getCreatedContainer() + + private fun makeDefaultActivityOptions(displayId: Int): ActivityOptions? { + val callbacks = RunnableList() + val options = ActivityOptions.makeCustomAnimation(context, 0, 0) + options.setSplashScreenStyle(SplashScreen.SPLASH_SCREEN_STYLE_UNDEFINED) + options.setPendingIntentBackgroundActivityStartMode( + ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOW_ALWAYS + ) + + val recentsViewContainer = getRecentsViewContainer(displayId) ?: return null + val endCallback = AnimUtils.completeRunnableListCallback(callbacks, recentsViewContainer) + options.setOnAnimationAbortListener(endCallback) + options.setOnAnimationFinishedListener(endCallback) + return ActivityOptionsWrapper(options, callbacks).options + } } diff --git a/quickstep/src/com/android/quickstep/actioncorner/PreviousScreen.kt b/quickstep/src/com/android/quickstep/actioncorner/PreviousScreen.kt new file mode 100644 index 0000000000..8a72553a9c --- /dev/null +++ b/quickstep/src/com/android/quickstep/actioncorner/PreviousScreen.kt @@ -0,0 +1,27 @@ +/* + * Copyright 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.quickstep.actioncorner + +/** Stores the screen before going home or overview for action corner. */ +sealed class PreviousScreen { + + data class SingleTaskScreen(val taskId: Int) : PreviousScreen() + + data class SplitTaskScreen(val taskId1: Int, val taskId2: Int) : PreviousScreen() + + data object OverviewScreen : PreviousScreen() +} diff --git a/quickstep/src/com/android/quickstep/dagger/QuickstepBaseAppComponent.java b/quickstep/src/com/android/quickstep/dagger/QuickstepBaseAppComponent.java index 77426f3744..a3d222f167 100644 --- a/quickstep/src/com/android/quickstep/dagger/QuickstepBaseAppComponent.java +++ b/quickstep/src/com/android/quickstep/dagger/QuickstepBaseAppComponent.java @@ -32,6 +32,7 @@ import com.android.quickstep.SystemDecorationChangeObserver; import com.android.quickstep.SystemUiProxy; import com.android.quickstep.TaskAnimationManager; import com.android.quickstep.TopTaskTracker; +import com.android.quickstep.actioncorner.ActionCornerHandler; import com.android.quickstep.fallback.window.RecentsWindowManager; import com.android.quickstep.inputconsumers.NavHandleLongPressHandler; import com.android.quickstep.logging.SettingsChangeLogger; @@ -85,4 +86,7 @@ public interface QuickstepBaseAppComponent extends LauncherBaseAppComponent { DisplayRepository getDisplayRepository(); NavHandleLongPressHandler getNavHandleLongPressHandler(); + + /** Gets the factory to create a new ActionCornerHandlerFactory */ + ActionCornerHandler.Factory getActionCornerHandlerFactory(); } diff --git a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt index 762e99f299..dae4874573 100644 --- a/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt +++ b/quickstep/src/com/android/quickstep/fallback/window/RecentsWindowManager.kt @@ -153,6 +153,16 @@ constructor( private var taskbarUIController: TaskbarUIController? = null private val tisBindHelper: TISBindHelper = TISBindHelper(this) {} + private val splitSelectStateController: SplitSelectStateController = + SplitSelectStateController( + /* container= */ this, + stateManager, + /* depthController= */ null, + statsLogManager, + systemUiProxy, + recentsModel, + /* activityBackCallback= */ null, + ) // Callback array that corresponds to events defined in @ActivityEvent private val eventCallbacks = @@ -269,15 +279,7 @@ constructor( ?.apply { init( actionsView, - SplitSelectStateController( - /* container= */ this@RecentsWindowManager, - stateManager, - /* depthController= */ null, - statsLogManager, - systemUiProxy, - recentsModel, - /* activityBackCallback= */ null, - ), + splitSelectStateController, DesktopRecentsTransitionController( stateManager, systemUiProxy, @@ -429,6 +431,10 @@ constructor( return recentsView as T } + override fun getSplitSelectStateController(): SplitSelectStateController { + return splitSelectStateController + } + override fun getRootView(): View? { return windowView } diff --git a/quickstep/src/com/android/quickstep/views/RecentsViewContainer.java b/quickstep/src/com/android/quickstep/views/RecentsViewContainer.java index 706247af7c..031158d886 100644 --- a/quickstep/src/com/android/quickstep/views/RecentsViewContainer.java +++ b/quickstep/src/com/android/quickstep/views/RecentsViewContainer.java @@ -33,6 +33,7 @@ import com.android.launcher3.taskbar.TaskbarUIController; import com.android.launcher3.views.ActivityContext; import com.android.launcher3.views.ScrimView; import com.android.quickstep.BaseContainerInterface; +import com.android.quickstep.util.SplitSelectStateController; /** * Interface to be implemented by the parent view of RecentsView @@ -204,4 +205,9 @@ public interface RecentsViewContainer extends ActivityContext { void setTaskbarUIController(@Nullable TaskbarUIController taskbarUIController); @Nullable TaskbarUIController getTaskbarUIController(); + + /** + * Returns the Split Select State Controller + */ + SplitSelectStateController getSplitSelectStateController(); } diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt index 350c02957f..329d977fc7 100644 --- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt +++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/TaskbarRecentAppsControllerTest.kt @@ -154,7 +154,7 @@ class TaskbarRecentAppsControllerTest : TaskbarBaseTestCase() { @Test fun canShowRunningAndRecentAppsIsFalseAfterInit_getTasksOnlyCalledInInit() { // getTasks() should have been called once from init(). - verify(mockRecentsModel, times(1)).getTasks(any>>(), any()) + verify(mockRecentsModel, times(1)).getTasks(any(), any>>()) recentAppsController.canShowRunningApps = false recentAppsController.canShowRecentApps = false prepareHotseatAndRunningAndRecentApps( @@ -163,7 +163,7 @@ class TaskbarRecentAppsControllerTest : TaskbarBaseTestCase() { recentTaskPackages = listOf(RECENT_PACKAGE_1, RECENT_PACKAGE_2), ) // Verify that getTasks() was not called again after the init(). - verify(mockRecentsModel, times(1)).getTasks(any>>(), any()) + verify(mockRecentsModel, times(1)).getTasks(any(), any>>()) } @Test @@ -1064,12 +1064,12 @@ class TaskbarRecentAppsControllerTest : TaskbarBaseTestCase() { addAll(recentTasks) } doAnswer { - val callback: Consumer> = it.getArgument(0) + val callback: Consumer> = it.getArgument(1) callback.accept(allTasks) taskListChangeId } .whenever(mockRecentsModel) - .getTasks(any>>(), any()) + .getTasks(any(), any>>()) recentTasksChangedListener?.onRecentTasksChanged() } diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/rules/MockedRecentsModelHelper.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/rules/MockedRecentsModelHelper.kt index 25b7971d18..6b34cef3b1 100644 --- a/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/rules/MockedRecentsModelHelper.kt +++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/taskbar/rules/MockedRecentsModelHelper.kt @@ -62,9 +62,9 @@ class MockedRecentsModelHelper { taskListId } - on { getTasks(anyOrNull>>(), anyOrNull()) } doAnswer + on { getTasks(anyOrNull(), anyOrNull>>()) } doAnswer { - val request = it.getArgument>?>(0) + val request = it.getArgument>?>(1) if (request != null) { taskRequests.add { response -> request.accept(response) } } diff --git a/quickstep/tests/multivalentTests/src/com/android/quickstep/actioncorner/ActionCornerHandlerTest.kt b/quickstep/tests/multivalentTests/src/com/android/quickstep/actioncorner/ActionCornerHandlerTest.kt new file mode 100644 index 0000000000..da49533da8 --- /dev/null +++ b/quickstep/tests/multivalentTests/src/com/android/quickstep/actioncorner/ActionCornerHandlerTest.kt @@ -0,0 +1,223 @@ +/* + * Copyright 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.quickstep.actioncorner + +import android.app.ActivityManager.RecentTaskInfo +import android.graphics.Rect +import android.platform.test.annotations.DisableFlags +import android.view.Display.DEFAULT_DISPLAY +import android.window.IWindowContainerToken +import android.window.WindowContainerToken +import androidx.test.filters.SmallTest +import com.android.launcher3.LauncherState +import com.android.launcher3.uioverrides.QuickstepLauncher +import com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR +import com.android.launcher3.util.LauncherMultivalentJUnit +import com.android.launcher3.util.SandboxApplication +import com.android.launcher3.util.TestUtil +import com.android.quickstep.BaseActivityInterface +import com.android.quickstep.OverviewCommandHelper +import com.android.quickstep.OverviewComponentObserver +import com.android.quickstep.RecentsModel +import com.android.quickstep.TopTaskTracker +import com.android.quickstep.util.GroupTask +import com.android.quickstep.util.SingleTask +import com.android.quickstep.util.SplitSelectStateController +import com.android.quickstep.util.SplitTask +import com.android.systemui.shared.recents.model.Task +import com.android.systemui.shared.system.ActivityManagerWrapper +import com.android.systemui.shared.system.actioncorner.ActionCornerConstants.HOME +import com.android.wm.shell.Flags +import com.android.wm.shell.shared.GroupedTaskInfo +import com.android.wm.shell.shared.split.SplitBounds +import com.android.wm.shell.shared.split.SplitScreenConstants +import java.util.function.Consumer +import java.util.function.Predicate +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.ArgumentMatchers.anyInt +import org.mockito.ArgumentMatchers.eq +import org.mockito.Mockito +import org.mockito.kotlin.any +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +@SmallTest +@RunWith(LauncherMultivalentJUnit::class) +@DisableFlags(Flags.FLAG_ENABLE_SHELL_TOP_TASK_TRACKING) +class ActionCornerHandlerTest { + + @get:Rule val context = SandboxApplication() + + private val overviewCommandHelper: OverviewCommandHelper = mock() + private val overviewComponentObserver: OverviewComponentObserver = mock() + private val containerInterface: BaseActivityInterface = mock() + private val recentsViewContainer: QuickstepLauncher = mock() + private val splitSelectStateController: SplitSelectStateController = mock() + + private val topTaskTracker: TopTaskTracker = mock() + + private val recentsModel: RecentsModel = mock() + private val activityManagerWrapper: ActivityManagerWrapper = mock() + + private val bgExecutor = UI_HELPER_EXECUTOR + private val topTask: TopTaskTracker.CachedTaskInfo = mock() + private val actionCornerHandler: ActionCornerHandler = + ActionCornerHandler( + context, + overviewComponentObserver, + topTaskTracker, + recentsModel, + activityManagerWrapper, + bgExecutor, + overviewCommandHelper, + ) + + @Before + fun setup() { + whenever(topTaskTracker.getCachedTopTask(false, DEFAULT_DISPLAY)).thenReturn(topTask) + whenever(containerInterface.getCreatedContainer()).thenReturn(recentsViewContainer) + whenever(overviewComponentObserver.getContainerInterface(any())) + .thenReturn(containerInterface) + whenever(recentsViewContainer.lifecycle).thenReturn(mock()) + whenever(recentsViewContainer.splitSelectStateController) + .thenReturn(splitSelectStateController) + } + + @Test + fun inSingleTask_homeActionCornerTwice_goHomeThenGoBackToSingleTask() { + whenever(topTask.isHomeTask).thenReturn(false) + val taskInfo = createTaskInfo(1) + mockFullScreenTopTask(taskInfo) + + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + verify(overviewCommandHelper) + .addCommand(OverviewCommandHelper.CommandType.HOME, DEFAULT_DISPLAY) + + // Toggle back to the task from home + mockAtHome() + mockRecentsModelTasks(listOf(SingleTask(Task.from(taskInfo)))) + + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + TestUtil.runOnExecutorSync(bgExecutor) {} + verify(activityManagerWrapper).startActivityFromRecents(eq(1), any()) + } + + @Test + fun inSplitTask_homeActionCornerTwice_goHomeThenGoBackToSplitTask() { + whenever(topTask.isHomeTask).thenReturn(false) + val taskInfo1 = createTaskInfo(1) + val taskInfo2 = createTaskInfo(2) + mockSplitTopTask(taskInfo1, taskInfo2) + + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + verify(overviewCommandHelper) + .addCommand(OverviewCommandHelper.CommandType.HOME, DEFAULT_DISPLAY) + + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + mockAtHome() + val splitBounds = SplitBounds(Rect(), Rect(), 1, 2, SplitScreenConstants.SNAP_TO_2_33_66) + mockRecentsModelTasks( + listOf(SplitTask(Task.from(taskInfo1), Task.from(taskInfo2), splitBounds)) + ) + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + verify(splitSelectStateController) + .launchExistingSplitPair( + eq(null), + eq(taskInfo1.taskId), + eq(taskInfo2.taskId), + anyInt(), + any(), + eq(false), + eq(SplitScreenConstants.SNAP_TO_2_33_66), + ) + } + + @Test + fun atHome_homeActionCorner_doNothing() { + mockAtHome() + + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + verify(overviewCommandHelper, never()) + .addCommand(OverviewCommandHelper.CommandType.HOME, DEFAULT_DISPLAY) + verify(activityManagerWrapper, never()).startActivityFromRecents(eq(1), any()) + } + + @Test + fun inSingleTask_homeActionCorner_changeTask_goHome_homeActionCorner_doNothing() { + whenever(topTask.isHomeTask).thenReturn(false) + val taskInfo = createTaskInfo(1) + mockFullScreenTopTask(taskInfo) + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + + // Change task + val taskInfo2 = createTaskInfo(2) + mockFullScreenTopTask(taskInfo2) + mockRecentsModelTasks(listOf(SingleTask(Task.from(taskInfo2)))) + mockAtHome() + + // Do not go back to any task because the latest task was changed after going home by + // action corner + actionCornerHandler.handleAction(HOME, DEFAULT_DISPLAY) + verify(activityManagerWrapper, never()).startActivityFromRecents(anyInt(), any()) + } + + private fun mockFullScreenTopTask(taskInfo: RecentTaskInfo) { + val groupedTask = GroupedTaskInfo.forFullscreenTasks(taskInfo) + whenever(topTaskTracker.runningSplitTaskIds).thenReturn(intArrayOf()) + whenever(topTask.getPlaceholderGroupedTaskInfo(any())).thenReturn(groupedTask) + } + + private fun mockSplitTopTask(task1: RecentTaskInfo, task2: RecentTaskInfo) { + val splitGroupedTask = GroupedTaskInfo.forSplitTasks(task1, task2, null) + whenever(topTaskTracker.runningSplitTaskIds) + .thenReturn(intArrayOf(task1.getTaskId(), task2.getTaskId())) + whenever(topTask.getPlaceholderGroupedTaskInfo(any())).thenReturn(splitGroupedTask) + } + + private fun mockAtHome() { + whenever(topTask.isHomeTask).thenReturn(true) + whenever(recentsViewContainer.isRecentsViewVisible).thenReturn(false) + } + + private fun mockRecentsModelTasks(tasks: List) { + whenever(recentsModel.getTasks(any(), any>>())).thenAnswer { + invocation -> + val filter = invocation.getArgument>(0) + val callback = invocation.getArgument>>(1) + callback.accept(ArrayList(tasks.stream().filter(filter).toList())) + 0 + } + } + + private fun createTaskInfo(id: Int) = + RecentTaskInfo().apply { + taskId = id + displayId = DEFAULT_DISPLAY + token = WindowContainerToken(Mockito.mock(IWindowContainerToken::class.java)) + } +}