317 lines
13 KiB
Kotlin
317 lines
13 KiB
Kotlin
/*
|
|
* 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.launcher3.uioverrides.touchcontrollers
|
|
|
|
import android.content.Context
|
|
import android.graphics.Rect
|
|
import android.view.MotionEvent
|
|
import androidx.dynamicanimation.animation.SpringAnimation
|
|
import com.android.app.animation.Interpolators.DECELERATE
|
|
import com.android.app.animation.Interpolators.LINEAR
|
|
import com.android.launcher3.AbstractFloatingView
|
|
import com.android.launcher3.R
|
|
import com.android.launcher3.Utilities.EDGE_NAV_BAR
|
|
import com.android.launcher3.Utilities.boundToRange
|
|
import com.android.launcher3.Utilities.debugLog
|
|
import com.android.launcher3.Utilities.isRtl
|
|
import com.android.launcher3.Utilities.mapToRange
|
|
import com.android.launcher3.touch.SingleAxisSwipeDetector
|
|
import com.android.launcher3.util.MSDLPlayerWrapper
|
|
import com.android.launcher3.util.TouchController
|
|
import com.android.quickstep.views.RecentsView
|
|
import com.android.quickstep.views.RecentsView.RECENTS_SCALE_PROPERTY
|
|
import com.android.quickstep.views.RecentsViewContainer
|
|
import com.android.quickstep.views.TaskView
|
|
import com.google.android.msdl.data.model.MSDLToken
|
|
import kotlin.math.abs
|
|
|
|
/** Touch controller for handling task view card dismiss swipes */
|
|
class TaskViewDismissTouchController<CONTAINER>(
|
|
private val container: CONTAINER,
|
|
private val taskViewRecentsTouchContext: TaskViewRecentsTouchContext,
|
|
) : TouchController, SingleAxisSwipeDetector.Listener where
|
|
CONTAINER : Context,
|
|
CONTAINER : RecentsViewContainer {
|
|
private val recentsView: RecentsView<*, *> = container.getOverviewPanel()
|
|
private val detector: SingleAxisSwipeDetector =
|
|
SingleAxisSwipeDetector(
|
|
container as Context,
|
|
this,
|
|
recentsView.pagedOrientationHandler.upDownSwipeDirection,
|
|
)
|
|
private val isRtl = isRtl(container.resources)
|
|
private val upDirection: Int = recentsView.pagedOrientationHandler.getUpDirection(isRtl)
|
|
|
|
private val tempTaskThumbnailBounds = Rect()
|
|
|
|
private var taskBeingDragged: TaskView? = null
|
|
private var springAnimation: SpringAnimation? = null
|
|
private var dismissLength: Int = 0
|
|
private var verticalFactor: Int = 0
|
|
private var hasDismissThresholdHapticRun = false
|
|
private var initialDisplacement: Float = 0f
|
|
private var recentsScaleAnimation: SpringAnimation? = null
|
|
private var isBlockedDuringDismissal = false
|
|
|
|
private fun canInterceptTouch(ev: MotionEvent): Boolean =
|
|
when {
|
|
// Don't intercept swipes on the nav bar, as user might be trying to go home during a
|
|
// task dismiss animation.
|
|
(ev.edgeFlags and EDGE_NAV_BAR) != 0 -> {
|
|
debugLog(TAG, "Not intercepting edge swipe on nav bar.")
|
|
false
|
|
}
|
|
|
|
// Floating views that a TouchController should not try to intercept touches from.
|
|
AbstractFloatingView.getTopOpenViewWithType(
|
|
container,
|
|
AbstractFloatingView.TYPE_TOUCH_CONTROLLER_NO_INTERCEPT,
|
|
) != null -> {
|
|
debugLog(TAG, "Not intercepting, open floating view blocking touch.")
|
|
false
|
|
}
|
|
|
|
// Disable swiping if the task overlay is modal.
|
|
taskViewRecentsTouchContext.isRecentsModal -> {
|
|
debugLog(TAG, "Not intercepting touch in modal overlay.")
|
|
false
|
|
}
|
|
|
|
else ->
|
|
taskViewRecentsTouchContext.isRecentsInteractive.also { isRecentsInteractive ->
|
|
if (!isRecentsInteractive) {
|
|
debugLog(TAG, "Not intercepting touch, recents not interactive.")
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onControllerInterceptTouchEvent(ev: MotionEvent): Boolean {
|
|
if ((ev.action == MotionEvent.ACTION_UP || ev.action == MotionEvent.ACTION_CANCEL)) {
|
|
clearState()
|
|
}
|
|
if (ev.action == MotionEvent.ACTION_DOWN) {
|
|
if (!onActionDown(ev)) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
onControllerTouchEvent(ev)
|
|
val upDirectionIsPositive = upDirection == SingleAxisSwipeDetector.DIRECTION_POSITIVE
|
|
val wasInitialTouchUp =
|
|
(upDirectionIsPositive && detector.wasInitialTouchPositive()) ||
|
|
(!upDirectionIsPositive && !detector.wasInitialTouchPositive())
|
|
return detector.isDraggingState && wasInitialTouchUp
|
|
}
|
|
|
|
override fun onControllerTouchEvent(ev: MotionEvent?): Boolean = detector.onTouchEvent(ev)
|
|
|
|
private fun onActionDown(ev: MotionEvent): Boolean {
|
|
springAnimation?.cancel()
|
|
recentsScaleAnimation?.cancel()
|
|
if (!canInterceptTouch(ev)) {
|
|
return false
|
|
}
|
|
taskBeingDragged =
|
|
recentsView.taskViews
|
|
.firstOrNull {
|
|
recentsView.isTaskViewVisible(it) && container.dragLayer.isEventOverView(it, ev)
|
|
}
|
|
?.also {
|
|
val secondaryLayerDimension =
|
|
recentsView.pagedOrientationHandler.getSecondaryDimension(
|
|
container.dragLayer
|
|
)
|
|
// Dismiss length as bottom of task so it is fully off screen when dismissed.
|
|
it.getThumbnailBounds(tempTaskThumbnailBounds, relativeToDragLayer = true)
|
|
dismissLength =
|
|
recentsView.pagedOrientationHandler.getTaskDismissLength(
|
|
secondaryLayerDimension,
|
|
tempTaskThumbnailBounds,
|
|
)
|
|
verticalFactor =
|
|
recentsView.pagedOrientationHandler.getTaskDismissVerticalDirection()
|
|
}
|
|
detector.setDetectableScrollConditions(upDirection, /* ignoreSlop= */ false)
|
|
return true
|
|
}
|
|
|
|
override fun onDragStart(start: Boolean, startDisplacement: Float) {
|
|
if (isBlockedDuringDismissal) return
|
|
val taskBeingDragged = taskBeingDragged ?: return
|
|
debugLog(TAG, "Handling touch event.")
|
|
|
|
initialDisplacement =
|
|
taskBeingDragged.secondaryDismissTranslationProperty.get(taskBeingDragged)
|
|
|
|
// Add a tiny bit of translation Z, so that it draws on top of other views. This is relevant
|
|
// (e.g.) when we dismiss a task by sliding it upward: if there is a row of icons above, we
|
|
// want the dragged task to stay above all other views.
|
|
taskBeingDragged.translationZ = 0.1f
|
|
}
|
|
|
|
override fun onDrag(displacement: Float): Boolean {
|
|
if (isBlockedDuringDismissal) return true
|
|
val taskBeingDragged = taskBeingDragged ?: return false
|
|
val currentDisplacement = displacement + initialDisplacement
|
|
val boundedDisplacement =
|
|
boundToRange(abs(currentDisplacement), 0f, dismissLength.toFloat())
|
|
// When swiping below origin, allow slight undershoot to simulate resisting the movement.
|
|
val totalDisplacement =
|
|
if (recentsView.pagedOrientationHandler.isGoingUp(currentDisplacement, isRtl))
|
|
boundedDisplacement * verticalFactor
|
|
else
|
|
mapToRange(
|
|
boundedDisplacement,
|
|
0f,
|
|
dismissLength.toFloat(),
|
|
0f,
|
|
container.resources.getDimension(R.dimen.task_dismiss_max_undershoot),
|
|
DECELERATE,
|
|
) * -verticalFactor
|
|
taskBeingDragged.secondaryDismissTranslationProperty.setValue(
|
|
taskBeingDragged,
|
|
totalDisplacement,
|
|
)
|
|
if (taskBeingDragged.isRunningTask && recentsView.enableDrawingLiveTile) {
|
|
recentsView.runActionOnRemoteHandles { remoteTargetHandle ->
|
|
remoteTargetHandle.taskViewSimulator.taskSecondaryTranslation.value =
|
|
totalDisplacement
|
|
}
|
|
recentsView.redrawLiveTile()
|
|
}
|
|
val dismissFraction = displacement / (dismissLength * verticalFactor).toFloat()
|
|
RECENTS_SCALE_PROPERTY.setValue(recentsView, getRecentsScale(dismissFraction))
|
|
playDismissThresholdHaptic(displacement)
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Play a haptic to alert the user they have passed the dismiss threshold.
|
|
*
|
|
* <p>Check within a range of the threshold value, as the drag event does not necessarily happen
|
|
* at the exact threshold's displacement.
|
|
*/
|
|
private fun playDismissThresholdHaptic(displacement: Float) {
|
|
val dismissThreshold = (DISMISS_THRESHOLD_FRACTION * dismissLength * verticalFactor)
|
|
val inHapticRange =
|
|
displacement >= (dismissThreshold - DISMISS_THRESHOLD_HAPTIC_RANGE) &&
|
|
displacement <= (dismissThreshold + DISMISS_THRESHOLD_HAPTIC_RANGE)
|
|
if (!inHapticRange) {
|
|
hasDismissThresholdHapticRun = false
|
|
} else if (!hasDismissThresholdHapticRun) {
|
|
MSDLPlayerWrapper.INSTANCE.get(recentsView.context)
|
|
.playToken(MSDLToken.SWIPE_THRESHOLD_INDICATOR)
|
|
hasDismissThresholdHapticRun = true
|
|
}
|
|
}
|
|
|
|
override fun onDragEnd(velocity: Float) {
|
|
if (isBlockedDuringDismissal) return
|
|
val taskBeingDragged = taskBeingDragged ?: return
|
|
|
|
val currentDisplacement =
|
|
taskBeingDragged.secondaryDismissTranslationProperty.get(taskBeingDragged)
|
|
val isBeyondDismissThreshold =
|
|
abs(currentDisplacement) > abs(DISMISS_THRESHOLD_FRACTION * dismissLength)
|
|
val velocityIsGoingUp = recentsView.pagedOrientationHandler.isGoingUp(velocity, isRtl)
|
|
val isFlingingTowardsDismiss = detector.isFling(velocity) && velocityIsGoingUp
|
|
val isFlingingTowardsRestState = detector.isFling(velocity) && !velocityIsGoingUp
|
|
val isDismissing =
|
|
isFlingingTowardsDismiss || (isBeyondDismissThreshold && !isFlingingTowardsRestState)
|
|
springAnimation =
|
|
recentsView
|
|
.createTaskDismissSettlingSpringAnimation(
|
|
taskBeingDragged,
|
|
velocity,
|
|
isDismissing,
|
|
dismissLength,
|
|
this::clearState,
|
|
)
|
|
.apply {
|
|
animateToFinalPosition(
|
|
if (isDismissing) (dismissLength * verticalFactor).toFloat() else 0f
|
|
)
|
|
}
|
|
isBlockedDuringDismissal = true
|
|
recentsScaleAnimation =
|
|
recentsView.animateRecentsScale(RECENTS_SCALE_DEFAULT).addEndListener { _, _, _, _ ->
|
|
recentsScaleAnimation = null
|
|
}
|
|
}
|
|
|
|
private fun clearState() {
|
|
detector.finishedScrolling()
|
|
detector.setDetectableScrollConditions(0, false)
|
|
taskBeingDragged?.translationZ = 0f
|
|
taskBeingDragged = null
|
|
springAnimation = null
|
|
isBlockedDuringDismissal = false
|
|
}
|
|
|
|
private fun getRecentsScale(dismissFraction: Float): Float {
|
|
return when {
|
|
// Do not scale recents when dragging below origin.
|
|
dismissFraction <= 0 -> {
|
|
RECENTS_SCALE_DEFAULT
|
|
}
|
|
// Initially scale recents as the drag begins, up to the first threshold.
|
|
dismissFraction < RECENTS_SCALE_FIRST_THRESHOLD_FRACTION -> {
|
|
mapToRange(
|
|
dismissFraction,
|
|
0f,
|
|
RECENTS_SCALE_FIRST_THRESHOLD_FRACTION,
|
|
RECENTS_SCALE_DEFAULT,
|
|
RECENTS_SCALE_ON_DISMISS_CANCEL,
|
|
LINEAR,
|
|
)
|
|
}
|
|
// Keep scale consistent until dragging to the dismiss threshold.
|
|
dismissFraction < RECENTS_SCALE_DISMISS_THRESHOLD_FRACTION -> {
|
|
RECENTS_SCALE_ON_DISMISS_CANCEL
|
|
}
|
|
// Scale beyond the dismiss threshold again, to indicate dismiss will occur on release.
|
|
dismissFraction < RECENTS_SCALE_SECOND_THRESHOLD_FRACTION -> {
|
|
mapToRange(
|
|
dismissFraction,
|
|
RECENTS_SCALE_DISMISS_THRESHOLD_FRACTION,
|
|
RECENTS_SCALE_SECOND_THRESHOLD_FRACTION,
|
|
RECENTS_SCALE_ON_DISMISS_CANCEL,
|
|
RECENTS_SCALE_ON_DISMISS_SUCCESS,
|
|
LINEAR,
|
|
)
|
|
}
|
|
// Keep scale beyond the dismiss threshold scaling consistent.
|
|
else -> {
|
|
RECENTS_SCALE_ON_DISMISS_SUCCESS
|
|
}
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
private const val TAG = "TaskViewDismissTouchController"
|
|
|
|
private const val DISMISS_THRESHOLD_FRACTION = 0.5f
|
|
private const val DISMISS_THRESHOLD_HAPTIC_RANGE = 10f
|
|
|
|
private const val RECENTS_SCALE_ON_DISMISS_CANCEL = 0.9875f
|
|
private const val RECENTS_SCALE_ON_DISMISS_SUCCESS = 0.975f
|
|
private const val RECENTS_SCALE_DEFAULT = 1f
|
|
private const val RECENTS_SCALE_FIRST_THRESHOLD_FRACTION = 0.2f
|
|
private const val RECENTS_SCALE_DISMISS_THRESHOLD_FRACTION = 0.5f
|
|
private const val RECENTS_SCALE_SECOND_THRESHOLD_FRACTION = 0.575f
|
|
}
|
|
}
|