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

Commit 70de8a48 authored by Jagrut Desai's avatar Jagrut Desai
Browse files

TaskbarPinningController Unit Tests 

Test: Presubmit
Bug: 265439107
Flag: NONE

Change-Id: I5da3558adf88126b07c5d6217ee4fbbcc1e2e348
parent 98057e74

quickstep/src/com/android/launcher3/taskbar/TaskbarActivityContext.java

+10 −0
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ import androidx.annotation.VisibleForTesting; 
import com.android.launcher3.AbstractFloatingView;

import com.android.launcher3.BubbleTextView;

import com.android.launcher3.DeviceProfile;

import com.android.launcher3.LauncherPrefs;

import com.android.launcher3.LauncherSettings.Favorites;

import com.android.launcher3.R;

import com.android.launcher3.anim.AnimatorPlaybackController;
@@ -182,6 +183,8 @@ public class TaskbarActivityContext extends BaseTaskbarContext { 


    private DeviceProfile mPersistentTaskbarDeviceProfile;



    private final LauncherPrefs mLauncherPrefs;



    public TaskbarActivityContext(Context windowContext,

            @Nullable Context navigationBarPanelContext, DeviceProfile launcherDp,

            TaskbarNavButtonController buttonController, ScopedUnfoldTransitionProgressProvider
@@ -293,6 +296,8 @@ public class TaskbarActivityContext extends BaseTaskbarContext { 
                new KeyboardQuickSwitchController(),

                new TaskbarPinningController(this),

                bubbleControllersOptional);



        mLauncherPrefs = LauncherPrefs.get(this);

    }



    /** Updates {@link DeviceProfile} instances for any Taskbar windows. */
@@ -410,6 +415,11 @@ public class TaskbarActivityContext extends BaseTaskbarContext { 
                getDeviceProfile().toSmallString());

    }



    @NonNull

    public LauncherPrefs getLauncherPrefs() {

        return mLauncherPrefs;

    }



    /**

     * Returns the View bounds of transient taskbar.

     */

quickstep/src/com/android/launcher3/taskbar/TaskbarPinningController.kt

+50 −31
Original line number Diff line number Diff line
@@ -16,7 +16,9 @@ 
package com.android.launcher3.taskbar



import android.animation.AnimatorSet

import android.annotation.SuppressLint

import android.view.View

import androidx.annotation.VisibleForTesting

import androidx.core.animation.doOnEnd

import com.android.launcher3.LauncherPrefs

