/*
|
* Copyright (C) 2012 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.systemui.bubbles;
|
|
import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
|
import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
|
|
import android.animation.Animator;
|
import android.animation.AnimatorListenerAdapter;
|
import android.animation.ValueAnimator;
|
import android.annotation.NonNull;
|
import android.app.Notification;
|
import android.content.Context;
|
import android.content.res.Resources;
|
import android.graphics.ColorMatrix;
|
import android.graphics.ColorMatrixColorFilter;
|
import android.graphics.Outline;
|
import android.graphics.Paint;
|
import android.graphics.Point;
|
import android.graphics.PointF;
|
import android.graphics.Rect;
|
import android.graphics.RectF;
|
import android.os.Bundle;
|
import android.os.VibrationEffect;
|
import android.os.Vibrator;
|
import android.service.notification.StatusBarNotification;
|
import android.util.Log;
|
import android.util.StatsLog;
|
import android.view.Choreographer;
|
import android.view.Gravity;
|
import android.view.LayoutInflater;
|
import android.view.MotionEvent;
|
import android.view.View;
|
import android.view.ViewOutlineProvider;
|
import android.view.ViewTreeObserver;
|
import android.view.WindowInsets;
|
import android.view.WindowManager;
|
import android.view.accessibility.AccessibilityNodeInfo;
|
import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
|
import android.view.animation.AccelerateDecelerateInterpolator;
|
import android.widget.FrameLayout;
|
|
import androidx.annotation.MainThread;
|
import androidx.annotation.Nullable;
|
import androidx.dynamicanimation.animation.DynamicAnimation;
|
import androidx.dynamicanimation.animation.FloatPropertyCompat;
|
import androidx.dynamicanimation.animation.SpringAnimation;
|
import androidx.dynamicanimation.animation.SpringForce;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.widget.ViewClippingUtil;
|
import com.android.systemui.R;
|
import com.android.systemui.bubbles.animation.ExpandedAnimationController;
|
import com.android.systemui.bubbles.animation.PhysicsAnimationLayout;
|
import com.android.systemui.bubbles.animation.StackAnimationController;
|
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
|
/**
|
* Renders bubbles in a stack and handles animating expanded and collapsed states.
|
*/
|
public class BubbleStackView extends FrameLayout {
|
private static final String TAG = "BubbleStackView";
|
private static final boolean DEBUG = false;
|
|
/** How far the flyout needs to be dragged before it's dismissed regardless of velocity. */
|
static final float FLYOUT_DRAG_PERCENT_DISMISS = 0.25f;
|
|
/** Velocity required to dismiss the flyout via drag. */
|
private static final float FLYOUT_DISMISS_VELOCITY = 2000f;
|
|
/**
|
* Factor for attenuating translation when the flyout is overscrolled (8f = flyout moves 1 pixel
|
* for every 8 pixels overscrolled).
|
*/
|
private static final float FLYOUT_OVERSCROLL_ATTENUATION_FACTOR = 8f;
|
|
/** Duration of the flyout alpha animations. */
|
private static final int FLYOUT_ALPHA_ANIMATION_DURATION = 100;
|
|
/** Percent to darken the bubbles when they're in the dismiss target. */
|
private static final float DARKEN_PERCENT = 0.3f;
|
|
/** How long to wait, in milliseconds, before hiding the flyout. */
|
@VisibleForTesting
|
static final int FLYOUT_HIDE_AFTER = 5000;
|
|
/**
|
* Interface to synchronize {@link View} state and the screen.
|
*
|
* {@hide}
|
*/
|
interface SurfaceSynchronizer {
|
/**
|
* Wait until requested change on a {@link View} is reflected on the screen.
|
*
|
* @param callback callback to run after the change is reflected on the screen.
|
*/
|
void syncSurfaceAndRun(Runnable callback);
|
}
|
|
private static final SurfaceSynchronizer DEFAULT_SURFACE_SYNCHRONIZER =
|
new SurfaceSynchronizer() {
|
@Override
|
public void syncSurfaceAndRun(Runnable callback) {
|
Choreographer.getInstance().postFrameCallback(new Choreographer.FrameCallback() {
|
// Just wait 2 frames. There is no guarantee, but this is usually enough time that
|
// the requested change is reflected on the screen.
|
// TODO: Once SurfaceFlinger provide APIs to sync the state of {@code View} and
|
// surfaces, rewrite this logic with them.
|
private int mFrameWait = 2;
|
|
@Override
|
public void doFrame(long frameTimeNanos) {
|
if (--mFrameWait > 0) {
|
Choreographer.getInstance().postFrameCallback(this);
|
} else {
|
callback.run();
|
}
|
}
|
});
|
}
|
};
|
|
private Point mDisplaySize;
|
|
private final SpringAnimation mExpandedViewXAnim;
|
private final SpringAnimation mExpandedViewYAnim;
|
private final BubbleData mBubbleData;
|
|
private final Vibrator mVibrator;
|
private final ValueAnimator mDesaturateAndDarkenAnimator;
|
private final Paint mDesaturateAndDarkenPaint = new Paint();
|
|
private PhysicsAnimationLayout mBubbleContainer;
|
private StackAnimationController mStackAnimationController;
|
private ExpandedAnimationController mExpandedAnimationController;
|
|
private FrameLayout mExpandedViewContainer;
|
|
private BubbleFlyoutView mFlyout;
|
/** Runnable that fades out the flyout and then sets it to GONE. */
|
private Runnable mHideFlyout = () -> animateFlyoutCollapsed(true, 0 /* velX */);
|
|
/** Layout change listener that moves the stack to the nearest valid position on rotation. */
|
private OnLayoutChangeListener mMoveStackToValidPositionOnLayoutListener;
|
/** Whether the stack was on the left side of the screen prior to rotation. */
|
private boolean mWasOnLeftBeforeRotation = false;
|
/**
|
* How far down the screen the stack was before rotation, in terms of percentage of the way down
|
* the allowable region. Defaults to -1 if not set.
|
*/
|
private float mVerticalPosPercentBeforeRotation = -1;
|
|
private int mBubbleSize;
|
private int mBubblePadding;
|
private int mExpandedViewPadding;
|
private int mExpandedAnimateXDistance;
|
private int mExpandedAnimateYDistance;
|
private int mPointerHeight;
|
private int mStatusBarHeight;
|
private int mPipDismissHeight;
|
private int mImeOffset;
|
|
private Bubble mExpandedBubble;
|
private boolean mIsExpanded;
|
private boolean mImeVisible;
|
|
/** Whether the stack is currently on the left side of the screen, or animating there. */
|
private boolean mStackOnLeftOrWillBe = false;
|
|
/** Whether a touch gesture, such as a stack/bubble drag or flyout drag, is in progress. */
|
private boolean mIsGestureInProgress = false;
|
|
private BubbleTouchHandler mTouchHandler;
|
private BubbleController.BubbleExpandListener mExpandListener;
|
private BubbleExpandedView.OnBubbleBlockedListener mBlockedListener;
|
|
private boolean mViewUpdatedRequested = false;
|
private boolean mIsExpansionAnimating = false;
|
private boolean mShowingDismiss = false;
|
|
/**
|
* Whether the user is currently dragging their finger within the dismiss target. In this state
|
* the stack will be magnetized to the center of the target, so we shouldn't move it until the
|
* touch exits the dismiss target area.
|
*/
|
private boolean mDraggingInDismissTarget = false;
|
|
/** Whether the stack is magneting towards the dismiss target. */
|
private boolean mAnimatingMagnet = false;
|
|
/** The view to desaturate/darken when magneted to the dismiss target. */
|
private View mDesaturateAndDarkenTargetView;
|
|
private LayoutInflater mInflater;
|
|
// Used for determining view / touch intersection
|
int[] mTempLoc = new int[2];
|
RectF mTempRect = new RectF();
|
|
private final List<Rect> mSystemGestureExclusionRects = Collections.singletonList(new Rect());
|
|
private ViewTreeObserver.OnPreDrawListener mViewUpdater =
|
new ViewTreeObserver.OnPreDrawListener() {
|
@Override
|
public boolean onPreDraw() {
|
getViewTreeObserver().removeOnPreDrawListener(mViewUpdater);
|
applyCurrentState();
|
mViewUpdatedRequested = false;
|
return true;
|
}
|
};
|
|
private ViewTreeObserver.OnDrawListener mSystemGestureExcludeUpdater =
|
this::updateSystemGestureExcludeRects;
|
|
private ViewClippingUtil.ClippingParameters mClippingParameters =
|
new ViewClippingUtil.ClippingParameters() {
|
|
@Override
|
public boolean shouldFinish(View view) {
|
return false;
|
}
|
|
@Override
|
public boolean isClippingEnablingAllowed(View view) {
|
return !mIsExpanded;
|
}
|
};
|
|
/** Float property that 'drags' the flyout. */
|
private final FloatPropertyCompat mFlyoutCollapseProperty =
|
new FloatPropertyCompat("FlyoutCollapseSpring") {
|
@Override
|
public float getValue(Object o) {
|
return mFlyoutDragDeltaX;
|
}
|
|
@Override
|
public void setValue(Object o, float v) {
|
onFlyoutDragged(v);
|
}
|
};
|
|
/** SpringAnimation that springs the flyout collapsed via onFlyoutDragged. */
|
private final SpringAnimation mFlyoutTransitionSpring =
|
new SpringAnimation(this, mFlyoutCollapseProperty);
|
|
/** Distance the flyout has been dragged in the X axis. */
|
private float mFlyoutDragDeltaX = 0f;
|
|
/**
|
* End listener for the flyout spring that either posts a runnable to hide the flyout, or hides
|
* it immediately.
|
*/
|
private final DynamicAnimation.OnAnimationEndListener mAfterFlyoutTransitionSpring =
|
(dynamicAnimation, b, v, v1) -> {
|
if (mFlyoutDragDeltaX == 0) {
|
mFlyout.postDelayed(mHideFlyout, FLYOUT_HIDE_AFTER);
|
} else {
|
mFlyout.hideFlyout();
|
}
|
};
|
|
@NonNull private final SurfaceSynchronizer mSurfaceSynchronizer;
|
|
private BubbleDismissView mDismissContainer;
|
private Runnable mAfterMagnet;
|
|
private boolean mSuppressNewDot = false;
|
private boolean mSuppressFlyout = false;
|
|
public BubbleStackView(Context context, BubbleData data,
|
@Nullable SurfaceSynchronizer synchronizer) {
|
super(context);
|
|
mBubbleData = data;
|
mInflater = LayoutInflater.from(context);
|
mTouchHandler = new BubbleTouchHandler(this, data, context);
|
setOnTouchListener(mTouchHandler);
|
mInflater = LayoutInflater.from(context);
|
|
Resources res = getResources();
|
mBubbleSize = res.getDimensionPixelSize(R.dimen.individual_bubble_size);
|
mBubblePadding = res.getDimensionPixelSize(R.dimen.bubble_padding);
|
mExpandedAnimateXDistance =
|
res.getDimensionPixelSize(R.dimen.bubble_expanded_animate_x_distance);
|
mExpandedAnimateYDistance =
|
res.getDimensionPixelSize(R.dimen.bubble_expanded_animate_y_distance);
|
mPointerHeight = res.getDimensionPixelSize(R.dimen.bubble_pointer_height);
|
|
mStatusBarHeight =
|
res.getDimensionPixelSize(com.android.internal.R.dimen.status_bar_height);
|
mPipDismissHeight = mContext.getResources().getDimensionPixelSize(
|
R.dimen.pip_dismiss_gradient_height);
|
mImeOffset = res.getDimensionPixelSize(R.dimen.pip_ime_offset);
|
|
mDisplaySize = new Point();
|
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
|
wm.getDefaultDisplay().getSize(mDisplaySize);
|
|
mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
|
|
mExpandedViewPadding = res.getDimensionPixelSize(R.dimen.bubble_expanded_view_padding);
|
int elevation = res.getDimensionPixelSize(R.dimen.bubble_elevation);
|
|
mStackAnimationController = new StackAnimationController();
|
mExpandedAnimationController = new ExpandedAnimationController(
|
mDisplaySize, mExpandedViewPadding);
|
mSurfaceSynchronizer = synchronizer != null ? synchronizer : DEFAULT_SURFACE_SYNCHRONIZER;
|
|
mBubbleContainer = new PhysicsAnimationLayout(context);
|
mBubbleContainer.setActiveController(mStackAnimationController);
|
mBubbleContainer.setElevation(elevation);
|
mBubbleContainer.setClipChildren(false);
|
addView(mBubbleContainer, new FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
|
|
mExpandedViewContainer = new FrameLayout(context);
|
mExpandedViewContainer.setElevation(elevation);
|
mExpandedViewContainer.setPadding(mExpandedViewPadding, mExpandedViewPadding,
|
mExpandedViewPadding, mExpandedViewPadding);
|
mExpandedViewContainer.setClipChildren(false);
|
addView(mExpandedViewContainer);
|
|
mFlyout = new BubbleFlyoutView(context);
|
mFlyout.setVisibility(GONE);
|
mFlyout.animate()
|
.setDuration(FLYOUT_ALPHA_ANIMATION_DURATION)
|
.setInterpolator(new AccelerateDecelerateInterpolator());
|
addView(mFlyout, new FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT));
|
|
mFlyoutTransitionSpring.setSpring(new SpringForce()
|
.setStiffness(SpringForce.STIFFNESS_MEDIUM)
|
.setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY));
|
mFlyoutTransitionSpring.addEndListener(mAfterFlyoutTransitionSpring);
|
|
mDismissContainer = new BubbleDismissView(mContext);
|
mDismissContainer.setLayoutParams(new FrameLayout.LayoutParams(
|
MATCH_PARENT,
|
getResources().getDimensionPixelSize(R.dimen.pip_dismiss_gradient_height),
|
Gravity.BOTTOM));
|
addView(mDismissContainer);
|
|
mDismissContainer = new BubbleDismissView(mContext);
|
mDismissContainer.setLayoutParams(new FrameLayout.LayoutParams(
|
MATCH_PARENT,
|
getResources().getDimensionPixelSize(R.dimen.pip_dismiss_gradient_height),
|
Gravity.BOTTOM));
|
addView(mDismissContainer);
|
|
mExpandedViewXAnim =
|
new SpringAnimation(mExpandedViewContainer, DynamicAnimation.TRANSLATION_X);
|
mExpandedViewXAnim.setSpring(
|
new SpringForce()
|
.setStiffness(SpringForce.STIFFNESS_LOW)
|
.setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY));
|
|
mExpandedViewYAnim =
|
new SpringAnimation(mExpandedViewContainer, DynamicAnimation.TRANSLATION_Y);
|
mExpandedViewYAnim.setSpring(
|
new SpringForce()
|
.setStiffness(SpringForce.STIFFNESS_LOW)
|
.setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY));
|
mExpandedViewYAnim.addEndListener((anim, cancelled, value, velocity) -> {
|
if (mIsExpanded && mExpandedBubble != null) {
|
mExpandedBubble.expandedView.updateView();
|
}
|
});
|
|
setClipChildren(false);
|
setFocusable(true);
|
mBubbleContainer.bringToFront();
|
|
setOnApplyWindowInsetsListener((View view, WindowInsets insets) -> {
|
final int keyboardHeight = insets.getSystemWindowInsetBottom()
|
- insets.getStableInsetBottom();
|
if (!mIsExpanded || mIsExpansionAnimating) {
|
return view.onApplyWindowInsets(insets);
|
}
|
mImeVisible = keyboardHeight != 0;
|
|
float newY = getYPositionForExpandedView();
|
if (newY < 0) {
|
// TODO: This means our expanded content is too big to fit on screen. Right now
|
// we'll let it translate off but we should be clipping it & pushing the header
|
// down so that it always remains visible.
|
}
|
mExpandedViewYAnim.animateToFinalPosition(newY);
|
mExpandedAnimationController.updateYPosition(
|
// Update the insets after we're done translating otherwise position
|
// calculation for them won't be correct.
|
() -> mExpandedBubble.expandedView.updateInsets(insets));
|
return view.onApplyWindowInsets(insets);
|
});
|
|
mMoveStackToValidPositionOnLayoutListener =
|
(v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) -> {
|
if (mVerticalPosPercentBeforeRotation >= 0) {
|
mStackAnimationController.moveStackToSimilarPositionAfterRotation(
|
mWasOnLeftBeforeRotation, mVerticalPosPercentBeforeRotation);
|
}
|
removeOnLayoutChangeListener(mMoveStackToValidPositionOnLayoutListener);
|
};
|
|
// This must be a separate OnDrawListener since it should be called for every draw.
|
getViewTreeObserver().addOnDrawListener(mSystemGestureExcludeUpdater);
|
|
final ColorMatrix animatedMatrix = new ColorMatrix();
|
final ColorMatrix darkenMatrix = new ColorMatrix();
|
|
mDesaturateAndDarkenAnimator = ValueAnimator.ofFloat(1f, 0f);
|
mDesaturateAndDarkenAnimator.addUpdateListener(animation -> {
|
final float animatedValue = (float) animation.getAnimatedValue();
|
animatedMatrix.setSaturation(animatedValue);
|
|
final float animatedDarkenValue = (1f - animatedValue) * DARKEN_PERCENT;
|
darkenMatrix.setScale(
|
1f - animatedDarkenValue /* red */,
|
1f - animatedDarkenValue /* green */,
|
1f - animatedDarkenValue /* blue */,
|
1f /* alpha */);
|
|
// Concat the matrices so that the animatedMatrix both desaturates and darkens.
|
animatedMatrix.postConcat(darkenMatrix);
|
|
// Update the paint and apply it to the bubble container.
|
mDesaturateAndDarkenPaint.setColorFilter(new ColorMatrixColorFilter(animatedMatrix));
|
mDesaturateAndDarkenTargetView.setLayerPaint(mDesaturateAndDarkenPaint);
|
});
|
}
|
|
/**
|
* Handle theme changes.
|
*/
|
public void onThemeChanged() {
|
for (Bubble b: mBubbleData.getBubbles()) {
|
b.iconView.updateViews();
|
b.expandedView.applyThemeAttrs();
|
}
|
}
|
|
/** Respond to the phone being rotated by repositioning the stack and hiding any flyouts. */
|
public void onOrientationChanged() {
|
final RectF allowablePos = mStackAnimationController.getAllowableStackPositionRegion();
|
mWasOnLeftBeforeRotation = mStackAnimationController.isStackOnLeftSide();
|
mVerticalPosPercentBeforeRotation =
|
(mStackAnimationController.getStackPosition().y - allowablePos.top)
|
/ (allowablePos.bottom - allowablePos.top);
|
addOnLayoutChangeListener(mMoveStackToValidPositionOnLayoutListener);
|
|
hideFlyoutImmediate();
|
}
|
|
@Override
|
public void getBoundsOnScreen(Rect outRect, boolean clipToParent) {
|
getBoundsOnScreen(outRect);
|
}
|
|
@Override
|
protected void onDetachedFromWindow() {
|
super.onDetachedFromWindow();
|
getViewTreeObserver().removeOnPreDrawListener(mViewUpdater);
|
}
|
|
@Override
|
public boolean onInterceptTouchEvent(MotionEvent ev) {
|
float x = ev.getRawX();
|
float y = ev.getRawY();
|
// If we're expanded only intercept if the tap is outside of the widget container
|
if (mIsExpanded && isIntersecting(mExpandedViewContainer, x, y)) {
|
return false;
|
} else {
|
return isIntersecting(mBubbleContainer, x, y);
|
}
|
}
|
|
@Override
|
public void onInitializeAccessibilityNodeInfoInternal(AccessibilityNodeInfo info) {
|
super.onInitializeAccessibilityNodeInfoInternal(info);
|
|
// Custom actions.
|
AccessibilityAction moveTopLeft = new AccessibilityAction(R.id.action_move_top_left,
|
getContext().getResources()
|
.getString(R.string.bubble_accessibility_action_move_top_left));
|
info.addAction(moveTopLeft);
|
|
AccessibilityAction moveTopRight = new AccessibilityAction(R.id.action_move_top_right,
|
getContext().getResources()
|
.getString(R.string.bubble_accessibility_action_move_top_right));
|
info.addAction(moveTopRight);
|
|
AccessibilityAction moveBottomLeft = new AccessibilityAction(R.id.action_move_bottom_left,
|
getContext().getResources()
|
.getString(R.string.bubble_accessibility_action_move_bottom_left));
|
info.addAction(moveBottomLeft);
|
|
AccessibilityAction moveBottomRight = new AccessibilityAction(R.id.action_move_bottom_right,
|
getContext().getResources()
|
.getString(R.string.bubble_accessibility_action_move_bottom_right));
|
info.addAction(moveBottomRight);
|
|
// Default actions.
|
info.addAction(AccessibilityAction.ACTION_DISMISS);
|
if (mIsExpanded) {
|
info.addAction(AccessibilityAction.ACTION_COLLAPSE);
|
} else {
|
info.addAction(AccessibilityAction.ACTION_EXPAND);
|
}
|
}
|
|
@Override
|
public boolean performAccessibilityActionInternal(int action, Bundle arguments) {
|
if (super.performAccessibilityActionInternal(action, arguments)) {
|
return true;
|
}
|
final RectF stackBounds = mStackAnimationController.getAllowableStackPositionRegion();
|
|
// R constants are not final so we cannot use switch-case here.
|
if (action == AccessibilityNodeInfo.ACTION_DISMISS) {
|
mBubbleData.dismissAll(BubbleController.DISMISS_ACCESSIBILITY_ACTION);
|
return true;
|
} else if (action == AccessibilityNodeInfo.ACTION_COLLAPSE) {
|
mBubbleData.setExpanded(false);
|
return true;
|
} else if (action == AccessibilityNodeInfo.ACTION_EXPAND) {
|
mBubbleData.setExpanded(true);
|
return true;
|
} else if (action == R.id.action_move_top_left) {
|
mStackAnimationController.springStack(stackBounds.left, stackBounds.top);
|
return true;
|
} else if (action == R.id.action_move_top_right) {
|
mStackAnimationController.springStack(stackBounds.right, stackBounds.top);
|
return true;
|
} else if (action == R.id.action_move_bottom_left) {
|
mStackAnimationController.springStack(stackBounds.left, stackBounds.bottom);
|
return true;
|
} else if (action == R.id.action_move_bottom_right) {
|
mStackAnimationController.springStack(stackBounds.right, stackBounds.bottom);
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* Update content description for a11y TalkBack.
|
*/
|
public void updateContentDescription() {
|
if (mBubbleData.getBubbles().isEmpty()) {
|
return;
|
}
|
Bubble topBubble = mBubbleData.getBubbles().get(0);
|
String appName = topBubble.getAppName();
|
Notification notification = topBubble.entry.notification.getNotification();
|
CharSequence titleCharSeq = notification.extras.getCharSequence(Notification.EXTRA_TITLE);
|
String titleStr = getResources().getString(R.string.stream_notification);
|
if (titleCharSeq != null) {
|
titleStr = titleCharSeq.toString();
|
}
|
int moreCount = mBubbleContainer.getChildCount() - 1;
|
|
// Example: Title from app name.
|
String singleDescription = getResources().getString(
|
R.string.bubble_content_description_single, titleStr, appName);
|
|
// Example: Title from app name and 4 more.
|
String stackDescription = getResources().getString(
|
R.string.bubble_content_description_stack, titleStr, appName, moreCount);
|
|
if (mIsExpanded) {
|
// TODO(b/129522932) - update content description for each bubble in expanded view.
|
} else {
|
// Collapsed stack.
|
if (moreCount > 0) {
|
mBubbleContainer.setContentDescription(stackDescription);
|
} else {
|
mBubbleContainer.setContentDescription(singleDescription);
|
}
|
}
|
}
|
|
private void updateSystemGestureExcludeRects() {
|
// Exclude the region occupied by the first BubbleView in the stack
|
Rect excludeZone = mSystemGestureExclusionRects.get(0);
|
if (mBubbleContainer.getChildCount() > 0) {
|
View firstBubble = mBubbleContainer.getChildAt(0);
|
excludeZone.set(firstBubble.getLeft(), firstBubble.getTop(), firstBubble.getRight(),
|
firstBubble.getBottom());
|
excludeZone.offset((int) (firstBubble.getTranslationX() + 0.5f),
|
(int) (firstBubble.getTranslationY() + 0.5f));
|
mBubbleContainer.setSystemGestureExclusionRects(mSystemGestureExclusionRects);
|
} else {
|
excludeZone.setEmpty();
|
mBubbleContainer.setSystemGestureExclusionRects(Collections.emptyList());
|
}
|
}
|
|
/**
|
* Updates the visibility of the 'dot' indicating an update on the bubble.
|
* @param key the {@link NotificationEntry#key} associated with the bubble.
|
*/
|
public void updateDotVisibility(String key) {
|
Bubble b = mBubbleData.getBubbleWithKey(key);
|
if (b != null) {
|
b.updateDotVisibility();
|
}
|
}
|
|
/**
|
* Sets the listener to notify when the bubble stack is expanded.
|
*/
|
public void setExpandListener(BubbleController.BubbleExpandListener listener) {
|
mExpandListener = listener;
|
}
|
|
/**
|
* Whether the stack of bubbles is expanded or not.
|
*/
|
public boolean isExpanded() {
|
return mIsExpanded;
|
}
|
|
/**
|
* The {@link BubbleView} that is expanded, null if one does not exist.
|
*/
|
BubbleView getExpandedBubbleView() {
|
return mExpandedBubble != null ? mExpandedBubble.iconView : null;
|
}
|
|
/**
|
* The {@link Bubble} that is expanded, null if one does not exist.
|
*/
|
Bubble getExpandedBubble() {
|
return mExpandedBubble;
|
}
|
|
/**
|
* Sets the bubble that should be expanded and expands if needed.
|
*
|
* @param key the {@link NotificationEntry#key} associated with the bubble to expand.
|
* @deprecated replaced by setSelectedBubble(Bubble) + setExpanded(true)
|
*/
|
@Deprecated
|
void setExpandedBubble(String key) {
|
Bubble bubbleToExpand = mBubbleData.getBubbleWithKey(key);
|
if (bubbleToExpand != null) {
|
setSelectedBubble(bubbleToExpand);
|
bubbleToExpand.entry.setShowInShadeWhenBubble(false);
|
setExpanded(true);
|
}
|
}
|
|
/**
|
* Sets the entry that should be expanded and expands if needed.
|
*/
|
@VisibleForTesting
|
void setExpandedBubble(NotificationEntry entry) {
|
for (int i = 0; i < mBubbleContainer.getChildCount(); i++) {
|
BubbleView bv = (BubbleView) mBubbleContainer.getChildAt(i);
|
if (entry.equals(bv.getEntry())) {
|
setExpandedBubble(entry.key);
|
}
|
}
|
}
|
|
// via BubbleData.Listener
|
void addBubble(Bubble bubble) {
|
if (DEBUG) {
|
Log.d(TAG, "addBubble: " + bubble);
|
}
|
bubble.inflate(mInflater, this);
|
mBubbleContainer.addView(bubble.iconView, 0,
|
new FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT));
|
ViewClippingUtil.setClippingDeactivated(bubble.iconView, true, mClippingParameters);
|
if (bubble.iconView != null) {
|
bubble.iconView.setSuppressDot(mSuppressNewDot, false /* animate */);
|
}
|
animateInFlyoutForBubble(bubble);
|
requestUpdate();
|
logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__POSTED);
|
updatePointerPosition();
|
}
|
|
// via BubbleData.Listener
|
void removeBubble(Bubble bubble) {
|
if (DEBUG) {
|
Log.d(TAG, "removeBubble: " + bubble);
|
}
|
// Remove it from the views
|
int removedIndex = mBubbleContainer.indexOfChild(bubble.iconView);
|
if (removedIndex >= 0) {
|
mBubbleContainer.removeViewAt(removedIndex);
|
logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__DISMISSED);
|
} else {
|
Log.d(TAG, "was asked to remove Bubble, but didn't find the view! " + bubble);
|
}
|
updatePointerPosition();
|
}
|
|
// via BubbleData.Listener
|
void updateBubble(Bubble bubble) {
|
animateInFlyoutForBubble(bubble);
|
requestUpdate();
|
logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__UPDATED);
|
}
|
|
public void updateBubbleOrder(List<Bubble> bubbles) {
|
for (int i = 0; i < bubbles.size(); i++) {
|
Bubble bubble = bubbles.get(i);
|
mBubbleContainer.reorderView(bubble.iconView, i);
|
}
|
}
|
|
/**
|
* Changes the currently selected bubble. If the stack is already expanded, the newly selected
|
* bubble will be shown immediately. This does not change the expanded state or change the
|
* position of any bubble.
|
*/
|
// via BubbleData.Listener
|
public void setSelectedBubble(@Nullable Bubble bubbleToSelect) {
|
if (DEBUG) {
|
Log.d(TAG, "setSelectedBubble: " + bubbleToSelect);
|
}
|
if (mExpandedBubble != null && mExpandedBubble.equals(bubbleToSelect)) {
|
return;
|
}
|
final Bubble previouslySelected = mExpandedBubble;
|
mExpandedBubble = bubbleToSelect;
|
if (mIsExpanded) {
|
// Make the container of the expanded view transparent before removing the expanded view
|
// from it. Otherwise a punch hole created by {@link android.view.SurfaceView} in the
|
// expanded view becomes visible on the screen. See b/126856255
|
mExpandedViewContainer.setAlpha(0.0f);
|
mSurfaceSynchronizer.syncSurfaceAndRun(() -> {
|
updateExpandedBubble();
|
updatePointerPosition();
|
requestUpdate();
|
logBubbleEvent(previouslySelected, StatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
|
logBubbleEvent(bubbleToSelect, StatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
|
notifyExpansionChanged(previouslySelected.entry, false /* expanded */);
|
notifyExpansionChanged(bubbleToSelect == null ? null : bubbleToSelect.entry,
|
true /* expanded */);
|
});
|
}
|
}
|
|
/**
|
* Changes the expanded state of the stack.
|
*
|
* @param shouldExpand whether the bubble stack should appear expanded
|
*/
|
// via BubbleData.Listener
|
public void setExpanded(boolean shouldExpand) {
|
if (DEBUG) {
|
Log.d(TAG, "setExpanded: " + shouldExpand);
|
}
|
boolean wasExpanded = mIsExpanded;
|
if (shouldExpand == wasExpanded) {
|
return;
|
}
|
if (wasExpanded) {
|
// Collapse the stack
|
animateExpansion(false /* expand */);
|
logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
|
} else {
|
// Expand the stack
|
animateExpansion(true /* expand */);
|
// TODO: move next line to BubbleData
|
logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
|
logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__STACK_EXPANDED);
|
}
|
notifyExpansionChanged(mExpandedBubble.entry, mIsExpanded);
|
}
|
|
/**
|
* Dismiss the stack of bubbles.
|
* @deprecated
|
*/
|
@Deprecated
|
void stackDismissed(int reason) {
|
if (DEBUG) {
|
Log.d(TAG, "stackDismissed: reason=" + reason);
|
}
|
mBubbleData.dismissAll(reason);
|
logBubbleEvent(null /* no bubble associated with bubble stack dismiss */,
|
StatsLog.BUBBLE_UICHANGED__ACTION__STACK_DISMISSED);
|
}
|
|
/**
|
* @return the view the touch event is on
|
*/
|
@Nullable
|
public View getTargetView(MotionEvent event) {
|
float x = event.getRawX();
|
float y = event.getRawY();
|
if (mIsExpanded) {
|
if (isIntersecting(mBubbleContainer, x, y)) {
|
for (int i = 0; i < mBubbleContainer.getChildCount(); i++) {
|
BubbleView view = (BubbleView) mBubbleContainer.getChildAt(i);
|
if (isIntersecting(view, x, y)) {
|
return view;
|
}
|
}
|
} else if (isIntersecting(mExpandedViewContainer, x, y)) {
|
return mExpandedViewContainer;
|
}
|
// Outside parts of view we care about.
|
return null;
|
} else if (mFlyout.getVisibility() == VISIBLE && isIntersecting(mFlyout, x, y)) {
|
return mFlyout;
|
}
|
|
// If it wasn't an individual bubble in the expanded state, or the flyout, it's the stack.
|
return this;
|
}
|
|
View getFlyoutView() {
|
return mFlyout;
|
}
|
|
/**
|
* Collapses the stack of bubbles.
|
* <p>
|
* Must be called from the main thread.
|
*
|
* @deprecated use {@link #setExpanded(boolean)} and {@link #setSelectedBubble(Bubble)}
|
*/
|
@Deprecated
|
@MainThread
|
void collapseStack() {
|
if (DEBUG) {
|
Log.d(TAG, "collapseStack()");
|
}
|
mBubbleData.setExpanded(false);
|
}
|
|
/**
|
* @deprecated use {@link #setExpanded(boolean)} and {@link #setSelectedBubble(Bubble)}
|
*/
|
@Deprecated
|
@MainThread
|
void collapseStack(Runnable endRunnable) {
|
if (DEBUG) {
|
Log.d(TAG, "collapseStack(endRunnable)");
|
}
|
collapseStack();
|
// TODO - use the runnable at end of animation
|
endRunnable.run();
|
}
|
|
/**
|
* Expands the stack of bubbles.
|
* <p>
|
* Must be called from the main thread.
|
*
|
* @deprecated use {@link #setExpanded(boolean)} and {@link #setSelectedBubble(Bubble)}
|
*/
|
@Deprecated
|
@MainThread
|
void expandStack() {
|
if (DEBUG) {
|
Log.d(TAG, "expandStack()");
|
}
|
mBubbleData.setExpanded(true);
|
}
|
|
/**
|
* Tell the stack to animate to collapsed or expanded state.
|
*/
|
private void animateExpansion(boolean shouldExpand) {
|
if (DEBUG) {
|
Log.d(TAG, "animateExpansion: shouldExpand=" + shouldExpand);
|
}
|
if (mIsExpanded != shouldExpand) {
|
hideFlyoutImmediate();
|
|
mIsExpanded = shouldExpand;
|
updateExpandedBubble();
|
applyCurrentState();
|
|
mIsExpansionAnimating = true;
|
|
Runnable updateAfter = () -> {
|
applyCurrentState();
|
mIsExpansionAnimating = false;
|
requestUpdate();
|
};
|
|
if (shouldExpand) {
|
mBubbleContainer.setActiveController(mExpandedAnimationController);
|
mExpandedAnimationController.expandFromStack(() -> {
|
updatePointerPosition();
|
updateAfter.run();
|
} /* after */);
|
} else {
|
mBubbleContainer.cancelAllAnimations();
|
mExpandedAnimationController.collapseBackToStack(
|
mStackAnimationController.getStackPositionAlongNearestHorizontalEdge(),
|
() -> {
|
mBubbleContainer.setActiveController(mStackAnimationController);
|
updateAfter.run();
|
});
|
}
|
|
final float xStart =
|
mStackAnimationController.getStackPosition().x < getWidth() / 2
|
? -mExpandedAnimateXDistance
|
: mExpandedAnimateXDistance;
|
|
final float yStart = Math.min(
|
mStackAnimationController.getStackPosition().y,
|
mExpandedAnimateYDistance);
|
final float yDest = getYPositionForExpandedView();
|
|
if (shouldExpand) {
|
mExpandedViewContainer.setTranslationX(xStart);
|
mExpandedViewContainer.setTranslationY(yStart);
|
mExpandedViewContainer.setAlpha(0f);
|
}
|
|
mExpandedViewXAnim.animateToFinalPosition(shouldExpand ? 0f : xStart);
|
mExpandedViewYAnim.animateToFinalPosition(shouldExpand ? yDest : yStart);
|
mExpandedViewContainer.animate()
|
.setDuration(100)
|
.alpha(shouldExpand ? 1f : 0f);
|
}
|
}
|
|
private void notifyExpansionChanged(NotificationEntry entry, boolean expanded) {
|
if (mExpandListener != null) {
|
mExpandListener.onBubbleExpandChanged(expanded, entry != null ? entry.key : null);
|
}
|
}
|
|
/** Return the BubbleView at the given index from the bubble container. */
|
public BubbleView getBubbleAt(int i) {
|
return mBubbleContainer.getChildCount() > i
|
? (BubbleView) mBubbleContainer.getChildAt(i)
|
: null;
|
}
|
|
/** Moves the bubbles out of the way if they're going to be over the keyboard. */
|
public void onImeVisibilityChanged(boolean visible, int height) {
|
mStackAnimationController.setImeHeight(height + mImeOffset);
|
|
if (!mIsExpanded) {
|
mStackAnimationController.animateForImeVisibility(visible);
|
}
|
}
|
|
/** Called when a drag operation on an individual bubble has started. */
|
public void onBubbleDragStart(View bubble) {
|
if (DEBUG) {
|
Log.d(TAG, "onBubbleDragStart: bubble=" + bubble);
|
}
|
mExpandedAnimationController.prepareForBubbleDrag(bubble);
|
}
|
|
/** Called with the coordinates to which an individual bubble has been dragged. */
|
public void onBubbleDragged(View bubble, float x, float y) {
|
if (!mIsExpanded || mIsExpansionAnimating) {
|
return;
|
}
|
|
mExpandedAnimationController.dragBubbleOut(bubble, x, y);
|
springInDismissTarget();
|
}
|
|
/** Called when a drag operation on an individual bubble has finished. */
|
public void onBubbleDragFinish(
|
View bubble, float x, float y, float velX, float velY) {
|
if (DEBUG) {
|
Log.d(TAG, "onBubbleDragFinish: bubble=" + bubble);
|
}
|
|
if (!mIsExpanded || mIsExpansionAnimating) {
|
return;
|
}
|
|
mExpandedAnimationController.snapBubbleBack(bubble, velX, velY);
|
springOutDismissTargetAndHideCircle();
|
}
|
|
void onDragStart() {
|
if (DEBUG) {
|
Log.d(TAG, "onDragStart()");
|
}
|
if (mIsExpanded || mIsExpansionAnimating) {
|
return;
|
}
|
|
mStackAnimationController.cancelStackPositionAnimations();
|
mBubbleContainer.setActiveController(mStackAnimationController);
|
hideFlyoutImmediate();
|
|
mDraggingInDismissTarget = false;
|
}
|
|
void onDragged(float x, float y) {
|
if (mIsExpanded || mIsExpansionAnimating) {
|
return;
|
}
|
|
springInDismissTarget();
|
mStackAnimationController.moveStackFromTouch(x, y);
|
}
|
|
void onDragFinish(float x, float y, float velX, float velY) {
|
if (DEBUG) {
|
Log.d(TAG, "onDragFinish");
|
}
|
|
if (mIsExpanded || mIsExpansionAnimating) {
|
return;
|
}
|
|
final float newStackX = mStackAnimationController.flingStackThenSpringToEdge(x, velX, velY);
|
logBubbleEvent(null /* no bubble associated with bubble stack move */,
|
StatsLog.BUBBLE_UICHANGED__ACTION__STACK_MOVED);
|
|
mStackOnLeftOrWillBe = newStackX <= 0;
|
updateBubbleShadowsAndDotPosition(true /* animate */);
|
springOutDismissTargetAndHideCircle();
|
}
|
|
void onFlyoutDragStart() {
|
mFlyout.removeCallbacks(mHideFlyout);
|
}
|
|
void onFlyoutDragged(float deltaX) {
|
final boolean onLeft = mStackAnimationController.isStackOnLeftSide();
|
mFlyoutDragDeltaX = deltaX;
|
|
final float collapsePercent =
|
onLeft ? -deltaX / mFlyout.getWidth() : deltaX / mFlyout.getWidth();
|
mFlyout.setCollapsePercent(Math.min(1f, Math.max(0f, collapsePercent)));
|
|
// Calculate how to translate the flyout if it has been dragged too far in etiher direction.
|
float overscrollTranslation = 0f;
|
if (collapsePercent < 0f || collapsePercent > 1f) {
|
// Whether we are more than 100% transitioned to the dot.
|
final boolean overscrollingPastDot = collapsePercent > 1f;
|
|
// Whether we are overscrolling physically to the left - this can either be pulling the
|
// flyout away from the stack (if the stack is on the right) or pushing it to the left
|
// after it has already become the dot.
|
final boolean overscrollingLeft =
|
(onLeft && collapsePercent > 1f) || (!onLeft && collapsePercent < 0f);
|
|
overscrollTranslation =
|
(overscrollingPastDot ? collapsePercent - 1f : collapsePercent * -1)
|
* (overscrollingLeft ? -1 : 1)
|
* (mFlyout.getWidth() / (FLYOUT_OVERSCROLL_ATTENUATION_FACTOR
|
// Attenuate the smaller dot less than the larger flyout.
|
/ (overscrollingPastDot ? 2 : 1)));
|
}
|
|
mFlyout.setTranslationX(mFlyout.getRestingTranslationX() + overscrollTranslation);
|
}
|
|
/**
|
* Called when the flyout drag has finished, and returns true if the gesture successfully
|
* dismissed the flyout.
|
*/
|
void onFlyoutDragFinished(float deltaX, float velX) {
|
final boolean onLeft = mStackAnimationController.isStackOnLeftSide();
|
final boolean metRequiredVelocity =
|
onLeft ? velX < -FLYOUT_DISMISS_VELOCITY : velX > FLYOUT_DISMISS_VELOCITY;
|
final boolean metRequiredDeltaX =
|
onLeft
|
? deltaX < -mFlyout.getWidth() * FLYOUT_DRAG_PERCENT_DISMISS
|
: deltaX > mFlyout.getWidth() * FLYOUT_DRAG_PERCENT_DISMISS;
|
final boolean isCancelFling = onLeft ? velX > 0 : velX < 0;
|
final boolean shouldDismiss = metRequiredVelocity || (metRequiredDeltaX && !isCancelFling);
|
|
mFlyout.removeCallbacks(mHideFlyout);
|
animateFlyoutCollapsed(shouldDismiss, velX);
|
}
|
|
/**
|
* Called when the first touch event of a gesture (stack drag, bubble drag, flyout drag, etc.)
|
* is received.
|
*/
|
void onGestureStart() {
|
mIsGestureInProgress = true;
|
}
|
|
/** Called when a gesture is completed or cancelled. */
|
void onGestureFinished() {
|
mIsGestureInProgress = false;
|
|
if (mIsExpanded) {
|
mExpandedAnimationController.onGestureFinished();
|
}
|
}
|
|
/** Prepares and starts the desaturate/darken animation on the bubble stack. */
|
private void animateDesaturateAndDarken(View targetView, boolean desaturateAndDarken) {
|
mDesaturateAndDarkenTargetView = targetView;
|
|
if (desaturateAndDarken) {
|
// Use the animated paint for the bubbles.
|
mDesaturateAndDarkenTargetView.setLayerType(
|
View.LAYER_TYPE_HARDWARE, mDesaturateAndDarkenPaint);
|
mDesaturateAndDarkenAnimator.removeAllListeners();
|
mDesaturateAndDarkenAnimator.start();
|
} else {
|
mDesaturateAndDarkenAnimator.removeAllListeners();
|
mDesaturateAndDarkenAnimator.addListener(new AnimatorListenerAdapter() {
|
@Override
|
public void onAnimationEnd(Animator animation) {
|
super.onAnimationEnd(animation);
|
// Stop using the animated paint.
|
resetDesaturationAndDarken();
|
}
|
});
|
mDesaturateAndDarkenAnimator.reverse();
|
}
|
}
|
|
private void resetDesaturationAndDarken() {
|
mDesaturateAndDarkenAnimator.removeAllListeners();
|
mDesaturateAndDarkenAnimator.cancel();
|
mDesaturateAndDarkenTargetView.setLayerType(View.LAYER_TYPE_NONE, null);
|
}
|
|
/**
|
* Magnets the stack to the target, while also transforming the target to encircle the stack and
|
* desaturating/darkening the bubbles.
|
*/
|
void animateMagnetToDismissTarget(
|
View magnetView, boolean toTarget, float x, float y, float velX, float velY) {
|
mDraggingInDismissTarget = toTarget;
|
|
if (toTarget) {
|
// The Y-value for the bubble stack to be positioned in the center of the dismiss target
|
final float destY = mDismissContainer.getDismissTargetCenterY() - mBubbleSize / 2f;
|
|
mAnimatingMagnet = true;
|
|
final Runnable afterMagnet = () -> {
|
mAnimatingMagnet = false;
|
if (mAfterMagnet != null) {
|
mAfterMagnet.run();
|
}
|
};
|
|
if (magnetView == this) {
|
mStackAnimationController.magnetToDismiss(velX, velY, destY, afterMagnet);
|
animateDesaturateAndDarken(mBubbleContainer, true);
|
} else {
|
mExpandedAnimationController.magnetBubbleToDismiss(
|
magnetView, velX, velY, destY, afterMagnet);
|
|
animateDesaturateAndDarken(magnetView, true);
|
}
|
|
mDismissContainer.animateEncircleCenterWithX(true);
|
|
} else {
|
mAnimatingMagnet = false;
|
|
if (magnetView == this) {
|
mStackAnimationController.demagnetizeFromDismissToPoint(x, y, velX, velY);
|
animateDesaturateAndDarken(mBubbleContainer, false);
|
} else {
|
mExpandedAnimationController.demagnetizeBubbleTo(x, y, velX, velY);
|
animateDesaturateAndDarken(magnetView, false);
|
}
|
|
mDismissContainer.animateEncircleCenterWithX(false);
|
}
|
|
mVibrator.vibrate(VibrationEffect.get(toTarget
|
? VibrationEffect.EFFECT_CLICK
|
: VibrationEffect.EFFECT_TICK));
|
}
|
|
/**
|
* Magnets the stack to the dismiss target if it's not already there. Then, dismiss the stack
|
* using the 'implode' animation and animate out the target.
|
*/
|
void magnetToStackIfNeededThenAnimateDismissal(
|
View touchedView, float velX, float velY, Runnable after) {
|
final View draggedOutBubble = mExpandedAnimationController.getDraggedOutBubble();
|
final Runnable animateDismissal = () -> {
|
mAfterMagnet = null;
|
|
mVibrator.vibrate(VibrationEffect.get(VibrationEffect.EFFECT_CLICK));
|
mDismissContainer.animateEncirclingCircleDisappearance();
|
|
// 'Implode' the stack and then hide the dismiss target.
|
if (touchedView == this) {
|
mStackAnimationController.implodeStack(
|
() -> {
|
mAnimatingMagnet = false;
|
mShowingDismiss = false;
|
mDraggingInDismissTarget = false;
|
after.run();
|
resetDesaturationAndDarken();
|
});
|
} else {
|
mExpandedAnimationController.dismissDraggedOutBubble(draggedOutBubble, () -> {
|
mAnimatingMagnet = false;
|
mShowingDismiss = false;
|
mDraggingInDismissTarget = false;
|
resetDesaturationAndDarken();
|
after.run();
|
});
|
}
|
};
|
|
if (mAnimatingMagnet) {
|
// If the magnet animation is currently playing, dismiss the stack after it's done. This
|
// happens if the stack is flung towards the target.
|
mAfterMagnet = animateDismissal;
|
} else if (mDraggingInDismissTarget) {
|
// If we're in the dismiss target, but not animating, we already magneted - dismiss
|
// immediately.
|
animateDismissal.run();
|
} else {
|
// Otherwise, we need to start the magnet animation and then dismiss afterward.
|
animateMagnetToDismissTarget(touchedView, true, -1 /* x */, -1 /* y */, velX, velY);
|
mAfterMagnet = animateDismissal;
|
}
|
}
|
|
/** Animates in the dismiss target, including the gradient behind it. */
|
private void springInDismissTarget() {
|
if (mShowingDismiss) {
|
return;
|
}
|
|
mShowingDismiss = true;
|
|
// Show the dismiss container and bring it to the front so the bubbles will go behind it.
|
mDismissContainer.springIn();
|
mDismissContainer.bringToFront();
|
mDismissContainer.setZ(Short.MAX_VALUE - 1);
|
}
|
|
/**
|
* Animates the dismiss target out, as well as the circle that encircles the bubbles, if they
|
* were dragged into the target and encircled.
|
*/
|
private void springOutDismissTargetAndHideCircle() {
|
if (!mShowingDismiss) {
|
return;
|
}
|
|
mDismissContainer.springOut();
|
mShowingDismiss = false;
|
}
|
|
/** Whether the location of the given MotionEvent is within the dismiss target area. */
|
boolean isInDismissTarget(MotionEvent ev) {
|
return isIntersecting(mDismissContainer.getDismissTarget(), ev.getRawX(), ev.getRawY());
|
}
|
|
/** Animates the flyout collapsed (to dot), or the reverse, starting with the given velocity. */
|
private void animateFlyoutCollapsed(boolean collapsed, float velX) {
|
final boolean onLeft = mStackAnimationController.isStackOnLeftSide();
|
mFlyoutTransitionSpring
|
.setStartValue(mFlyoutDragDeltaX)
|
.setStartVelocity(velX)
|
.animateToFinalPosition(collapsed
|
? (onLeft ? -mFlyout.getWidth() : mFlyout.getWidth())
|
: 0f);
|
}
|
|
/**
|
* Calculates how large the expanded view of the bubble can be. This takes into account the
|
* y position when the bubbles are expanded as well as the bounds of the dismiss target.
|
*/
|
int getMaxExpandedHeight() {
|
int expandedY = (int) mExpandedAnimationController.getExpandedY();
|
// PIP dismiss view uses FLAG_LAYOUT_IN_SCREEN so we need to subtract the bottom inset
|
int pipDismissHeight = mPipDismissHeight - getBottomInset();
|
return mDisplaySize.y - expandedY - mBubbleSize - pipDismissHeight;
|
}
|
|
/**
|
* Calculates the y position of the expanded view when it is expanded.
|
*/
|
float getYPositionForExpandedView() {
|
return getStatusBarHeight() + mBubbleSize + mBubblePadding + mPointerHeight;
|
}
|
|
/**
|
* Called when the height of the currently expanded view has changed (not via an
|
* update to the bubble's desired height but for some other reason, e.g. permission view
|
* goes away).
|
*/
|
void onExpandedHeightChanged() {
|
if (mIsExpanded) {
|
requestUpdate();
|
}
|
}
|
|
/** Sets whether all bubbles in the stack should not show the 'new' dot. */
|
void setSuppressNewDot(boolean suppressNewDot) {
|
mSuppressNewDot = suppressNewDot;
|
|
for (int i = 0; i < mBubbleContainer.getChildCount(); i++) {
|
BubbleView bv = (BubbleView) mBubbleContainer.getChildAt(i);
|
bv.setSuppressDot(suppressNewDot, true /* animate */);
|
}
|
}
|
|
/**
|
* Sets whether the flyout should not appear, even if the notif otherwise would generate one.
|
*/
|
void setSuppressFlyout(boolean suppressFlyout) {
|
mSuppressFlyout = suppressFlyout;
|
}
|
|
/**
|
* Callback to run after the flyout hides. Also called if a new flyout is shown before the
|
* previous one animates out.
|
*/
|
private Runnable mAfterFlyoutHides;
|
|
/**
|
* Animates in the flyout for the given bubble, if available, and then hides it after some time.
|
*/
|
@VisibleForTesting
|
void animateInFlyoutForBubble(Bubble bubble) {
|
final CharSequence updateMessage = bubble.entry.getUpdateMessage(getContext());
|
|
// Show the message if one exists, and we're not expanded or animating expansion.
|
if (updateMessage != null
|
&& !isExpanded()
|
&& !mIsExpansionAnimating
|
&& !mIsGestureInProgress
|
&& !mSuppressFlyout) {
|
if (bubble.iconView != null) {
|
// Temporarily suppress the dot while the flyout is visible.
|
bubble.iconView.setSuppressDot(
|
true /* suppressDot */, false /* animate */);
|
|
mFlyoutDragDeltaX = 0f;
|
mFlyout.setAlpha(0f);
|
|
if (mAfterFlyoutHides != null) {
|
mAfterFlyoutHides.run();
|
}
|
|
mAfterFlyoutHides = () -> {
|
if (bubble.iconView == null) {
|
return;
|
}
|
|
// If we're going to suppress the dot, make it visible first so it'll
|
// visibly animate away.
|
if (mSuppressNewDot) {
|
bubble.iconView.setSuppressDot(
|
false /* suppressDot */, false /* animate */);
|
}
|
|
// Reset dot suppression. If we're not suppressing due to DND, then
|
// stop suppressing it with no animation (since the flyout has
|
// transformed into the dot). If we are suppressing due to DND, animate
|
// it away.
|
bubble.iconView.setSuppressDot(
|
mSuppressNewDot /* suppressDot */,
|
mSuppressNewDot /* animate */);
|
};
|
|
// Post in case layout isn't complete and getWidth returns 0.
|
post(() -> {
|
// An auto-expanding bubble could have been posted during the time it takes to
|
// layout.
|
if (isExpanded()) {
|
return;
|
}
|
|
mFlyout.showFlyout(
|
updateMessage, mStackAnimationController.getStackPosition(), getWidth(),
|
mStackAnimationController.isStackOnLeftSide(),
|
bubble.iconView.getBadgeColor(), mAfterFlyoutHides);
|
});
|
}
|
|
mFlyout.removeCallbacks(mHideFlyout);
|
mFlyout.postDelayed(mHideFlyout, FLYOUT_HIDE_AFTER);
|
logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__FLYOUT);
|
}
|
}
|
|
/** Hide the flyout immediately and cancel any pending hide runnables. */
|
private void hideFlyoutImmediate() {
|
if (mAfterFlyoutHides != null) {
|
mAfterFlyoutHides.run();
|
}
|
|
mFlyout.removeCallbacks(mHideFlyout);
|
mFlyout.hideFlyout();
|
}
|
|
@Override
|
public void getBoundsOnScreen(Rect outRect) {
|
if (!mIsExpanded) {
|
if (mBubbleContainer.getChildCount() > 0) {
|
mBubbleContainer.getChildAt(0).getBoundsOnScreen(outRect);
|
}
|
} else {
|
mBubbleContainer.getBoundsOnScreen(outRect);
|
}
|
|
if (mFlyout.getVisibility() == View.VISIBLE) {
|
final Rect flyoutBounds = new Rect();
|
mFlyout.getBoundsOnScreen(flyoutBounds);
|
outRect.union(flyoutBounds);
|
}
|
}
|
|
private int getStatusBarHeight() {
|
if (getRootWindowInsets() != null) {
|
WindowInsets insets = getRootWindowInsets();
|
return Math.max(
|
mStatusBarHeight,
|
insets.getDisplayCutout() != null
|
? insets.getDisplayCutout().getSafeInsetTop()
|
: 0);
|
}
|
|
return 0;
|
}
|
|
private int getBottomInset() {
|
if (getRootWindowInsets() != null) {
|
WindowInsets insets = getRootWindowInsets();
|
return insets.getSystemWindowInsetBottom();
|
}
|
return 0;
|
}
|
|
private boolean isIntersecting(View view, float x, float y) {
|
mTempLoc = view.getLocationOnScreen();
|
mTempRect.set(mTempLoc[0], mTempLoc[1], mTempLoc[0] + view.getWidth(),
|
mTempLoc[1] + view.getHeight());
|
return mTempRect.contains(x, y);
|
}
|
|
private void requestUpdate() {
|
if (mViewUpdatedRequested || mIsExpansionAnimating) {
|
return;
|
}
|
mViewUpdatedRequested = true;
|
getViewTreeObserver().addOnPreDrawListener(mViewUpdater);
|
invalidate();
|
}
|
|
private void updateExpandedBubble() {
|
if (DEBUG) {
|
Log.d(TAG, "updateExpandedBubble()");
|
}
|
mExpandedViewContainer.removeAllViews();
|
if (mExpandedBubble != null && mIsExpanded) {
|
mExpandedViewContainer.addView(mExpandedBubble.expandedView);
|
mExpandedBubble.expandedView.populateExpandedView();
|
mExpandedViewContainer.setVisibility(mIsExpanded ? VISIBLE : GONE);
|
mExpandedViewContainer.setAlpha(1.0f);
|
}
|
}
|
|
private void applyCurrentState() {
|
if (DEBUG) {
|
Log.d(TAG, "applyCurrentState: mIsExpanded=" + mIsExpanded);
|
}
|
|
mExpandedViewContainer.setVisibility(mIsExpanded ? VISIBLE : GONE);
|
if (mIsExpanded) {
|
// First update the view so that it calculates a new height (ensuring the y position
|
// calculation is correct)
|
mExpandedBubble.expandedView.updateView();
|
final float y = getYPositionForExpandedView();
|
if (!mExpandedViewYAnim.isRunning()) {
|
// We're not animating so set the value
|
mExpandedViewContainer.setTranslationY(y);
|
mExpandedBubble.expandedView.updateView();
|
} else {
|
// We are animating so update the value; there is an end listener on the animator
|
// that will ensure expandedeView.updateView gets called.
|
mExpandedViewYAnim.animateToFinalPosition(y);
|
}
|
}
|
|
mStackOnLeftOrWillBe = mStackAnimationController.isStackOnLeftSide();
|
updateBubbleShadowsAndDotPosition(false);
|
}
|
|
/** Sets the appropriate Z-order and dot position for each bubble in the stack. */
|
private void updateBubbleShadowsAndDotPosition(boolean animate) {
|
int bubbsCount = mBubbleContainer.getChildCount();
|
for (int i = 0; i < bubbsCount; i++) {
|
BubbleView bv = (BubbleView) mBubbleContainer.getChildAt(i);
|
bv.updateDotVisibility(true /* animate */);
|
bv.setZ((BubbleController.MAX_BUBBLES
|
* getResources().getDimensionPixelSize(R.dimen.bubble_elevation)) - i);
|
|
// Draw the shadow around the circle inscribed within the bubble's bounds. This
|
// (intentionally) does not draw a shadow behind the update dot, which should be drawing
|
// its own shadow since it's on a different (higher) plane.
|
bv.setOutlineProvider(new ViewOutlineProvider() {
|
@Override
|
public void getOutline(View view, Outline outline) {
|
outline.setOval(0, 0, mBubbleSize, mBubbleSize);
|
}
|
});
|
bv.setClipToOutline(false);
|
|
// If the dot is on the left, and so is the stack, we need to change the dot position.
|
if (bv.getDotPositionOnLeft() == mStackOnLeftOrWillBe) {
|
bv.setDotPosition(!mStackOnLeftOrWillBe, animate);
|
}
|
}
|
}
|
|
private void updatePointerPosition() {
|
if (DEBUG) {
|
Log.d(TAG, "updatePointerPosition()");
|
}
|
|
Bubble expandedBubble = getExpandedBubble();
|
if (expandedBubble == null) {
|
return;
|
}
|
|
int index = getBubbleIndex(expandedBubble);
|
float bubbleLeftFromScreenLeft = mExpandedAnimationController.getBubbleLeft(index);
|
float halfBubble = mBubbleSize / 2f;
|
|
// Bubbles live in expanded view container (x includes expanded view padding).
|
// Pointer lives in expanded view, which has padding (x does not include padding).
|
// Remove padding when deriving pointer location from bubbles.
|
float bubbleCenter = bubbleLeftFromScreenLeft + halfBubble - mExpandedViewPadding;
|
|
expandedBubble.expandedView.setPointerPosition(bubbleCenter);
|
}
|
|
/**
|
* @return the number of bubbles in the stack view.
|
*/
|
public int getBubbleCount() {
|
return mBubbleContainer.getChildCount();
|
}
|
|
/**
|
* Finds the bubble index within the stack.
|
*
|
* @param bubble the bubble to look up.
|
* @return the index of the bubble view within the bubble stack. The range of the position
|
* is between 0 and the bubble count minus 1.
|
*/
|
int getBubbleIndex(@Nullable Bubble bubble) {
|
if (bubble == null) {
|
return 0;
|
}
|
return mBubbleContainer.indexOfChild(bubble.iconView);
|
}
|
|
/**
|
* @return the normalized x-axis position of the bubble stack rounded to 4 decimal places.
|
*/
|
public float getNormalizedXPosition() {
|
return new BigDecimal(getStackPosition().x / mDisplaySize.x)
|
.setScale(4, RoundingMode.CEILING.HALF_UP)
|
.floatValue();
|
}
|
|
/**
|
* @return the normalized y-axis position of the bubble stack rounded to 4 decimal places.
|
*/
|
public float getNormalizedYPosition() {
|
return new BigDecimal(getStackPosition().y / mDisplaySize.y)
|
.setScale(4, RoundingMode.CEILING.HALF_UP)
|
.floatValue();
|
}
|
|
public PointF getStackPosition() {
|
return mStackAnimationController.getStackPosition();
|
}
|
|
/**
|
* Logs the bubble UI event.
|
*
|
* @param bubble the bubble that is being interacted on. Null value indicates that
|
* the user interaction is not specific to one bubble.
|
* @param action the user interaction enum.
|
*/
|
private void logBubbleEvent(@Nullable Bubble bubble, int action) {
|
if (bubble == null || bubble.entry == null
|
|| bubble.entry.notification == null) {
|
StatsLog.write(StatsLog.BUBBLE_UI_CHANGED,
|
null /* package name */,
|
null /* notification channel */,
|
0 /* notification ID */,
|
0 /* bubble position */,
|
getBubbleCount(),
|
action,
|
getNormalizedXPosition(),
|
getNormalizedYPosition(),
|
false /* unread bubble */,
|
false /* on-going bubble */,
|
false /* foreground bubble */);
|
} else {
|
StatusBarNotification notification = bubble.entry.notification;
|
StatsLog.write(StatsLog.BUBBLE_UI_CHANGED,
|
notification.getPackageName(),
|
notification.getNotification().getChannelId(),
|
notification.getId(),
|
getBubbleIndex(bubble),
|
getBubbleCount(),
|
action,
|
getNormalizedXPosition(),
|
getNormalizedYPosition(),
|
bubble.entry.showInShadeWhenBubble(),
|
bubble.entry.isForegroundService(),
|
BubbleController.isForegroundApp(mContext, notification.getPackageName()));
|
}
|
}
|
|
/**
|
* Called when a back gesture should be directed to the Bubbles stack. When expanded,
|
* a back key down/up event pair is forwarded to the bubble Activity.
|
*/
|
boolean performBackPressIfNeeded() {
|
if (!isExpanded()) {
|
return false;
|
}
|
return mExpandedBubble.expandedView.performBackPressIfNeeded();
|
}
|
|
/** For debugging only */
|
List<Bubble> getBubblesOnScreen() {
|
List<Bubble> bubbles = new ArrayList<>();
|
for (int i = 0; i < mBubbleContainer.getChildCount(); i++) {
|
View child = mBubbleContainer.getChildAt(i);
|
if (child instanceof BubbleView) {
|
String key = ((BubbleView) child).getKey();
|
Bubble bubble = mBubbleData.getBubbleWithKey(key);
|
bubbles.add(bubble);
|
}
|
}
|
return bubbles;
|
}
|
}
|
