The stash handle now animates out before the new bubble animates in, and animates back in after the new bubble is hidden. There's still some additional polish needed :) Demo: http://recall/-/bJtug1HhvXkkeA4MQvIaiP/z30Ob1rcDUkNEphLAQsgV Flag: ACONFIG com.android.wm.shell.enable_bubble_bar DEVELOPMENT Bug: 280605846 Test: atest BubbleBarViewAnimatorTest Change-Id: I03449286b01ec96de9834e24a707652ddbe49fb0
327 lines
13 KiB
Java
327 lines
13 KiB
Java
/*
|
|
* 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.launcher3.taskbar.bubbles;
|
|
|
|
import static android.view.View.INVISIBLE;
|
|
import static android.view.View.VISIBLE;
|
|
|
|
import android.animation.Animator;
|
|
import android.animation.AnimatorListenerAdapter;
|
|
import android.animation.ValueAnimator;
|
|
import android.content.res.Resources;
|
|
import android.graphics.Outline;
|
|
import android.graphics.Rect;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewOutlineProvider;
|
|
|
|
import com.android.launcher3.R;
|
|
import com.android.launcher3.anim.AnimatedFloat;
|
|
import com.android.launcher3.anim.RevealOutlineAnimation;
|
|
import com.android.launcher3.anim.RoundedRectRevealOutlineProvider;
|
|
import com.android.launcher3.taskbar.StashedHandleView;
|
|
import com.android.launcher3.taskbar.TaskbarActivityContext;
|
|
import com.android.launcher3.taskbar.TaskbarControllers;
|
|
import com.android.launcher3.util.Executors;
|
|
import com.android.launcher3.util.MultiPropertyFactory;
|
|
import com.android.launcher3.util.MultiValueAlpha;
|
|
import com.android.systemui.shared.navigationbar.RegionSamplingHelper;
|
|
import com.android.wm.shell.common.bubbles.BubbleBarLocation;
|
|
|
|
/**
|
|
* Handles properties/data collection, then passes the results to our stashed handle View to render.
|
|
*/
|
|
public class BubbleStashedHandleViewController {
|
|
|
|
private final TaskbarActivityContext mActivity;
|
|
private final StashedHandleView mStashedHandleView;
|
|
private final MultiValueAlpha mStashedHandleAlpha;
|
|
|
|
// Initialized in init.
|
|
private BubbleBarViewController mBarViewController;
|
|
private BubbleStashController mBubbleStashController;
|
|
private RegionSamplingHelper mRegionSamplingHelper;
|
|
private int mBarSize;
|
|
private int mStashedTaskbarHeight;
|
|
private int mStashedHandleWidth;
|
|
private int mStashedHandleHeight;
|
|
|
|
private final AnimatedFloat mStashedHandleTranslationY =
|
|
new AnimatedFloat(this::updateTranslationY);
|
|
|
|
// Modified when swipe up is happening on the stashed handle or task bar.
|
|
private float mSwipeUpTranslationY;
|
|
|
|
// The bounds we want to clip to in the settled state when showing the stashed handle.
|
|
private final Rect mStashedHandleBounds = new Rect();
|
|
|
|
// When the reveal animation is cancelled, we can assume it's about to create a new animation,
|
|
// which should start off at the same point the cancelled one left off.
|
|
private float mStartProgressForNextRevealAnim;
|
|
private boolean mWasLastRevealAnimReversed;
|
|
|
|
// XXX: if there are more of these maybe do state flags instead
|
|
private boolean mHiddenForSysui;
|
|
private boolean mHiddenForNoBubbles;
|
|
private boolean mHiddenForHomeButtonDisabled;
|
|
|
|
public BubbleStashedHandleViewController(TaskbarActivityContext activity,
|
|
StashedHandleView stashedHandleView) {
|
|
mActivity = activity;
|
|
mStashedHandleView = stashedHandleView;
|
|
mStashedHandleAlpha = new MultiValueAlpha(mStashedHandleView, 1);
|
|
}
|
|
|
|
public void init(TaskbarControllers controllers, BubbleControllers bubbleControllers) {
|
|
mBarViewController = bubbleControllers.bubbleBarViewController;
|
|
mBubbleStashController = bubbleControllers.bubbleStashController;
|
|
|
|
Resources resources = mActivity.getResources();
|
|
mStashedHandleHeight = resources.getDimensionPixelSize(
|
|
R.dimen.bubblebar_stashed_handle_height);
|
|
mStashedHandleWidth = resources.getDimensionPixelSize(
|
|
R.dimen.bubblebar_stashed_handle_width);
|
|
mBarSize = resources.getDimensionPixelSize(R.dimen.bubblebar_size);
|
|
|
|
final int bottomMargin = resources.getDimensionPixelSize(
|
|
R.dimen.transient_taskbar_bottom_margin);
|
|
mStashedHandleView.getLayoutParams().height = mBarSize + bottomMargin;
|
|
|
|
mStashedHandleAlpha.get(0).setValue(0);
|
|
|
|
mStashedTaskbarHeight = resources.getDimensionPixelSize(
|
|
R.dimen.bubblebar_stashed_size);
|
|
mStashedHandleView.setOutlineProvider(new ViewOutlineProvider() {
|
|
@Override
|
|
public void getOutline(View view, Outline outline) {
|
|
float stashedHandleRadius = view.getHeight() / 2f;
|
|
outline.setRoundRect(mStashedHandleBounds, stashedHandleRadius);
|
|
}
|
|
});
|
|
|
|
mRegionSamplingHelper = new RegionSamplingHelper(mStashedHandleView,
|
|
new RegionSamplingHelper.SamplingCallback() {
|
|
@Override
|
|
public void onRegionDarknessChanged(boolean isRegionDark) {
|
|
mStashedHandleView.updateHandleColor(isRegionDark, true /* animate */);
|
|
}
|
|
|
|
@Override
|
|
public Rect getSampledRegion(View sampledView) {
|
|
return mStashedHandleView.getSampledRegion();
|
|
}
|
|
}, Executors.UI_HELPER_EXECUTOR);
|
|
|
|
mStashedHandleView.addOnLayoutChangeListener((view, i, i1, i2, i3, i4, i5, i6, i7) ->
|
|
updateBounds(mBarViewController.getBubbleBarLocation()));
|
|
}
|
|
|
|
private void updateBounds(BubbleBarLocation bubbleBarLocation) {
|
|
// As more bubbles get added, the icon bounds become larger. To ensure a consistent
|
|
// handle bar position, we pin it to the edge of the screen.
|
|
final int stashedCenterY = mStashedHandleView.getHeight() - mStashedTaskbarHeight / 2;
|
|
if (bubbleBarLocation.isOnLeft(mStashedHandleView.isLayoutRtl())) {
|
|
final int left = mBarViewController.getHorizontalMargin();
|
|
mStashedHandleBounds.set(
|
|
left,
|
|
stashedCenterY - mStashedHandleHeight / 2,
|
|
left + mStashedHandleWidth,
|
|
stashedCenterY + mStashedHandleHeight / 2);
|
|
mStashedHandleView.setPivotX(0);
|
|
} else {
|
|
final int right =
|
|
mActivity.getDeviceProfile().widthPx - mBarViewController.getHorizontalMargin();
|
|
mStashedHandleBounds.set(
|
|
right - mStashedHandleWidth,
|
|
stashedCenterY - mStashedHandleHeight / 2,
|
|
right,
|
|
stashedCenterY + mStashedHandleHeight / 2);
|
|
mStashedHandleView.setPivotX(mStashedHandleView.getWidth());
|
|
}
|
|
|
|
mStashedHandleView.updateSampledRegion(mStashedHandleBounds);
|
|
mStashedHandleView.setPivotY(mStashedHandleView.getHeight() - mStashedTaskbarHeight / 2f);
|
|
}
|
|
|
|
public void onDestroy() {
|
|
mRegionSamplingHelper.stopAndDestroy();
|
|
mRegionSamplingHelper = null;
|
|
}
|
|
|
|
/**
|
|
* Returns the height of the stashed handle.
|
|
*/
|
|
public int getStashedHeight() {
|
|
return mStashedHandleHeight;
|
|
}
|
|
|
|
/**
|
|
* Returns the height when the bubble bar is unstashed (so the height of the bubble bar).
|
|
*/
|
|
public int getUnstashedHeight() {
|
|
return mBarSize;
|
|
}
|
|
|
|
/**
|
|
* Called when system ui state changes. Bubbles don't show when the device is locked.
|
|
*/
|
|
public void setHiddenForSysui(boolean hidden) {
|
|
if (mHiddenForSysui != hidden) {
|
|
mHiddenForSysui = hidden;
|
|
updateVisibilityForStateChange();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when the handle should be hidden (or shown) because there are no bubbles
|
|
* (or 1+ bubbles).
|
|
*/
|
|
public void setHiddenForBubbles(boolean hidden) {
|
|
if (mHiddenForNoBubbles != hidden) {
|
|
mHiddenForNoBubbles = hidden;
|
|
updateVisibilityForStateChange();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when the home button is enabled / disabled. Bubbles don't show if home is disabled.
|
|
*/
|
|
// TODO: is this needed for bubbles?
|
|
public void setIsHomeButtonDisabled(boolean homeDisabled) {
|
|
mHiddenForHomeButtonDisabled = homeDisabled;
|
|
updateVisibilityForStateChange();
|
|
}
|
|
|
|
// TODO: (b/273592694) animate it?
|
|
private void updateVisibilityForStateChange() {
|
|
if (!mHiddenForSysui && !mHiddenForHomeButtonDisabled && !mHiddenForNoBubbles) {
|
|
mStashedHandleView.setVisibility(VISIBLE);
|
|
} else {
|
|
mStashedHandleView.setVisibility(INVISIBLE);
|
|
mStashedHandleView.setAlpha(0);
|
|
}
|
|
updateRegionSampling();
|
|
}
|
|
|
|
/**
|
|
* Called when bubble bar is stash state changes so that updates to the stashed handle color
|
|
* can be started or stopped.
|
|
*/
|
|
public void onIsStashedChanged() {
|
|
updateRegionSampling();
|
|
}
|
|
|
|
private void updateRegionSampling() {
|
|
boolean handleVisible = mStashedHandleView.getVisibility() == VISIBLE
|
|
&& mBubbleStashController.isStashed();
|
|
if (mRegionSamplingHelper != null) {
|
|
mRegionSamplingHelper.setWindowVisible(handleVisible);
|
|
if (handleVisible) {
|
|
mStashedHandleView.updateSampledRegion(mStashedHandleBounds);
|
|
mRegionSamplingHelper.start(mStashedHandleView.getSampledRegion());
|
|
} else {
|
|
mRegionSamplingHelper.stop();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Returns an animator for translation Y. */
|
|
public AnimatedFloat getStashedHandleTranslationY() {
|
|
return mStashedHandleTranslationY;
|
|
}
|
|
|
|
/**
|
|
* Sets the translation of the stashed handle during the swipe up gesture.
|
|
*/
|
|
public void setTranslationYForSwipe(float transY) {
|
|
mSwipeUpTranslationY = transY;
|
|
updateTranslationY();
|
|
}
|
|
|
|
private void updateTranslationY() {
|
|
mStashedHandleView.setTranslationY(mStashedHandleTranslationY.value + mSwipeUpTranslationY);
|
|
}
|
|
|
|
/**
|
|
* Used by {@link BubbleStashController} to animate the handle when stashing or un stashing.
|
|
*/
|
|
public MultiPropertyFactory<View> getStashedHandleAlpha() {
|
|
return mStashedHandleAlpha;
|
|
}
|
|
|
|
/** Returns the x position of the center of the stashed handle. */
|
|
public float getStashedHandleCenterX() {
|
|
return mStashedHandleBounds.exactCenterX();
|
|
}
|
|
|
|
/**
|
|
* Creates and returns an Animator that updates the stashed handle shape and size.
|
|
* When stashed, the shape is a thin rounded pill. When unstashed, the shape morphs into
|
|
* the size of where the bubble bar icons will be.
|
|
*/
|
|
public Animator createRevealAnimToIsStashed(boolean isStashed) {
|
|
Rect bubbleBarBounds = new Rect(mBarViewController.getBubbleBarBounds());
|
|
|
|
// Account for the full visual height of the bubble bar
|
|
int heightDiff = (mBarSize - bubbleBarBounds.height()) / 2;
|
|
bubbleBarBounds.top -= heightDiff;
|
|
bubbleBarBounds.bottom += heightDiff;
|
|
float stashedHandleRadius = mStashedHandleView.getHeight() / 2f;
|
|
final RevealOutlineAnimation handleRevealProvider = new RoundedRectRevealOutlineProvider(
|
|
stashedHandleRadius, stashedHandleRadius, bubbleBarBounds, mStashedHandleBounds);
|
|
|
|
boolean isReversed = !isStashed;
|
|
boolean changingDirection = mWasLastRevealAnimReversed != isReversed;
|
|
mWasLastRevealAnimReversed = isReversed;
|
|
if (changingDirection) {
|
|
mStartProgressForNextRevealAnim = 1f - mStartProgressForNextRevealAnim;
|
|
}
|
|
|
|
ValueAnimator revealAnim = handleRevealProvider.createRevealAnimator(mStashedHandleView,
|
|
isReversed, mStartProgressForNextRevealAnim);
|
|
revealAnim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
mStartProgressForNextRevealAnim = ((ValueAnimator) animation).getAnimatedFraction();
|
|
}
|
|
});
|
|
return revealAnim;
|
|
}
|
|
|
|
/** Checks that the stash handle is visible and that the motion event is within bounds. */
|
|
public boolean isEventOverHandle(MotionEvent ev) {
|
|
if (mStashedHandleView.getVisibility() != VISIBLE) {
|
|
return false;
|
|
}
|
|
|
|
// the bounds of the handle only include the visible part, so we check that the Y coordinate
|
|
// is anywhere within the stashed taskbar height.
|
|
int top = mActivity.getDeviceProfile().heightPx - mStashedTaskbarHeight;
|
|
|
|
return (int) ev.getRawY() >= top && containsX((int) ev.getRawX());
|
|
}
|
|
|
|
/** Checks if the given x coordinate is within the stashed handle bounds. */
|
|
public boolean containsX(int x) {
|
|
return x >= mStashedHandleBounds.left && x <= mStashedHandleBounds.right;
|
|
}
|
|
|
|
/** Set a bubble bar location */
|
|
public void setBubbleBarLocation(BubbleBarLocation bubbleBarLocation) {
|
|
updateBounds(bubbleBarLocation);
|
|
}
|
|
}
|