import com.android.launcher3.LauncherPrefs.Companion.TASKBAR_PINNING
@@ -31,29 +33,23 @@ class TaskbarPinningController(private val context: TaskbarActivityContext) : 


    private lateinit var controllers: TaskbarControllers

    private lateinit var taskbarSharedState: TaskbarSharedState

    private val launcherPrefs = LauncherPrefs.get(context)

    private lateinit var launcherPrefs: LauncherPrefs

    private val statsLogManager = context.statsLogManager

    private var isAnimatingTaskbarPinning = false

    @VisibleForTesting var isAnimatingTaskbarPinning = false

    @VisibleForTesting lateinit var onCloseCallback: (preferenceChanged: Boolean) -> Unit



    @SuppressLint("VisibleForTests")

    fun init(taskbarControllers: TaskbarControllers, sharedState: TaskbarSharedState) {

        controllers = taskbarControllers

        taskbarSharedState = sharedState

    }



    fun showPinningView(view: View) {

        context.isTaskbarWindowFullscreen = true



        view.post {

            val popupView = createAndPopulate(view, context)

            popupView.requestFocus()



            popupView.onCloseCallback =

                callback@{ didPreferenceChange ->

        launcherPrefs = context.launcherPrefs

        onCloseCallback =

            fun(didPreferenceChange: Boolean) {

                statsLogManager.logger().log(LAUNCHER_TASKBAR_DIVIDER_MENU_CLOSE)

                context.dragLayer.post { context.onPopupVisibilityChanged(false) }



                if (!didPreferenceChange) {

                        return@callback

                    return

                }

                val animateToValue =

                    if (!launcherPrefs.get(TASKBAR_PINNING)) {
@@ -64,13 +60,41 @@ class TaskbarPinningController(private val context: TaskbarActivityContext) : 
                taskbarSharedState.taskbarWasPinned = animateToValue == PINNING_TRANSIENT

                animateTaskbarPinning(animateToValue)

            }

    }



    fun showPinningView(view: View) {

        context.isTaskbarWindowFullscreen = true

        view.post {

            val popupView = getPopupView(view)

            popupView.requestFocus()

            popupView.onCloseCallback = onCloseCallback

            context.onPopupVisibilityChanged(true)

            popupView.show()

            statsLogManager.logger().log(LAUNCHER_TASKBAR_DIVIDER_MENU_OPEN)

        }

    }



    private fun animateTaskbarPinning(animateToValue: Float) {

    @VisibleForTesting

    fun getPopupView(view: View): TaskbarDividerPopupView<*> {

        return createAndPopulate(view, context)

    }



    @VisibleForTesting

    fun animateTaskbarPinning(animateToValue: Float) {

        val taskbarViewController = controllers.taskbarViewController

        val animatorSet =

            getAnimatorSetForTaskbarPinningAnimation(animateToValue).apply {

                doOnEnd { recreateTaskbarAndUpdatePinningValue() }

                duration = PINNING_ANIMATION_DURATION

            }

        controllers.taskbarOverlayController.hideWindow()

        updateIsAnimatingTaskbarPinningAndNotifyTaskbarDragLayer(true)

        taskbarViewController.animateAwayNotificationDotsDuringTaskbarPinningAnimation()

        animatorSet.start()

    }



    @VisibleForTesting

    fun getAnimatorSetForTaskbarPinningAnimation(animateToValue: Float): AnimatorSet {

        val animatorSet = AnimatorSet()

        val taskbarViewController = controllers.taskbarViewController

        val dragLayerController = controllers.taskbarDragLayerController
@@ -82,13 +106,7 @@ class TaskbarPinningController(private val context: TaskbarActivityContext) : 
            taskbarViewController.taskbarIconTranslationXForPinning.animateToValue(animateToValue)

        )



        controllers.taskbarOverlayController.hideWindow()



        animatorSet.doOnEnd { recreateTaskbarAndUpdatePinningValue() }

        animatorSet.duration = PINNING_ANIMATION_DURATION

        updateIsAnimatingTaskbarPinningAndNotifyTaskbarDragLayer(true)

        taskbarViewController.animateAwayNotificationDotsDuringTaskbarPinningAnimation()

        animatorSet.start()

        return animatorSet

    }



    private fun updateIsAnimatingTaskbarPinningAndNotifyTaskbarDragLayer(isAnimating: Boolean) {
@@ -96,7 +114,8 @@ class TaskbarPinningController(private val context: TaskbarActivityContext) : 
        context.dragLayer.setAnimatingTaskbarPinning(isAnimating)

    }



    private fun recreateTaskbarAndUpdatePinningValue() {

    @VisibleForTesting

    fun recreateTaskbarAndUpdatePinningValue() {

        updateIsAnimatingTaskbarPinningAndNotifyTaskbarDragLayer(false)

        launcherPrefs.put(TASKBAR_PINNING, !launcherPrefs.get(TASKBAR_PINNING))

    }

quickstep/src/com/android/launcher3/taskbar/TaskbarSharedState.java

+10 −2
Original line number Diff line number Diff line
@@ -73,9 +73,17 @@ public class TaskbarSharedState { 
    };



    // Allows us to shift translation logic when doing taskbar pinning animation.

    public Boolean startTaskbarVariantIsTransient = true;

    public boolean startTaskbarVariantIsTransient = true;



    // To track if taskbar was pinned using taskbar pinning feature at the time of recreate,

    // so we can unstash transient taskbar when we un-pinning taskbar.

    public Boolean taskbarWasPinned = false;

    private boolean mTaskbarWasPinned = false;



    public boolean getTaskbarWasPinned() {

        return mTaskbarWasPinned;

    }



    public void setTaskbarWasPinned(boolean taskbarWasPinned) {

        mTaskbarWasPinned = taskbarWasPinned;

    }

}

quickstep/src/com/android/launcher3/taskbar/TaskbarStashController.java

+2 −2
Original line number Diff line number Diff line
@@ -307,7 +307,7 @@ public class TaskbarStashController implements TaskbarControllers.LoggableTaskba 
        boolean isTransientTaskbar = DisplayController.isTransientTaskbar(mActivity);

        boolean isInSetup = !mActivity.isUserSetupComplete() || setupUIVisible;

        updateStateForFlag(FLAG_STASHED_IN_APP_AUTO,

                isTransientTaskbar && !mTaskbarSharedState.taskbarWasPinned);

                isTransientTaskbar && !mTaskbarSharedState.getTaskbarWasPinned());

        updateStateForFlag(FLAG_STASHED_IN_APP_SETUP, isInSetup);

        updateStateForFlag(FLAG_IN_SETUP, isInSetup);

        updateStateForFlag(FLAG_STASHED_SMALL_SCREEN, isPhoneMode()
@@ -316,7 +316,7 @@ public class TaskbarStashController implements TaskbarControllers.LoggableTaskba 
        // us that we're paused until a bit later. This avoids flickering upon recreating taskbar.

        updateStateForFlag(FLAG_IN_APP, true);

        applyState(/* duration = */ 0);

        if (mTaskbarSharedState.taskbarWasPinned) {

        if (mTaskbarSharedState.getTaskbarWasPinned()) {

            tryStartTaskbarTimeout();

        }

        notifyStashChange(/* visible */ false, /* stashed */ isStashedInApp());

quickstep/tests/src/com/android/quickstep/taskbar/controllers/TaskbarPinningControllerTest.kt

0 → 100644
+202 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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.taskbar.controllers



import android.animation.AnimatorSet

import android.animation.ObjectAnimator

import android.view.View

import androidx.test.ext.junit.runners.AndroidJUnit4

import androidx.test.filters.SmallTest

import com.android.launcher3.LauncherPrefs

import com.android.launcher3.LauncherPrefs.Companion.TASKBAR_PINNING

import com.android.launcher3.logging.StatsLogManager

import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_DIVIDER_MENU_CLOSE

import com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_TASKBAR_DIVIDER_MENU_OPEN

import com.android.launcher3.taskbar.TaskbarActivityContext

import com.android.launcher3.taskbar.TaskbarBaseTestCase

import com.android.launcher3.taskbar.TaskbarDividerPopupView

import com.android.launcher3.taskbar.TaskbarDragLayer

import com.android.launcher3.taskbar.TaskbarPinningController

import com.android.launcher3.taskbar.TaskbarPinningController.Companion.PINNING_PERSISTENT

import com.android.launcher3.taskbar.TaskbarPinningController.Companion.PINNING_TRANSIENT

import com.android.launcher3.taskbar.TaskbarSharedState

import com.google.common.truth.Truth.assertThat

import org.junit.Before

import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.kotlin.any

import org.mockito.kotlin.argumentCaptor

import org.mockito.kotlin.doNothing

import org.mockito.kotlin.doReturn

import org.mockito.kotlin.mock

import org.mockito.kotlin.never

import org.mockito.kotlin.spy

import org.mockito.kotlin.times

import org.mockito.kotlin.verify

import org.mockito.kotlin.whenever



@SmallTest

@RunWith(AndroidJUnit4::class)

class TaskbarPinningControllerTest : TaskbarBaseTestCase() {

    private val taskbarDragLayer = mock<TaskbarDragLayer>()

    private val taskbarSharedState = mock<TaskbarSharedState>()

    private val launcherPrefs = mock<LauncherPrefs> { on { get(TASKBAR_PINNING) } doReturn false }

    private val statsLogger = mock<StatsLogManager.StatsLogger>()

    private val statsLogManager = mock<StatsLogManager> { on { logger() } doReturn statsLogger }

    private lateinit var pinningController: TaskbarPinningController



    @Before

    override fun setup() {

        super.setup()

        whenever(taskbarActivityContext.launcherPrefs).thenReturn(launcherPrefs)

        whenever(taskbarActivityContext.dragLayer).thenReturn(taskbarDragLayer)

        whenever(taskbarActivityContext.statsLogManager).thenReturn(statsLogManager)

        pinningController = spy(TaskbarPinningController(taskbarActivityContext))

        pinningController.init(taskbarControllers, taskbarSharedState)

    }



    @Test

    fun testOnCloseCallback_whenClosingPopupView_shouldLogStatsForClosingPopupMenu() {

        pinningController.onCloseCallback(false)

        verify(statsLogger, times(1)).log(LAUNCHER_TASKBAR_DIVIDER_MENU_CLOSE)

    }



    @Test

    fun testOnCloseCallback_whenClosingPopupView_shouldPostVisibilityChangedToDragLayer() {

        val argumentCaptor = argumentCaptor<Runnable>()

        pinningController.onCloseCallback(false)

        verify(taskbarDragLayer, times(1)).post(argumentCaptor.capture())



        val runnable = argumentCaptor.lastValue

        assertThat(runnable).isNotNull()



        runnable.run()

        verify(taskbarActivityContext, times(1)).onPopupVisibilityChanged(false)

    }



    @Test

    fun testOnCloseCallback_whenPreferenceUnchanged_shouldNotAnimateTaskbarPinning() {

        pinningController.onCloseCallback(false)

        verify(taskbarSharedState, never()).taskbarWasPinned = true

        verify(pinningController, never()).animateTaskbarPinning(any())

    }



    @Test

    fun testOnCloseCallback_whenPreferenceChanged_shouldAnimateToPinnedTaskbar() {

        whenever(launcherPrefs.get(TASKBAR_PINNING)).thenReturn(false)

        doNothing().whenever(pinningController).animateTaskbarPinning(any())



        pinningController.onCloseCallback(true)



        verify(taskbarSharedState, times(1)).taskbarWasPinned = false

        verify(pinningController, times(1)).animateTaskbarPinning(PINNING_PERSISTENT)

    }



    @Test

    fun testOnCloseCallback_whenPreferenceChanged_shouldAnimateToTransientTaskbar() {

        whenever(launcherPrefs.get(TASKBAR_PINNING)).thenReturn(true)

        doNothing().whenever(pinningController).animateTaskbarPinning(any())



        pinningController.onCloseCallback(true)



        verify(taskbarSharedState, times(1)).taskbarWasPinned = true

        verify(pinningController, times(1)).animateTaskbarPinning(PINNING_TRANSIENT)

    }



    @Test

    fun testShowPinningView_whenShowingPinningView_shouldSetTaskbarWindowFullscreenAndPostRunnableToView() {

        val popupView =

            mock<TaskbarDividerPopupView<TaskbarActivityContext>> {

                on { requestFocus() } doReturn true

            }

        val view = mock<View>()

        val argumentCaptor = argumentCaptor<Runnable>()

        doReturn(popupView).whenever(pinningController).getPopupView(view)



        pinningController.showPinningView(view)



        verify(view, times(1)).post(argumentCaptor.capture())



        val runnable = argumentCaptor.lastValue

        assertThat(runnable).isNotNull()

        runnable.run()



        verify(pinningController, times(1)).getPopupView(view)

        verify(popupView, times(1)).requestFocus()

        verify(popupView, times(1)).onCloseCallback = any()

        verify(taskbarActivityContext, times(1)).onPopupVisibilityChanged(true)

        verify(popupView, times(1)).show()

        verify(statsLogger, times(1)).log(LAUNCHER_TASKBAR_DIVIDER_MENU_OPEN)

    }



    @Test

    fun testAnimateTaskbarPinning_whenAnimationEnds_shouldInvokeCallbackDoOnEnd() {

        val animatorSet = spy(AnimatorSet())

        doReturn(animatorSet)

            .whenever(pinningController)

            .getAnimatorSetForTaskbarPinningAnimation(PINNING_PERSISTENT)

        doNothing().whenever(animatorSet).start()

        pinningController.animateTaskbarPinning(PINNING_PERSISTENT)

        animatorSet.listeners[0].onAnimationEnd(ObjectAnimator())

        verify(pinningController, times(1)).recreateTaskbarAndUpdatePinningValue()

    }



    @Test

    fun testAnimateTaskbarPinning_whenAnimatingToPersistentTaskbar_shouldAnimateToPinnedTaskbar() {

        val animatorSet = spy(AnimatorSet())

        doReturn(animatorSet)

            .whenever(pinningController)

            .getAnimatorSetForTaskbarPinningAnimation(PINNING_PERSISTENT)

        doNothing().whenever(animatorSet).start()

        pinningController.animateTaskbarPinning(PINNING_PERSISTENT)



        verify(taskbarOverlayController, times(1)).hideWindow()

        verify(pinningController, times(1))

            .getAnimatorSetForTaskbarPinningAnimation(PINNING_PERSISTENT)

        verify(taskbarViewController, times(1))

            .animateAwayNotificationDotsDuringTaskbarPinningAnimation()

        verify(taskbarDragLayer, times(1)).setAnimatingTaskbarPinning(true)

        assertThat(pinningController.isAnimatingTaskbarPinning).isTrue()

        assertThat(animatorSet.listeners).isNotNull()

    }



    @Test

    fun testAnimateTaskbarPinning_whenAnimatingToTransientTaskbar_shouldAnimateToTransientTaskbar() {

        val animatorSet = spy(AnimatorSet())

        doReturn(animatorSet)

            .whenever(pinningController)

            .getAnimatorSetForTaskbarPinningAnimation(PINNING_TRANSIENT)

        doNothing().whenever(animatorSet).start()

        pinningController.animateTaskbarPinning(PINNING_TRANSIENT)



        verify(taskbarOverlayController, times(1)).hideWindow()

        verify(pinningController, times(1))

            .getAnimatorSetForTaskbarPinningAnimation(PINNING_TRANSIENT)

        verify(taskbarDragLayer, times(1)).setAnimatingTaskbarPinning(true)

        assertThat(pinningController.isAnimatingTaskbarPinning).isTrue()

        verify(taskbarViewController, times(1))

            .animateAwayNotificationDotsDuringTaskbarPinningAnimation()

        assertThat(animatorSet.listeners).isNotNull()

    }



    @Test

    fun testRecreateTaskbarAndUpdatePinningValue_whenAnimationEnds_shouldUpdateTaskbarPinningLauncherPref() {

        pinningController.recreateTaskbarAndUpdatePinningValue()

        verify(taskbarDragLayer, times(1)).setAnimatingTaskbarPinning(false)

        assertThat(pinningController.isAnimatingTaskbarPinning).isFalse()

        verify(launcherPrefs, times(1)).put(TASKBAR_PINNING, true)

    }

}