Files
Flexera-Launcher/quickstep/src/com/android/launcher3/taskbar/TaskbarOverflowView.java
T
Artsiom Mitrokhin dcf37ce078 Update taskbar overflow view to match the spec
This includes:
1) updating the color token used in dark mode,
2) adjusting sizes of individual app icons and their strokes.

See screenshots in http://b/383556682#comment7.

Bug: 383556682, 380386440
Flag: com.android.launcher3.taskbar_overflow
Test: manual
Change-Id: Ia05d803c5602552ce4f3e4675411b281107ac843
2025-03-07 10:38:37 -05:00

497 lines
20 KiB
Java

/*
* 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.launcher3.taskbar;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.BlendMode;
import android.graphics.BlendModeColorFilter;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.FloatProperty;
import android.util.IntProperty;
import android.view.LayoutInflater;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import androidx.annotation.NonNull;
import androidx.annotation.VisibleForTesting;
import androidx.core.graphics.ColorUtils;
import com.android.app.animation.Interpolators;
import com.android.launcher3.Reorderable;
import com.android.launcher3.Utilities;
import com.android.launcher3.icons.IconNormalizer;
import com.android.launcher3.util.MultiTranslateDelegate;
import com.android.launcher3.util.Themes;
import com.android.systemui.shared.recents.model.Task;
import java.util.ArrayList;
import java.util.List;
/**
* View used as overflow icon within task bar, when the list of recent/running apps overflows the
* available display bounds - if display is not wide enough to show all running apps in the taskbar,
* this icon is added to the taskbar as an entry point to open UI that surfaces all running apps.
* The icon contains icon representations of up to 4 more recent tasks in overflow, stacked on top
* each other in counter clockwise manner (icons of tasks partially overlapping with each other).
*/
public class TaskbarOverflowView extends FrameLayout implements Reorderable {
private static final int ALPHA_TRANSPARENT = 0;
private static final int ALPHA_OPAQUE = 255;
private static final long ANIMATION_DURATION_APPS_TO_LEAVE_BEHIND = 300L;
private static final long ANIMATION_DURATION_LEAVE_BEHIND_TO_APPS = 500L;
private static final long ANIMATION_SET_DURATION = 1000L;
private static final long ITEM_ICON_CENTER_OFFSET_ANIMATION_DURATION = 500L;
private static final long ITEM_ICON_COLOR_FILTER_OPACITY_ANIMATION_DURATION = 600L;
private static final long ITEM_ICON_SIZE_ANIMATION_DURATION = 500L;
private static final long ITEM_ICON_STROKE_WIDTH_ANIMATION_DURATION = 500L;
private static final long LEAVE_BEHIND_ANIMATIONS_DELAY = 500L;
private static final long LEAVE_BEHIND_OPACITY_ANIMATION_DURATION = 100L;
private static final long LEAVE_BEHIND_SIZE_ANIMATION_DURATION = 500L;
private static final float LEAVE_BEHIND_SIZE_SCALE_DOWN_MULTIPLIER = 0.83f;
private static final int MAX_ITEMS_IN_PREVIEW = 4;
// The height divided by the width of the horizontal box containing two overlapping app icons.
// According to the spec, this ratio is constant for different sizes of taskbar app icons.
// Assuming the width of this box = taskbar app icon size - 2 paddings - 2 stroke widths, and
// the height = width * 0.61, which is also equal to the height of a single item in the preview.
private static final float TWO_ITEM_ICONS_BOX_ASPECT_RATIO = 0.61f;
private static final FloatProperty<TaskbarOverflowView> ITEM_ICON_CENTER_OFFSET =
new FloatProperty<>("itemIconCenterOffset") {
@Override
public Float get(TaskbarOverflowView view) {
return view.mItemIconCenterOffset;
}
@Override
public void setValue(TaskbarOverflowView view, float value) {
view.mItemIconCenterOffset = value;
view.invalidate();
}
};
private static final IntProperty<TaskbarOverflowView> ITEM_ICON_COLOR_FILTER_OPACITY =
new IntProperty<>("itemIconColorFilterOpacity") {
@Override
public Integer get(TaskbarOverflowView view) {
return view.mItemIconColorFilterOpacity;
}
@Override
public void setValue(TaskbarOverflowView view, int value) {
view.mItemIconColorFilterOpacity = value;
view.invalidate();
}
};
private static final FloatProperty<TaskbarOverflowView> ITEM_ICON_SIZE =
new FloatProperty<>("itemIconSize") {
@Override
public Float get(TaskbarOverflowView view) {
return view.mItemIconSize;
}
@Override
public void setValue(TaskbarOverflowView view, float value) {
view.mItemIconSize = value;
view.invalidate();
}
};
private static final FloatProperty<TaskbarOverflowView> ITEM_ICON_STROKE_WIDTH =
new FloatProperty<>("itemIconStrokeWidth") {
@Override
public Float get(TaskbarOverflowView view) {
return view.mItemIconStrokeWidth;
}
@Override
public void setValue(TaskbarOverflowView view, float value) {
view.mItemIconStrokeWidth = value;
view.invalidate();
}
};
private static final IntProperty<TaskbarOverflowView> LEAVE_BEHIND_OPACITY =
new IntProperty<>("leaveBehindOpacity") {
@Override
public Integer get(TaskbarOverflowView view) {
return view.mLeaveBehindOpacity;
}
@Override
public void setValue(TaskbarOverflowView view, int value) {
view.mLeaveBehindOpacity = value;
view.invalidate();
}
};
private static final FloatProperty<TaskbarOverflowView> LEAVE_BEHIND_SIZE =
new FloatProperty<>("leaveBehindSize") {
@Override
public Float get(TaskbarOverflowView view) {
return view.mLeaveBehindSize;
}
@Override
public void setValue(TaskbarOverflowView view, float value) {
view.mLeaveBehindSize = value;
view.invalidate();
}
};
private boolean mIsRtlLayout;
private final List<Task> mItems = new ArrayList<Task>();
private int mIconSize;
private Paint mItemBackgroundPaint;
private final MultiTranslateDelegate mTranslateDelegate = new MultiTranslateDelegate(this);
private float mScaleForReorderBounce = 1f;
private int mItemBackgroundColor;
private int mLeaveBehindColor;
// Active means the overflow icon has been pressed, which replaces the app icons with the
// leave-behind circle and shows the KQS UI.
private boolean mIsActive = false;
private ValueAnimator mStateTransitionAnimationWrapper;
private float mItemIconCenterOffsetDefault;
private float mItemIconCenterOffset; // [0..mItemIconCenterOffsetDefault]
private int mItemIconColorFilterOpacity; // [ALPHA_TRANSPARENT..ALPHA_OPAQUE]
private float mItemIconSizeDefault;
private float mItemIconSizeScaledDown;
private float mItemIconSize; // [mItemIconSizeScaledDown..mItemIconSizeDefault]
private float mItemIconStrokeWidthDefault;
private float mItemIconStrokeWidth; // [0..mItemIconStrokeWidthDefault]
private int mLeaveBehindOpacity; // [ALPHA_TRANSPARENT..ALPHA_OPAQUE]
private float mLeaveBehindSizeScaledDown;
private float mLeaveBehindSizeDefault;
private float mLeaveBehindSize; // [mLeaveBehindSizeScaledDown..mLeaveBehindSizeDefault]
public TaskbarOverflowView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public TaskbarOverflowView(Context context) {
super(context);
init();
}
/**
* Inflates the taskbar overflow button view.
* @param resId The resource to inflate the view from.
* @param group The parent view.
* @param iconSize The size of the overflow button icon.
* @param padding The internal padding of the overflow view.
* @return A taskbar overflow button.
*/
public static TaskbarOverflowView inflateIcon(int resId, ViewGroup group, int iconSize,
int padding) {
LayoutInflater inflater = LayoutInflater.from(group.getContext());
TaskbarOverflowView icon = (TaskbarOverflowView) inflater.inflate(resId, group, false);
icon.mIconSize = iconSize;
final float taskbarIconRadius =
(iconSize - padding * 2f) * IconNormalizer.ICON_VISIBLE_AREA_FACTOR / 2f;
icon.mLeaveBehindSizeDefault = taskbarIconRadius; // 1/2 of taskbar app icon size
icon.mLeaveBehindSizeScaledDown =
icon.mLeaveBehindSizeDefault * LEAVE_BEHIND_SIZE_SCALE_DOWN_MULTIPLIER;
icon.mLeaveBehindSize = icon.mLeaveBehindSizeScaledDown;
icon.mItemIconStrokeWidthDefault =
taskbarIconRadius / 10f; // 1/20 of taskbar app icon size
icon.mItemIconStrokeWidth = icon.mItemIconStrokeWidthDefault;
icon.mItemIconSizeDefault = 2f * taskbarIconRadius * TWO_ITEM_ICONS_BOX_ASPECT_RATIO;
icon.mItemIconSizeScaledDown = icon.mLeaveBehindSizeScaledDown;
icon.mItemIconSize = icon.mItemIconSizeDefault;
icon.mItemIconCenterOffsetDefault = taskbarIconRadius
- icon.mItemIconSizeDefault * IconNormalizer.ICON_VISIBLE_AREA_FACTOR / 2f
- icon.mItemIconStrokeWidthDefault;
icon.mItemIconCenterOffset = icon.mItemIconCenterOffsetDefault;
return icon;
}
private void init() {
mIsRtlLayout = Utilities.isRtl(getResources());
mItemBackgroundPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mItemBackgroundColor = getContext().getColor(
com.android.internal.R.color.materialColorInverseOnSurface);
mLeaveBehindColor = Themes.getAttrColor(getContext(), android.R.attr.textColorTertiary);
setWillNotDraw(false);
}
@Override
protected void onDraw(@NonNull Canvas canvas) {
super.onDraw(canvas);
drawAppIcons(canvas);
drawLeaveBehindCircle(canvas);
}
private void drawAppIcons(@NonNull Canvas canvas) {
mItemBackgroundPaint.setColor(mItemBackgroundColor);
float canvasCenterXY = mIconSize / 2f;
int adjustedItemIconSize = Math.round(mItemIconSize);
float itemIconRadius = adjustedItemIconSize / 2f;
int itemsToShow = Math.min(mItems.size(), MAX_ITEMS_IN_PREVIEW);
for (int i = itemsToShow - 1; i >= 0; --i) {
Drawable icon = mItems.get(mItems.size() - i - 1).icon;
if (icon == null) {
continue;
}
float itemCenterX = getItemXOffset(mItemIconCenterOffset, mIsRtlLayout, i, itemsToShow);
float itemCenterY = getItemYOffset(mItemIconCenterOffset, i, itemsToShow);
Drawable iconCopy = icon.getConstantState().newDrawable().mutate();
iconCopy.setBounds(0, 0, adjustedItemIconSize, adjustedItemIconSize);
iconCopy.setColorFilter(new BlendModeColorFilter(
ColorUtils.setAlphaComponent(mLeaveBehindColor, mItemIconColorFilterOpacity),
BlendMode.SRC_ATOP));
canvas.save();
canvas.translate(
canvasCenterXY + itemCenterX - itemIconRadius,
canvasCenterXY + itemCenterY - itemIconRadius);
canvas.drawCircle(itemIconRadius, itemIconRadius,
itemIconRadius * IconNormalizer.ICON_VISIBLE_AREA_FACTOR + mItemIconStrokeWidth,
mItemBackgroundPaint);
iconCopy.draw(canvas);
canvas.restore();
}
}
private void drawLeaveBehindCircle(@NonNull Canvas canvas) {
mItemBackgroundPaint.setColor(
ColorUtils.setAlphaComponent(mLeaveBehindColor, mLeaveBehindOpacity));
final float xyCenter = mIconSize / 2f;
canvas.drawCircle(xyCenter, xyCenter, mLeaveBehindSize / 2f, mItemBackgroundPaint);
}
/**
* Clears the list of tasks tracked by the view.
*/
public void clearItems() {
mItems.clear();
invalidate();
}
/**
* Update the view to represent a new list of recent tasks.
* @param items Items to be shown in the view.
*/
public void setItems(List<Task> items) {
mItems.clear();
mItems.addAll(items);
invalidate();
}
@VisibleForTesting
public List<Integer> getItemIds() {
return mItems.stream().map(task -> task.key.id).toList();
}
/**
* Called when a task is updated. If the task is contained within the view, it's cached value
* gets updated. If the task is shown within the icon, invalidates the view, so the task icon
* gets updated.
* @param task The updated task.
*/
public void updateTaskIsShown(Task task) {
for (int i = 0; i < mItems.size(); ++i) {
if (mItems.get(i).key.id == task.key.id) {
mItems.set(i, task);
if (i >= mItems.size() - MAX_ITEMS_IN_PREVIEW) {
invalidate();
}
break;
}
}
}
/**
* Returns the view's state (whether it shows a set of app icons or a leave-behind circle).
*/
public boolean getIsActive() {
return mIsActive;
}
/**
* Updates the view's state to draw either a set of app icons or a leave-behind circle.
* @param isActive The next state of the view.
*/
public void setIsActive(boolean isActive) {
if (mIsActive == isActive) {
return;
}
mIsActive = isActive;
if (mStateTransitionAnimationWrapper != null
&& mStateTransitionAnimationWrapper.isRunning()) {
mStateTransitionAnimationWrapper.reverse();
return;
}
final AnimatorSet stateTransitionAnimation = getStateTransitionAnimation();
mStateTransitionAnimationWrapper = ValueAnimator.ofFloat(0, 1f);
mStateTransitionAnimationWrapper.setDuration(mIsActive
? ANIMATION_DURATION_APPS_TO_LEAVE_BEHIND
: ANIMATION_DURATION_LEAVE_BEHIND_TO_APPS);
mStateTransitionAnimationWrapper.setInterpolator(
mIsActive ? Interpolators.STANDARD : Interpolators.EMPHASIZED);
mStateTransitionAnimationWrapper.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mStateTransitionAnimationWrapper = null;
}
});
mStateTransitionAnimationWrapper.addUpdateListener(
new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animator) {
stateTransitionAnimation.setCurrentPlayTime(
(long) (ANIMATION_SET_DURATION * animator.getAnimatedFraction()));
}
});
mStateTransitionAnimationWrapper.start();
}
private AnimatorSet getStateTransitionAnimation() {
final AnimatorSet animation = new AnimatorSet();
animation.setInterpolator(Interpolators.LINEAR);
animation.playTogether(
buildAnimator(ITEM_ICON_CENTER_OFFSET, 0f, mItemIconCenterOffsetDefault,
ITEM_ICON_CENTER_OFFSET_ANIMATION_DURATION, 0L,
ITEM_ICON_CENTER_OFFSET_ANIMATION_DURATION),
buildAnimator(ITEM_ICON_COLOR_FILTER_OPACITY, ALPHA_OPAQUE, ALPHA_TRANSPARENT,
ITEM_ICON_COLOR_FILTER_OPACITY_ANIMATION_DURATION, 0L,
ANIMATION_SET_DURATION - ITEM_ICON_COLOR_FILTER_OPACITY_ANIMATION_DURATION),
buildAnimator(ITEM_ICON_SIZE, mItemIconSizeScaledDown, mItemIconSizeDefault,
ITEM_ICON_SIZE_ANIMATION_DURATION, 0L,
ITEM_ICON_SIZE_ANIMATION_DURATION),
buildAnimator(ITEM_ICON_STROKE_WIDTH, 0f, mItemIconStrokeWidthDefault,
ITEM_ICON_STROKE_WIDTH_ANIMATION_DURATION, 0L,
ITEM_ICON_STROKE_WIDTH_ANIMATION_DURATION),
buildAnimator(LEAVE_BEHIND_OPACITY, ALPHA_OPAQUE, ALPHA_TRANSPARENT,
LEAVE_BEHIND_OPACITY_ANIMATION_DURATION, LEAVE_BEHIND_ANIMATIONS_DELAY,
ANIMATION_SET_DURATION - LEAVE_BEHIND_ANIMATIONS_DELAY
- LEAVE_BEHIND_OPACITY_ANIMATION_DURATION),
buildAnimator(LEAVE_BEHIND_SIZE, mLeaveBehindSizeDefault,
mLeaveBehindSizeScaledDown, LEAVE_BEHIND_SIZE_ANIMATION_DURATION,
LEAVE_BEHIND_ANIMATIONS_DELAY, 0L)
);
return animation;
}
private ObjectAnimator buildAnimator(IntProperty<TaskbarOverflowView> property,
int finalValueWhenAnimatingToLeaveBehind, int finalValueWhenAnimatingToAppIcons,
long duration, long delayWhenAnimatingToLeaveBehind,
long delayWhenAnimatingToAppIcons) {
final ObjectAnimator animator = ObjectAnimator.ofInt(this, property,
mIsActive ? finalValueWhenAnimatingToLeaveBehind
: finalValueWhenAnimatingToAppIcons);
applyTiming(animator, duration, delayWhenAnimatingToLeaveBehind,
delayWhenAnimatingToAppIcons);
return animator;
}
private ObjectAnimator buildAnimator(FloatProperty<TaskbarOverflowView> property,
float finalValueWhenAnimatingToLeaveBehind, float finalValueWhenAnimatingToAppIcons,
long duration, long delayWhenAnimatingToLeaveBehind,
long delayWhenAnimatingToAppIcons) {
final ObjectAnimator animator = ObjectAnimator.ofFloat(this, property,
mIsActive ? finalValueWhenAnimatingToLeaveBehind
: finalValueWhenAnimatingToAppIcons);
applyTiming(animator, duration, delayWhenAnimatingToLeaveBehind,
delayWhenAnimatingToAppIcons);
return animator;
}
private void applyTiming(ObjectAnimator animator, long duration,
long delayWhenAnimatingToLeaveBehind,
long delayWhenAnimatingToAppIcons) {
animator.setDuration(duration);
animator.setStartDelay(
mIsActive ? delayWhenAnimatingToLeaveBehind : delayWhenAnimatingToAppIcons);
}
@Override
public MultiTranslateDelegate getTranslateDelegate() {
return mTranslateDelegate;
}
@Override
public float getReorderBounceScale() {
return mScaleForReorderBounce;
}
@Override
public void setReorderBounceScale(float scale) {
mScaleForReorderBounce = scale;
super.setScaleX(scale);
super.setScaleY(scale);
}
private float getItemXOffset(float baseOffset, boolean isRtl, int itemIndex, int itemCount) {
// Item with index 1 is on the left in all cases.
if (itemIndex == 1) {
return (isRtl ? 1 : -1) * baseOffset;
}
// First item is centered if total number of items shown is 3, on the right otherwise.
if (itemIndex == 0) {
if (itemCount == 3) {
return 0;
}
return (isRtl ? -1 : 1) * baseOffset;
}
// Last item is on the right when there are more than 2 items (case which is already handled
// as `itemIndex == 1`).
if (itemIndex == itemCount - 1) {
return (isRtl ? -1 : 1) * baseOffset;
}
return (isRtl ? 1 : -1) * baseOffset;
}
private float getItemYOffset(float baseOffset, int itemIndex, int itemCount) {
// If icon contains two items, they are both centered vertically.
if (itemCount == 2) {
return 0;
}
// First half of items is on top, later half is on bottom.
return (itemIndex + 1 <= itemCount / 2 ? -1 : 1) * baseOffset;
}
}