Files
Flexera-Launcher/quickstep/src/com/android/quickstep/orientation/LandscapePagedViewHandler.kt
T
samcackett 2244b633cc Add TaskContentView wrapper to TaskThumbnailView
- Keep TaskThumbnailViewDeprecated as-is
- Due to flag guarding and xml changes, added bottomright_snapshot id
- Remove redundant FrameLayout from task_header_view.xml and refactor
the view to handle alignment correctly
- Move feature flag logic to the state mapper
- Extract TaskThumbnailViewHeader logic and any related state out of
TaskThumbnailView and move to TaskContentView
- Use vertical LinearLayoutManager to hold the TaskThumbnailViewHeader
and TaskThumbnailView
- Rename TaskThumbnailViewHeader to TaskHeaderView. Rename xml and state
 similarly

This reverts commit df6dc455a7.
This reverts commit 714370a9bfb2e53738b0cd9958acd6540d8d649c.

Reason for revert: Reland previously reverted CL's with fixes

Fix: 408971730
Fix: 397889146
Fix: 401469907
Fix: 402277471
Fix: 403826044
Flag: com.android.launcher3.enable_refactor_task_thumbnail
Test: TaskUiStateMapperTest & TaskContentViewScreenshotTest & TaskThumbnailViewScreenshotTest & TaskHeaderViewScreenshotTest & SwitchBetweenSplitPairsGesturalNavPortrait
Change-Id: I01758447ad1194ebbeab748113621b42f3384db8
2025-04-09 16:36:51 +01:00

736 lines
28 KiB
Kotlin

/*
* Copyright (C) 2024 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.orientation
import android.annotation.SuppressLint
import android.content.res.Resources
import android.graphics.Point
import android.graphics.PointF
import android.graphics.Rect
import android.graphics.RectF
import android.graphics.drawable.ShapeDrawable
import android.util.FloatProperty
import android.util.Pair
import android.view.Gravity
import android.view.MotionEvent
import android.view.Surface
import android.view.VelocityTracker
import android.view.View
import android.view.View.MeasureSpec
import android.view.ViewGroup
import android.view.accessibility.AccessibilityEvent
import android.widget.FrameLayout
import android.widget.LinearLayout
import androidx.annotation.VisibleForTesting
import androidx.core.util.component1
import androidx.core.util.component2
import androidx.core.view.updateLayoutParams
import com.android.launcher3.DeviceProfile
import com.android.launcher3.LauncherAnimUtils
import com.android.launcher3.R
import com.android.launcher3.Utilities
import com.android.launcher3.logger.LauncherAtom.TaskSwitcherContainer
import com.android.launcher3.touch.PagedOrientationHandler.ChildBounds
import com.android.launcher3.touch.PagedOrientationHandler.Float2DAction
import com.android.launcher3.touch.PagedOrientationHandler.Int2DAction
import com.android.launcher3.touch.SingleAxisSwipeDetector
import com.android.launcher3.util.OverviewReleaseFlags.enableOverviewIconMenu
import com.android.launcher3.util.SplitConfigurationOptions.STAGE_POSITION_BOTTOM_OR_RIGHT
import com.android.launcher3.util.SplitConfigurationOptions.STAGE_POSITION_TOP_OR_LEFT
import com.android.launcher3.util.SplitConfigurationOptions.STAGE_POSITION_UNDEFINED
import com.android.launcher3.util.SplitConfigurationOptions.STAGE_TYPE_MAIN
import com.android.launcher3.util.SplitConfigurationOptions.SplitBounds
import com.android.launcher3.util.SplitConfigurationOptions.SplitPositionOption
import com.android.launcher3.util.SplitConfigurationOptions.StagePosition
import com.android.launcher3.views.BaseDragLayer
import com.android.quickstep.views.IconAppChipView
import kotlin.math.max
open class LandscapePagedViewHandler : RecentsPagedOrientationHandler {
override fun <T> getPrimaryValue(x: T, y: T): T = y
override fun <T> getSecondaryValue(x: T, y: T): T = x
override fun getPrimaryValue(x: Int, y: Int): Int = y
override fun getSecondaryValue(x: Int, y: Int): Int = x
override fun getPrimaryValue(x: Float, y: Float): Float = y
override fun getSecondaryValue(x: Float, y: Float): Float = x
override val isLayoutNaturalToLauncher: Boolean = false
override fun adjustFloatingIconStartVelocity(velocity: PointF) {
val oldX = velocity.x
val oldY = velocity.y
velocity.set(-oldY, oldX)
}
override fun fixBoundsForHomeAnimStartRect(outStartRect: RectF, deviceProfile: DeviceProfile) {
// We don't need to check the "top" value here because the startRect is in the orientation
// of the app, not of the fixed portrait launcher.
if (outStartRect.left > deviceProfile.heightPx) {
outStartRect.offsetTo(0f, outStartRect.top)
} else if (outStartRect.left < -deviceProfile.heightPx) {
outStartRect.offsetTo(0f, outStartRect.top)
}
}
override fun <T> setPrimary(target: T, action: Int2DAction<T>, param: Int) =
action.call(target, 0, param)
override fun <T> setPrimary(target: T, action: Float2DAction<T>, param: Float) =
action.call(target, 0f, param)
override fun <T> setSecondary(target: T, action: Float2DAction<T>, param: Float) =
action.call(target, param, 0f)
override fun <T> set(
target: T,
action: Int2DAction<T>,
primaryParam: Int,
secondaryParam: Int,
) = action.call(target, secondaryParam, primaryParam)
override fun getPrimaryDirection(event: MotionEvent, pointerIndex: Int): Float =
event.getY(pointerIndex)
override fun getPrimaryVelocity(velocityTracker: VelocityTracker, pointerId: Int): Float =
velocityTracker.getYVelocity(pointerId)
override fun getMeasuredSize(view: View): Int = view.measuredHeight
override fun getPrimarySize(view: View): Int = view.height
override fun getPrimarySize(rect: RectF): Float = rect.height()
override fun getSecondarySize(rect: RectF): Float = rect.width()
override fun getStart(rect: RectF): Float = rect.top
override fun getEnd(rect: RectF): Float = rect.bottom
override fun rotateInsets(insets: Rect, outInsets: Rect) {
outInsets.set(insets.bottom, insets.left, insets.top, insets.right)
}
override fun getClearAllSidePadding(view: View, isRtl: Boolean): Int =
if (isRtl) view.paddingBottom / 2 else -view.paddingTop / 2
override fun getSecondaryDimension(view: View): Int = view.width
override val primaryViewTranslate: FloatProperty<View> = LauncherAnimUtils.VIEW_TRANSLATE_Y
override val secondaryViewTranslate: FloatProperty<View> = LauncherAnimUtils.VIEW_TRANSLATE_X
override fun getPrimaryScroll(view: View): Int = view.scrollY
override fun getPrimaryScale(view: View): Float = view.scaleY
override fun setMaxScroll(event: AccessibilityEvent, maxScroll: Int) {
event.maxScrollY = maxScroll
}
override fun getRecentsRtlSetting(resources: Resources): Boolean = !Utilities.isRtl(resources)
override val degreesRotated: Float = 90f
override val rotation: Int = Surface.ROTATION_90
override fun setPrimaryScale(view: View, scale: Float) {
view.scaleY = scale
}
override fun setSecondaryScale(view: View, scale: Float) {
view.scaleX = scale
}
override fun getChildStart(view: View): Int = view.top
override fun getCenterForPage(view: View, insets: Rect): Int =
(view.paddingLeft + view.measuredWidth + insets.left - insets.right - view.paddingRight) / 2
override fun getScrollOffsetStart(view: View, insets: Rect): Int = insets.top + view.paddingTop
override fun getScrollOffsetEnd(view: View, insets: Rect): Int =
view.height - view.paddingBottom - insets.bottom
override val secondaryTranslationDirectionFactor: Int = 1
override fun getSplitTranslationDirectionFactor(
stagePosition: Int,
deviceProfile: DeviceProfile,
): Int = if (stagePosition == STAGE_POSITION_BOTTOM_OR_RIGHT) -1 else 1
override fun getTaskMenuX(
x: Float,
thumbnailView: View,
deviceProfile: DeviceProfile,
taskInsetMargin: Float,
taskViewIcon: View,
): Float = thumbnailView.measuredWidth + x - taskInsetMargin
override fun getTaskMenuY(
y: Float,
thumbnailView: View,
stagePosition: Int,
taskMenuView: View,
taskInsetMargin: Float,
taskViewIcon: View,
): Float {
val layoutParams = taskMenuView.layoutParams as BaseDragLayer.LayoutParams
var taskMenuY = y + taskInsetMargin
if (stagePosition == STAGE_POSITION_UNDEFINED) {
taskMenuY += (thumbnailView.measuredHeight - layoutParams.width) / 2f
}
return taskMenuY
}
override fun getTaskMenuWidth(
thumbnailView: View,
deviceProfile: DeviceProfile,
@StagePosition stagePosition: Int,
): Int =
when {
enableOverviewIconMenu() ->
thumbnailView.resources.getDimensionPixelSize(
R.dimen.task_thumbnail_icon_menu_expanded_width
)
stagePosition == STAGE_POSITION_UNDEFINED -> thumbnailView.measuredWidth
else -> thumbnailView.measuredHeight
}
override fun getTaskMenuHeight(
taskInsetMargin: Float,
deviceProfile: DeviceProfile,
taskMenuX: Float,
taskMenuY: Float,
): Int = (taskMenuX - taskInsetMargin).toInt()
override fun setTaskOptionsMenuLayoutOrientation(
deviceProfile: DeviceProfile,
taskMenuLayout: LinearLayout,
dividerSpacing: Int,
dividerDrawable: ShapeDrawable,
) {
taskMenuLayout.orientation = LinearLayout.VERTICAL
dividerDrawable.intrinsicHeight = dividerSpacing
taskMenuLayout.dividerDrawable = dividerDrawable
}
override fun setLayoutParamsForTaskMenuOptionItem(
lp: LinearLayout.LayoutParams,
viewGroup: LinearLayout,
deviceProfile: DeviceProfile,
) {
// Phone fake landscape
viewGroup.orientation = LinearLayout.HORIZONTAL
lp.width = ViewGroup.LayoutParams.MATCH_PARENT
lp.height = ViewGroup.LayoutParams.WRAP_CONTENT
}
override fun updateDwbBannerLayout(
taskViewWidth: Int,
taskViewHeight: Int,
isGroupedTaskView: Boolean,
deviceProfile: DeviceProfile,
snapshotViewWidth: Int,
snapshotViewHeight: Int,
banner: View,
) {
banner.pivotX = 0f
banner.pivotY = 0f
banner.rotation = degreesRotated
banner.updateLayoutParams<FrameLayout.LayoutParams> {
gravity = Gravity.TOP or if (banner.isLayoutRtl) Gravity.END else Gravity.START
width =
if (isGroupedTaskView) {
snapshotViewHeight
} else {
taskViewHeight - deviceProfile.overviewTaskThumbnailTopMarginPx
}
}
}
override fun getDwbBannerTranslations(
taskViewWidth: Int,
taskViewHeight: Int,
splitBounds: SplitBounds?,
deviceProfile: DeviceProfile,
thumbnailViews: Array<View>,
desiredTaskId: Int,
banner: View,
): Pair<Float, Float> {
val snapshotParams = thumbnailViews[0].layoutParams as ViewGroup.MarginLayoutParams
val translationX = banner.height.toFloat()
val translationY: Float
if (splitBounds == null) {
translationY = snapshotParams.topMargin.toFloat()
} else {
if (desiredTaskId == splitBounds.leftTopTaskId) {
translationY = snapshotParams.topMargin.toFloat()
} else {
val topLeftTaskPlusDividerPercent =
splitBounds.leftTopTaskPercent + splitBounds.dividerPercent
translationY =
snapshotParams.topMargin +
(taskViewHeight - snapshotParams.topMargin) * topLeftTaskPlusDividerPercent
}
}
return Pair(translationX, translationY)
}
/* ---------- The following are only used by TaskViewTouchHandler. ---------- */
override val upDownSwipeDirection: SingleAxisSwipeDetector.Direction =
SingleAxisSwipeDetector.HORIZONTAL
override fun getUpDirection(isRtl: Boolean): Int =
if (isRtl) SingleAxisSwipeDetector.DIRECTION_NEGATIVE
else SingleAxisSwipeDetector.DIRECTION_POSITIVE
override fun getDownDirection(isRtl: Boolean): Int =
if (isRtl) SingleAxisSwipeDetector.DIRECTION_POSITIVE
else SingleAxisSwipeDetector.DIRECTION_NEGATIVE
override fun isGoingUp(displacement: Float, isRtl: Boolean): Boolean =
if (isRtl) displacement < 0 else displacement > 0
override fun getTaskDragDisplacementFactor(isRtl: Boolean): Int = if (isRtl) 1 else -1
override fun getTaskDismissVerticalDirection(): Int = 1
override fun getTaskDismissLength(secondaryDimension: Int, taskThumbnailBounds: Rect): Int =
secondaryDimension - taskThumbnailBounds.left
override fun getTaskLaunchLength(secondaryDimension: Int, taskThumbnailBounds: Rect): Int =
taskThumbnailBounds.left
/* -------------------- */
override fun getChildBounds(
child: View,
childStart: Int,
pageCenter: Int,
layoutChild: Boolean,
): ChildBounds {
val childHeight = child.measuredHeight
val childWidth = child.measuredWidth
val childBottom = childStart + childHeight
val childLeft = pageCenter - childWidth / 2
if (layoutChild) {
child.layout(childLeft, childStart, childLeft + childWidth, childBottom)
}
return ChildBounds(childHeight, childWidth, childBottom, childLeft)
}
override fun getDistanceToBottomOfRect(dp: DeviceProfile, rect: Rect): Int = rect.left
override fun getSplitPositionOptions(dp: DeviceProfile): List<SplitPositionOption> =
// Add "left" side of phone which is actually the top
listOf(
SplitPositionOption(
R.drawable.ic_split_horizontal,
R.string.recent_task_option_split_screen,
STAGE_POSITION_TOP_OR_LEFT,
STAGE_TYPE_MAIN,
)
)
override fun getInitialSplitPlaceholderBounds(
placeholderHeight: Int,
placeholderInset: Int,
dp: DeviceProfile,
@StagePosition stagePosition: Int,
out: Rect,
) {
// In fake land/seascape, the placeholder always needs to go to the "top" of the device,
// which is the same bounds as 0 rotation.
val width = dp.widthPx
val insetSizeAdjustment = getPlaceholderSizeAdjustment(dp)
out.set(0, 0, width, placeholderHeight + insetSizeAdjustment)
out.inset(placeholderInset, 0)
// Adjust the top to account for content off screen. This will help to animate the view in
// with rounded corners.
val screenWidth = dp.widthPx
val screenHeight = dp.heightPx
val totalHeight =
(1.0f * screenHeight / 2 * (screenWidth - 2 * placeholderInset) / screenWidth).toInt()
out.top -= totalHeight - placeholderHeight
}
override fun updateSplitIconParams(
out: View,
onScreenRectCenterX: Float,
onScreenRectCenterY: Float,
fullscreenScaleX: Float,
fullscreenScaleY: Float,
drawableWidth: Int,
drawableHeight: Int,
dp: DeviceProfile,
@StagePosition stagePosition: Int,
) {
val insetAdjustment = getPlaceholderSizeAdjustment(dp) / 2f
out.x = (onScreenRectCenterX / fullscreenScaleX - 1.0f * drawableWidth / 2)
out.y =
((onScreenRectCenterY + insetAdjustment) / fullscreenScaleY - 1.0f * drawableHeight / 2)
}
/**
* The split placeholder comes with a default inset to buffer the icon from the top of the
* screen. But if the device already has a large inset (from cutouts etc), use that instead.
*/
private fun getPlaceholderSizeAdjustment(dp: DeviceProfile?): Int =
max((dp!!.insets.top - dp.splitPlaceholderInset).toDouble(), 0.0).toInt()
override fun setSplitInstructionsParams(
out: View,
dp: DeviceProfile,
splitInstructionsHeight: Int,
splitInstructionsWidth: Int,
) {
out.pivotX = 0f
out.pivotY = splitInstructionsHeight.toFloat()
out.rotation = degreesRotated
val distanceToEdge =
out.resources.getDimensionPixelSize(
R.dimen.split_instructions_bottom_margin_phone_landscape
)
// Adjust for any insets on the left edge
val insetCorrectionX = dp.insets.left
// Center the view in case of unbalanced insets on top or bottom of screen
val insetCorrectionY = (dp.insets.bottom - dp.insets.top) / 2
out.translationX = (distanceToEdge - insetCorrectionX).toFloat()
out.translationY =
(-splitInstructionsHeight - splitInstructionsWidth) / 2f + insetCorrectionY
// Setting gravity to LEFT instead of the lint-recommended START because we always want this
// view to be screen-left when phone is in landscape, regardless of the RtL setting.
val lp = out.layoutParams as FrameLayout.LayoutParams
lp.gravity = Gravity.LEFT or Gravity.CENTER_VERTICAL
out.layoutParams = lp
}
override fun getFinalSplitPlaceholderBounds(
splitDividerSize: Int,
dp: DeviceProfile,
@StagePosition stagePosition: Int,
out1: Rect,
out2: Rect,
) {
// In fake land/seascape, the window bounds are always top and bottom half
val screenHeight = dp.heightPx
val screenWidth = dp.widthPx
out1.set(0, 0, screenWidth, screenHeight / 2 - splitDividerSize)
out2.set(0, screenHeight / 2 + splitDividerSize, screenWidth, screenHeight)
}
override fun setSplitTaskSwipeRect(
dp: DeviceProfile,
outRect: Rect,
splitInfo: SplitBounds,
desiredStagePosition: Int,
) {
val topLeftTaskPercent = splitInfo.leftTopTaskPercent
val dividerBarPercent = splitInfo.dividerPercent
if (desiredStagePosition == STAGE_POSITION_TOP_OR_LEFT) {
outRect.bottom = outRect.top + (outRect.height() * topLeftTaskPercent).toInt()
} else {
outRect.top += (outRect.height() * (topLeftTaskPercent + dividerBarPercent)).toInt()
}
}
/**
* @param inSplitSelection Whether user currently has a task from this task group staged for
* split screen. Currently this state is not reachable in fake landscape.
*/
override fun measureGroupedTaskViewThumbnailBounds(
primarySnapshot: View,
secondarySnapshot: View,
parentWidth: Int,
parentHeight: Int,
splitBoundsConfig: SplitBounds,
dp: DeviceProfile,
isRtl: Boolean,
inSplitSelection: Boolean,
) {
val primaryParams = primarySnapshot.layoutParams as FrameLayout.LayoutParams
val secondaryParams = secondarySnapshot.layoutParams as FrameLayout.LayoutParams
// Swap the margins that are set in TaskView#setRecentsOrientedState()
secondaryParams.topMargin = dp.overviewTaskThumbnailTopMarginPx
primaryParams.topMargin = 0
// Measure and layout the thumbnails bottom up, since the primary is on the visual left
// (portrait bottom) and secondary is on the right (portrait top)
val spaceAboveSnapshot = dp.overviewTaskThumbnailTopMarginPx
val totalThumbnailHeight = parentHeight - spaceAboveSnapshot
val dividerBar = getDividerBarSize(totalThumbnailHeight, splitBoundsConfig)
val (taskViewFirst, taskViewSecond) =
getGroupedTaskViewSizes(dp, splitBoundsConfig, parentWidth, parentHeight)
primarySnapshot.translationY = spaceAboveSnapshot.toFloat()
primarySnapshot.measure(
MeasureSpec.makeMeasureSpec(taskViewFirst.x, MeasureSpec.EXACTLY),
MeasureSpec.makeMeasureSpec(taskViewFirst.y, MeasureSpec.EXACTLY),
)
val translationY = taskViewFirst.y + spaceAboveSnapshot + dividerBar
secondarySnapshot.translationY = (translationY - spaceAboveSnapshot).toFloat()
secondarySnapshot.measure(
MeasureSpec.makeMeasureSpec(taskViewSecond.x, MeasureSpec.EXACTLY),
MeasureSpec.makeMeasureSpec(taskViewSecond.y, MeasureSpec.EXACTLY),
)
}
override fun getGroupedTaskViewSizes(
dp: DeviceProfile,
splitBoundsConfig: SplitBounds,
parentWidth: Int,
parentHeight: Int,
): Pair<Point, Point> {
val spaceAboveSnapshot = dp.overviewTaskThumbnailTopMarginPx
val totalThumbnailHeight = parentHeight - spaceAboveSnapshot
val dividerBar = getDividerBarSize(totalThumbnailHeight, splitBoundsConfig)
val taskPercent = splitBoundsConfig.leftTopTaskPercent
val firstTaskViewSize = Point(parentWidth, (totalThumbnailHeight * taskPercent).toInt())
val secondTaskViewSize =
Point(parentWidth, totalThumbnailHeight - firstTaskViewSize.y - dividerBar)
return Pair(firstTaskViewSize, secondTaskViewSize)
}
override fun setTaskIconParams(
iconParams: FrameLayout.LayoutParams,
taskIconMargin: Int,
taskIconHeight: Int,
thumbnailTopMargin: Int,
isRtl: Boolean,
) {
iconParams.gravity =
if (isRtl) {
Gravity.START or Gravity.CENTER_VERTICAL
} else {
Gravity.END or Gravity.CENTER_VERTICAL
}
iconParams.rightMargin = -taskIconHeight - taskIconMargin / 2
iconParams.leftMargin = 0
iconParams.topMargin = thumbnailTopMargin / 2
iconParams.bottomMargin = 0
}
override fun setIconAppChipChildrenParams(
iconParams: FrameLayout.LayoutParams,
chipChildMarginStart: Int,
) {
iconParams.gravity = Gravity.START or Gravity.CENTER_VERTICAL
iconParams.marginStart = chipChildMarginStart
iconParams.topMargin = 0
}
override fun setIconAppChipMenuParams(
iconAppChipView: IconAppChipView,
iconMenuParams: FrameLayout.LayoutParams,
iconMenuMargin: Int,
thumbnailTopMargin: Int,
) {
val isRtl = iconAppChipView.layoutDirection == View.LAYOUT_DIRECTION_RTL
if (isRtl) {
iconMenuParams.gravity = Gravity.START or Gravity.BOTTOM
iconMenuParams.marginStart = iconMenuMargin
iconMenuParams.bottomMargin = iconMenuMargin
iconAppChipView.pivotX = iconMenuParams.width - iconMenuParams.height / 2f
iconAppChipView.pivotY = iconMenuParams.height / 2f
} else {
iconMenuParams.gravity = Gravity.END or Gravity.TOP
iconMenuParams.marginStart = 0
iconMenuParams.bottomMargin = 0
iconAppChipView.pivotX = iconMenuParams.width / 2f
iconAppChipView.pivotY = iconMenuParams.width / 2f
}
iconMenuParams.topMargin = iconMenuMargin
iconMenuParams.marginEnd = iconMenuMargin
iconAppChipView.setSplitTranslationY(0f)
iconAppChipView.setRotation(degreesRotated)
}
/**
* @param inSplitSelection Whether user currently has a task from this task group staged for
* split screen. Currently this state is not reachable in fake landscape.
*/
override fun setSplitIconParams(
primaryIconView: View,
secondaryIconView: View,
taskIconHeight: Int,
primarySnapshotWidth: Int,
primarySnapshotHeight: Int,
groupedTaskViewHeight: Int,
groupedTaskViewWidth: Int,
isRtl: Boolean,
deviceProfile: DeviceProfile,
splitConfig: SplitBounds,
inSplitSelection: Boolean,
oneIconHiddenDueToSmallWidth: Boolean,
) {
val spaceAboveSnapshot = deviceProfile.overviewTaskThumbnailTopMarginPx
val totalThumbnailHeight = groupedTaskViewHeight - spaceAboveSnapshot
val dividerBar: Int = getDividerBarSize(totalThumbnailHeight, splitConfig)
val (topLeftY, bottomRightY) =
getSplitIconsPosition(
taskIconHeight,
primarySnapshotHeight,
totalThumbnailHeight,
isRtl,
deviceProfile.overviewTaskMarginPx,
dividerBar,
oneIconHiddenDueToSmallWidth,
)
updateSplitIconsPosition(primaryIconView, topLeftY, isRtl)
updateSplitIconsPosition(secondaryIconView, bottomRightY, isRtl)
}
override fun getDefaultSplitPosition(deviceProfile: DeviceProfile): Int {
throw IllegalStateException("Default position not available in fake landscape")
}
override fun <T> getSplitSelectTaskOffset(
primary: FloatProperty<T>,
secondary: FloatProperty<T>,
deviceProfile: DeviceProfile,
): Pair<FloatProperty<T>, FloatProperty<T>> = Pair(primary, secondary)
override fun getFloatingTaskOffscreenTranslationTarget(
floatingTask: View,
onScreenRect: RectF,
@StagePosition stagePosition: Int,
dp: DeviceProfile,
): Float = floatingTask.translationY - onScreenRect.height()
override fun setFloatingTaskPrimaryTranslation(
floatingTask: View,
translation: Float,
dp: DeviceProfile,
) {
floatingTask.translationY = translation
}
override fun getFloatingTaskPrimaryTranslation(floatingTask: View, dp: DeviceProfile): Float =
floatingTask.translationY
override fun getHandlerTypeForLogging(): TaskSwitcherContainer.OrientationHandler =
TaskSwitcherContainer.OrientationHandler.LANDSCAPE
/**
* Retrieves split icons position
*
* @param taskIconHeight The height of the task icon.
* @param primarySnapshotHeight The height for the primary snapshot (i.e., top-left snapshot).
* @param totalThumbnailHeight The total height for the group task view.
* @param isRtl Whether the layout direction is RTL (or false for LTR).
* @param overviewTaskMarginPx The space under the focused task icon provided by Device Profile.
* @param dividerSize The size of the divider for the group task view.
* @return The top-left and right-bottom positions for the icon views.
*/
@VisibleForTesting
open fun getSplitIconsPosition(
taskIconHeight: Int,
primarySnapshotHeight: Int,
totalThumbnailHeight: Int,
isRtl: Boolean,
overviewTaskMarginPx: Int,
dividerSize: Int,
oneIconHiddenDueToSmallWidth: Boolean,
): SplitIconPositions {
return if (enableOverviewIconMenu()) {
if (isRtl) {
SplitIconPositions(-(totalThumbnailHeight - primarySnapshotHeight), 0)
} else {
SplitIconPositions(0, primarySnapshotHeight + dividerSize)
}
} else {
if (oneIconHiddenDueToSmallWidth) {
// Center both icons
val centerY =
primarySnapshotHeight +
overviewTaskMarginPx +
((taskIconHeight + dividerSize) / 2)
SplitIconPositions(topLeftY = centerY, bottomRightY = centerY)
} else {
val topLeftY = primarySnapshotHeight + overviewTaskMarginPx
SplitIconPositions(
topLeftY = topLeftY,
bottomRightY = topLeftY + dividerSize + taskIconHeight,
)
}
}
}
/**
* Updates icon view gravity and translation for split tasks
*
* @param iconView View to be updated
* @param translationY the translationY that should be applied
* @param isRtl Whether the layout direction is RTL (or false for LTR).
*/
@SuppressLint("RtlHardcoded")
@VisibleForTesting
open fun updateSplitIconsPosition(iconView: View, translationY: Int, isRtl: Boolean) {
val layoutParams = iconView.layoutParams as FrameLayout.LayoutParams
if (enableOverviewIconMenu()) {
val appChipView = iconView as IconAppChipView
layoutParams.gravity =
if (isRtl) Gravity.BOTTOM or Gravity.START else Gravity.TOP or Gravity.END
appChipView.layoutParams = layoutParams
appChipView.setSplitTranslationX(0f)
appChipView.setSplitTranslationY(translationY.toFloat())
} else {
layoutParams.gravity = Gravity.TOP or Gravity.RIGHT
layoutParams.topMargin = translationY
iconView.translationX = 0f
iconView.translationY = 0f
iconView.layoutParams = layoutParams
}
}
/**
* It calculates the divider's size in the group task view.
*
* @param totalThumbnailHeight The total height for the group task view
* @param splitConfig Contains information about sizes and proportions for split task.
* @return The divider size for the group task view.
*/
protected fun getDividerBarSize(totalThumbnailHeight: Int, splitConfig: SplitBounds): Int {
return Math.round(totalThumbnailHeight * splitConfig.dividerPercent)
}
/**
* Data structure to keep the y position to be used for the split task icon views translation.
*
* @param topLeftY The y-axis position for the task view position on the Top or Left side.
* @param bottomRightY The y-axis position for the task view position on the Bottom or Right
* side.
*/
data class SplitIconPositions(val topLeftY: Int, val bottomRightY: Int)
}