package com.android.systemui.statusbar.phone;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.SystemClock;
import android.os.VibrationEffect;
import android.util.AttributeSet;
import android.util.Log;
import android.view.InputDevice;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewTreeObserver;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.util.LatencyTracker;
import com.android.systemui.DejankUtils;
import com.android.systemui.Dependency;
import com.android.systemui.Interpolators;
import com.android.systemui.R;
import com.android.systemui.classifier.FalsingManager;
import com.android.systemui.doze.DozeLog;
import com.android.systemui.statusbar.FlingAnimationUtils;
import com.android.systemui.statusbar.StatusBarState;
import com.android.systemui.statusbar.VibratorHelper;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.function.BiConsumer;
public abstract class PanelView extends FrameLayout {
public static final boolean DEBUG = PanelBar.DEBUG;
public static final String TAG = PanelView.class.getSimpleName();
private static final int INITIAL_OPENING_PEEK_DURATION = 200;
private static final int PEEK_ANIMATION_DURATION = 360;
private static final int NO_FIXED_DURATION = -1;
private long mDownTime;
private float mMinExpandHeight;
private LockscreenGestureLogger mLockscreenGestureLogger = new LockscreenGestureLogger();
private boolean mPanelUpdateWhenAnimatorEnds;
private boolean mVibrateOnOpening;
protected boolean mLaunchingNotification;
private int mFixedDuration = NO_FIXED_DURATION;
private BiConsumer<Float, Boolean> mExpansionListener;
private final void logf(String fmt, Object... args) {
Log.v(TAG, (mViewName != null ? (mViewName + ": ") : "") + String.format(fmt, args));
}
protected StatusBar mStatusBar;
protected HeadsUpManagerPhone mHeadsUpManager;
private float mPeekHeight;
private float mHintDistance;
private float mInitialOffsetOnTouch;
private boolean mCollapsedAndHeadsUpOnDown;
private float mExpandedFraction = 0;
protected float mExpandedHeight = 0;
private boolean mPanelClosedOnDown;
private boolean mHasLayoutedSinceDown;
private float mUpdateFlingVelocity;
private boolean mUpdateFlingOnLayout;
private boolean mPeekTouching;
private boolean mJustPeeked;
private boolean mClosing;
protected boolean mTracking;
private boolean mTouchSlopExceeded;
private int mTrackingPointer;
protected int mTouchSlop;
protected boolean mHintAnimationRunning;
private boolean mOverExpandedBeforeFling;
private boolean mTouchAboveFalsingThreshold;
private int mUnlockFalsingThreshold;
private boolean mTouchStartedInEmptyArea;
private boolean mMotionAborted;
private boolean mUpwardsWhenTresholdReached;
private boolean mAnimatingOnDown;
private ValueAnimator mHeightAnimator;
private ObjectAnimator mPeekAnimator;
private VelocityTrackerInterface mVelocityTracker;
private FlingAnimationUtils mFlingAnimationUtils;
private FlingAnimationUtils mFlingAnimationUtilsClosing;
private FlingAnimationUtils mFlingAnimationUtilsDismissing;
private FalsingManager mFalsingManager;
private final VibratorHelper mVibratorHelper;
private boolean mInstantExpanding;
private boolean mAnimateAfterExpanding;
PanelBar mBar;
private String mViewName;
private float mInitialTouchY;
private float mInitialTouchX;
private boolean mTouchDisabled;
private boolean mNotificationsDragEnabled;
private Interpolator mBounceInterpolator;
protected KeyguardBottomAreaView mKeyguardBottomArea;
private float mNextCollapseSpeedUpFactor = 1.0f;
protected boolean mExpanding;
private boolean mGestureWaitForTouchSlop;
private boolean mIgnoreXTouchSlop;
private boolean mExpandLatencyTracking;
protected void onExpandingFinished() {
mBar.onExpandingFinished();
}
protected void onExpandingStarted() {
}
private void notifyExpandingStarted() {
if (!mExpanding) {
mExpanding = true;
onExpandingStarted();
}
}
protected final void notifyExpandingFinished() {
endClosing();
if (mExpanding) {
mExpanding = false;
onExpandingFinished();
}
}
private void runPeekAnimation(long duration, float peekHeight, boolean collapseWhenFinished) {
mPeekHeight = peekHeight;
if (DEBUG) logf("peek to height=%.1f", mPeekHeight);
if (mHeightAnimator != null) {
return;
}
if (mPeekAnimator != null) {
mPeekAnimator.cancel();
}
mPeekAnimator = ObjectAnimator.ofFloat(this, "expandedHeight", mPeekHeight)
.setDuration(duration);
mPeekAnimator.setInterpolator(Interpolators.LINEAR_OUT_SLOW_IN);
mPeekAnimator.addListener(new AnimatorListenerAdapter() {
private boolean mCancelled;
@Override
public void onAnimationCancel(Animator animation) {
mCancelled = true;
}
@Override
public void onAnimationEnd(Animator animation) {
mPeekAnimator = null;
if (!mCancelled && collapseWhenFinished) {
postOnAnimation(mPostCollapseRunnable);
}
}
});
notifyExpandingStarted();
mPeekAnimator.start();
mJustPeeked = true;
}
public PanelView(Context context, AttributeSet attrs) {
super(context, attrs);
mFlingAnimationUtils = new FlingAnimationUtils(context, 0.6f ,
0.6f );
mFlingAnimationUtilsClosing = new FlingAnimationUtils(context, 0.5f ,
0.6f );
mFlingAnimationUtilsDismissing = new FlingAnimationUtils(context,
0.5f , 0.2f , 0.6f ,
0.84f );
mBounceInterpolator = new BounceInterpolator();
mFalsingManager = FalsingManager.getInstance(context);
mNotificationsDragEnabled =
getResources().getBoolean(R.bool.config_enableNotificationShadeDrag);
mVibratorHelper = Dependency.get(VibratorHelper.class);
mVibrateOnOpening = mContext.getResources().getBoolean(
R.bool.config_vibrateOnIconAnimation);
}
protected void loadDimens() {
final Resources res = getContext().getResources();
final ViewConfiguration configuration = ViewConfiguration.get(getContext());
mTouchSlop = configuration.getScaledTouchSlop();
mHintDistance = res.getDimension(R.dimen.hint_move_distance);
mUnlockFalsingThreshold = res.getDimensionPixelSize(R.dimen.unlock_falsing_threshold);
}
private void trackMovement(MotionEvent event) {
float deltaX = event.getRawX() - event.getX();
float deltaY = event.getRawY() - event.getY();
event.offsetLocation(deltaX, deltaY);
if (mVelocityTracker != null) mVelocityTracker.addMovement(event);
event.offsetLocation(-deltaX, -deltaY);
}
public void setTouchDisabled(boolean disabled) {
mTouchDisabled = disabled;
if (mTouchDisabled) {
cancelHeightAnimator();
if (mTracking) {
onTrackingStopped(true );
}
notifyExpandingFinished();
}
}
public void startExpandLatencyTracking() {
if (LatencyTracker.isEnabled(mContext)) {
LatencyTracker.getInstance(mContext).onActionStart(
LatencyTracker.ACTION_EXPAND_PANEL);
mExpandLatencyTracking = true;
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (mInstantExpanding
|| (mTouchDisabled && event.getActionMasked() != MotionEvent.ACTION_CANCEL)
|| (mMotionAborted && event.getActionMasked() != MotionEvent.ACTION_DOWN)) {
return false;
}
if (!mNotificationsDragEnabled) {
if (mTracking) {
onTrackingStopped(true );
}
return false;
}
if (isFullyCollapsed() && event.isFromSource(InputDevice.SOURCE_MOUSE)) {
if (event.getAction() == MotionEvent.ACTION_UP) {
expand(true);
}
return true;
}
int pointerIndex = event.findPointerIndex(mTrackingPointer);
if (pointerIndex < 0) {
pointerIndex = 0;
mTrackingPointer = event.getPointerId(pointerIndex);
}
final float x = event.getX(pointerIndex);
final float y = event.getY(pointerIndex);
if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
mGestureWaitForTouchSlop = isFullyCollapsed() || hasConflictingGestures();
mIgnoreXTouchSlop = isFullyCollapsed() || shouldGestureIgnoreXTouchSlop(x, y);
}
switch (event.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
startExpandMotion(x, y, false , mExpandedHeight);
mJustPeeked = false;
mMinExpandHeight = 0.0f;
mPanelClosedOnDown = isFullyCollapsed();
mHasLayoutedSinceDown = false;
mUpdateFlingOnLayout = false;
mMotionAborted = false;
mPeekTouching = mPanelClosedOnDown;
mDownTime = SystemClock.uptimeMillis();
mTouchAboveFalsingThreshold = false;
mCollapsedAndHeadsUpOnDown = isFullyCollapsed()
&& mHeadsUpManager.hasPinnedHeadsUp();
if (mVelocityTracker == null) {
initVelocityTracker();
}
trackMovement(event);
if (!mGestureWaitForTouchSlop || (mHeightAnimator != null && !mHintAnimationRunning)
|| mPeekAnimator != null) {
mTouchSlopExceeded = (mHeightAnimator != null && !mHintAnimationRunning)
|| mPeekAnimator != null;
cancelHeightAnimator();
cancelPeek();
onTrackingStarted();
}
if (isFullyCollapsed() && !mHeadsUpManager.hasPinnedHeadsUp()
&& !mStatusBar.isBouncerShowing()) {
startOpening(event);
}
break;
case MotionEvent.ACTION_POINTER_UP:
final int upPointer = event.getPointerId(event.getActionIndex());
if (mTrackingPointer == upPointer) {
final int newIndex = event.getPointerId(0) != upPointer ? 0 : 1;
final float newY = event.getY(newIndex);
final float newX = event.getX(newIndex);
mTrackingPointer = event.getPointerId(newIndex);
startExpandMotion(newX, newY, true , mExpandedHeight);
}
break;
case MotionEvent.ACTION_POINTER_DOWN:
if (mStatusBar.getBarState() == StatusBarState.KEYGUARD) {
mMotionAborted = true;
endMotionEvent(event, x, y, true );
return false;
}
break;
case MotionEvent.ACTION_MOVE:
trackMovement(event);
float h = y - mInitialTouchY;
if (Math.abs(h) > mTouchSlop
&& (Math.abs(h) > Math.abs(x - mInitialTouchX)
|| mIgnoreXTouchSlop)) {
mTouchSlopExceeded = true;
if (mGestureWaitForTouchSlop && !mTracking && !mCollapsedAndHeadsUpOnDown) {
if (!mJustPeeked && mInitialOffsetOnTouch != 0f) {
startExpandMotion(x, y, false , mExpandedHeight);
h = 0;
}
cancelHeightAnimator();
onTrackingStarted();
}
}
float newHeight = Math.max(0, h + mInitialOffsetOnTouch);
if (newHeight > mPeekHeight) {
if (mPeekAnimator != null) {
mPeekAnimator.cancel();
}
mJustPeeked = false;
} else if (mPeekAnimator == null && mJustPeeked) {
mInitialOffsetOnTouch = mExpandedHeight;
mInitialTouchY = y;
mMinExpandHeight = mExpandedHeight;
mJustPeeked = false;
}
newHeight = Math.max(newHeight, mMinExpandHeight);
if (-h >= getFalsingThreshold()) {
mTouchAboveFalsingThreshold = true;
mUpwardsWhenTresholdReached = isDirectionUpwards(x, y);
}
if (!mJustPeeked && (!mGestureWaitForTouchSlop || mTracking) &&
!isTrackingBlocked()) {
setExpandedHeightInternal(newHeight);
}
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL:
trackMovement(event);
endMotionEvent(event, x, y, false );
break;
}
return !mGestureWaitForTouchSlop || mTracking;
}
private void startOpening(MotionEvent event) {
runPeekAnimation(INITIAL_OPENING_PEEK_DURATION, getOpeningHeight(),
false );
notifyBarPanelExpansionChanged();
if (mVibrateOnOpening) {
mVibratorHelper.vibrate(VibrationEffect.EFFECT_TICK);
}
float width = mStatusBar.getDisplayWidth();
float height = mStatusBar.getDisplayHeight();
int rot = mStatusBar.getRotation();
mLockscreenGestureLogger.writeAtFractionalPosition(MetricsEvent.ACTION_PANEL_VIEW_EXPAND,
(int) (event.getX() / width * 100),
(int) (event.getY() / height * 100),
rot);
}
protected abstract float getOpeningHeight();
private boolean isDirectionUpwards(float x, float y) {
float xDiff = x - mInitialTouchX;
float yDiff = y - mInitialTouchY;
if (yDiff >= 0) {
return false;
}
return Math.abs(yDiff) >= Math.abs(xDiff);
}
protected void startExpandingFromPeek() {
mStatusBar.handlePeekToExpandTransistion();
}
protected void startExpandMotion(float newX, float newY, boolean startTracking,
float expandedHeight) {
mInitialOffsetOnTouch = expandedHeight;
mInitialTouchY = newY;
mInitialTouchX = newX;
if (startTracking) {
mTouchSlopExceeded = true;
setExpandedHeight(mInitialOffsetOnTouch);
onTrackingStarted();
}
}
private void endMotionEvent(MotionEvent event, float x, float y, boolean forceCancel) {
mTrackingPointer = -1;
if ((mTracking && mTouchSlopExceeded)
|| Math.abs(x - mInitialTouchX) > mTouchSlop
|| Math.abs(y - mInitialTouchY) > mTouchSlop
|| event.getActionMasked() == MotionEvent.ACTION_CANCEL
|| forceCancel) {
float vel = 0f;
float vectorVel = 0f;
if (mVelocityTracker != null) {
mVelocityTracker.computeCurrentVelocity(1000);
vel = mVelocityTracker.getYVelocity();
vectorVel = (float) Math.hypot(
mVelocityTracker.getXVelocity(), mVelocityTracker.getYVelocity());
}
boolean expand = flingExpands(vel, vectorVel, x, y)
|| event.getActionMasked() == MotionEvent.ACTION_CANCEL
|| forceCancel;
DozeLog.traceFling(expand, mTouchAboveFalsingThreshold,
mStatusBar.isFalsingThresholdNeeded(),
mStatusBar.isWakeUpComingFromTouch());
if (!expand && mStatusBar.getBarState() == StatusBarState.KEYGUARD) {
float displayDensity = mStatusBar.getDisplayDensity();
int heightDp = (int) Math.abs((y - mInitialTouchY) / displayDensity);
int velocityDp = (int) Math.abs(vel / displayDensity);
mLockscreenGestureLogger.write(
MetricsEvent.ACTION_LS_UNLOCK,
heightDp, velocityDp);
}
fling(vel, expand, isFalseTouch(x, y));
onTrackingStopped(expand);
mUpdateFlingOnLayout = expand && mPanelClosedOnDown && !mHasLayoutedSinceDown;
if (mUpdateFlingOnLayout) {
mUpdateFlingVelocity = vel;
}
} else if (mPanelClosedOnDown && !mHeadsUpManager.hasPinnedHeadsUp() && !mTracking
&& !mStatusBar.isBouncerShowing() && !mStatusBar.isKeyguardFadingAway()) {
long timePassed = SystemClock.uptimeMillis() - mDownTime;
if (timePassed < ViewConfiguration.getLongPressTimeout()) {
runPeekAnimation(PEEK_ANIMATION_DURATION, getPeekHeight(), true );
} else {
postOnAnimation(mPostCollapseRunnable);
}
} else if (!mStatusBar.isBouncerShowing()) {
boolean expands = onEmptySpaceClick(mInitialTouchX);
onTrackingStopped(expands);
}
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
mPeekTouching = false;
}
protected float getCurrentExpandVelocity() {
if (mVelocityTracker == null) {
return 0;
}
mVelocityTracker.computeCurrentVelocity(1000);
return mVelocityTracker.getYVelocity();
}
private int getFalsingThreshold() {
float factor = mStatusBar.isWakeUpComingFromTouch() ? 1.5f : 1.0f;
return (int) (mUnlockFalsingThreshold * factor);
}
protected abstract boolean hasConflictingGestures();
protected abstract boolean shouldGestureIgnoreXTouchSlop(float x, float y);
protected void onTrackingStopped(boolean expand) {
mTracking = false;
mBar.onTrackingStopped(expand);
notifyBarPanelExpansionChanged();
}
protected void onTrackingStarted() {
endClosing();
mTracking = true;
mBar.onTrackingStarted();
notifyExpandingStarted();
notifyBarPanelExpansionChanged();
}
@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
if (mInstantExpanding || !mNotificationsDragEnabled || mTouchDisabled
|| (mMotionAborted && event.getActionMasked() != MotionEvent.ACTION_DOWN)) {
return false;
}
int pointerIndex = event.findPointerIndex(mTrackingPointer);
if (pointerIndex < 0) {
pointerIndex = 0;
mTrackingPointer = event.getPointerId(pointerIndex);
}
final float x = event.getX(pointerIndex);
final float y = event.getY(pointerIndex);
boolean scrolledToBottom = isScrolledToBottom();
switch (event.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
mStatusBar.userActivity();
mAnimatingOnDown = mHeightAnimator != null;
mMinExpandHeight = 0.0f;
mDownTime = SystemClock.uptimeMillis();
if (mAnimatingOnDown && mClosing && !mHintAnimationRunning
|| mPeekAnimator != null) {
cancelHeightAnimator();
cancelPeek();
mTouchSlopExceeded = true;
return true;
}
mInitialTouchY = y;
mInitialTouchX = x;
mTouchStartedInEmptyArea = !isInContentBounds(x, y);
mTouchSlopExceeded = false;
mJustPeeked = false;
mMotionAborted = false;
mPanelClosedOnDown = isFullyCollapsed();
mCollapsedAndHeadsUpOnDown = false;
mHasLayoutedSinceDown = false;
mUpdateFlingOnLayout = false;
mTouchAboveFalsingThreshold = false;
initVelocityTracker();
trackMovement(event);
break;
case MotionEvent.ACTION_POINTER_UP:
final int upPointer = event.getPointerId(event.getActionIndex());
if (mTrackingPointer == upPointer) {
final int newIndex = event.getPointerId(0) != upPointer ? 0 : 1;
mTrackingPointer = event.getPointerId(newIndex);
mInitialTouchX = event.getX(newIndex);
mInitialTouchY = event.getY(newIndex);
}
break;
case MotionEvent.ACTION_POINTER_DOWN:
if (mStatusBar.getBarState() == StatusBarState.KEYGUARD) {
mMotionAborted = true;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
}
break;
case MotionEvent.ACTION_MOVE:
final float h = y - mInitialTouchY;
trackMovement(event);
if (scrolledToBottom || mTouchStartedInEmptyArea || mAnimatingOnDown) {
float hAbs = Math.abs(h);
if ((h < -mTouchSlop || (mAnimatingOnDown && hAbs > mTouchSlop))
&& hAbs > Math.abs(x - mInitialTouchX)) {
cancelHeightAnimator();
startExpandMotion(x, y, true , mExpandedHeight);
return true;
}
}
break;
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
break;
}
return false;
}
protected abstract boolean isInContentBounds(float x, float y);
protected void cancelHeightAnimator() {
if (mHeightAnimator != null) {
if (mHeightAnimator.isRunning()) {
mPanelUpdateWhenAnimatorEnds = false;
}
mHeightAnimator.cancel();
}
endClosing();
}
private void endClosing() {
if (mClosing) {
mClosing = false;
onClosingFinished();
}
}
private void initVelocityTracker() {
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
}
mVelocityTracker = VelocityTrackerFactory.obtain(getContext());
}
protected boolean isScrolledToBottom() {
return true;
}
protected float getContentHeight() {
return mExpandedHeight;
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
loadDimens();
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
loadDimens();
}
protected boolean flingExpands(float vel, float vectorVel, float x, float y) {
if (isFalseTouch(x, y)) {
return true;
}
if (Math.abs(vectorVel) < mFlingAnimationUtils.getMinVelocityPxPerSecond()) {
return getExpandedFraction() > 0.5f;
} else {
return vel > 0;
}
}
private boolean isFalseTouch(float x, float y) {
if (!mStatusBar.isFalsingThresholdNeeded()) {
return false;
}
if (mFalsingManager.isClassiferEnabled()) {
return mFalsingManager.isFalseTouch();
}
if (!mTouchAboveFalsingThreshold) {
return true;
}
if (mUpwardsWhenTresholdReached) {
return false;
}
return !isDirectionUpwards(x, y);
}
protected void fling(float vel, boolean expand) {
fling(vel, expand, 1.0f , false);
}
protected void fling(float vel, boolean expand, boolean expandBecauseOfFalsing) {
fling(vel, expand, 1.0f , expandBecauseOfFalsing);
}
protected void fling(float vel, boolean expand, float collapseSpeedUpFactor,
boolean expandBecauseOfFalsing) {
cancelPeek();
float target = expand ? getMaxPanelHeight() : 0;
if (!expand) {
mClosing = true;
}
flingToHeight(vel, expand, target, collapseSpeedUpFactor, expandBecauseOfFalsing);
}
protected void flingToHeight(float vel, boolean expand, float target,
float collapseSpeedUpFactor, boolean expandBecauseOfFalsing) {
final boolean clearAllExpandHack = expand && fullyExpandedClearAllVisible()
&& mExpandedHeight < getMaxPanelHeight() - getClearAllHeight()
&& !isClearAllVisible();
if (clearAllExpandHack) {
target = getMaxPanelHeight() - getClearAllHeight();
}
if (target == mExpandedHeight || getOverExpansionAmount() > 0f && expand) {
notifyExpandingFinished();
return;
}
mOverExpandedBeforeFling = getOverExpansionAmount() > 0f;
ValueAnimator animator = createHeightAnimator(target);
if (expand) {
if (expandBecauseOfFalsing && vel < 0) {
vel = 0;
}
mFlingAnimationUtils.apply(animator, mExpandedHeight, target, vel, getHeight());
if (vel == 0) {
animator.setDuration(350);
}
} else {
if (shouldUseDismissingAnimation()) {
if (vel == 0) {
animator.setInterpolator(Interpolators.PANEL_CLOSE_ACCELERATED);
long duration = (long) (200 + mExpandedHeight / getHeight() * 100);
animator.setDuration(duration);
} else {
mFlingAnimationUtilsDismissing.apply(animator, mExpandedHeight, target, vel,
getHeight());
}
} else {
mFlingAnimationUtilsClosing
.apply(animator, mExpandedHeight, target, vel, getHeight());
}
if (vel == 0) {
animator.setDuration((long) (animator.getDuration() / collapseSpeedUpFactor));
}
if (mFixedDuration != NO_FIXED_DURATION) {
animator.setDuration(mFixedDuration);
}
}
animator.addListener(new AnimatorListenerAdapter() {
private boolean mCancelled;
@Override
public void onAnimationCancel(Animator animation) {
mCancelled = true;
}
@Override
public void onAnimationEnd(Animator animation) {
if (clearAllExpandHack && !mCancelled) {
setExpandedHeightInternal(getMaxPanelHeight());
}
setAnimator(null);
if (!mCancelled) {
notifyExpandingFinished();
}
notifyBarPanelExpansionChanged();
}
});
setAnimator(animator);
animator.start();
}
protected abstract boolean shouldUseDismissingAnimation();
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
mViewName = getResources().getResourceName(getId());
}
public String getName() {
return mViewName;
}
public void setExpandedHeight(float height) {
if (DEBUG) logf("setExpandedHeight(%.1f)", height);
setExpandedHeightInternal(height + getOverExpansionPixels());
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
mStatusBar.onPanelLaidOut();
requestPanelHeightUpdate();
mHasLayoutedSinceDown = true;
if (mUpdateFlingOnLayout) {
abortAnimations();
fling(mUpdateFlingVelocity, true );
mUpdateFlingOnLayout = false;
}
}
protected void requestPanelHeightUpdate() {
float currentMaxPanelHeight = getMaxPanelHeight();
if (isFullyCollapsed()) {
return;
}
if (currentMaxPanelHeight == mExpandedHeight) {
return;
}
if (mPeekAnimator != null || mPeekTouching) {
return;
}
if (mTracking && !isTrackingBlocked()) {
return;
}
if (mHeightAnimator != null) {
mPanelUpdateWhenAnimatorEnds = true;
return;
}
setExpandedHeight(currentMaxPanelHeight);
}
public void setExpandedHeightInternal(float h) {
if (mExpandLatencyTracking && h != 0f) {
DejankUtils.postAfterTraversal(() -> LatencyTracker.getInstance(mContext).onActionEnd(
LatencyTracker.ACTION_EXPAND_PANEL));
mExpandLatencyTracking = false;
}
float fhWithoutOverExpansion = getMaxPanelHeight() - getOverExpansionAmount();
if (mHeightAnimator == null) {
float overExpansionPixels = Math.max(0, h - fhWithoutOverExpansion);
if (getOverExpansionPixels() != overExpansionPixels && mTracking) {
setOverExpansion(overExpansionPixels, true );
}
mExpandedHeight = Math.min(h, fhWithoutOverExpansion) + getOverExpansionAmount();
} else {
mExpandedHeight = h;
if (mOverExpandedBeforeFling) {
setOverExpansion(Math.max(0, h - fhWithoutOverExpansion), false );
}
}
if (mExpandedHeight < 1f && mExpandedHeight != 0f && mClosing) {
mExpandedHeight = 0f;
if (mHeightAnimator != null) {
mHeightAnimator.end();
}
}
mExpandedFraction = Math.min(1f,
fhWithoutOverExpansion == 0 ? 0 : mExpandedHeight / fhWithoutOverExpansion);
onHeightUpdated(mExpandedHeight);
notifyBarPanelExpansionChanged();
}
protected abstract boolean isTrackingBlocked();
protected abstract void setOverExpansion(float overExpansion, boolean isPixels);
protected abstract void onHeightUpdated(float expandedHeight);
protected abstract float getOverExpansionAmount();
protected abstract float getOverExpansionPixels();
protected abstract int getMaxPanelHeight();
public void setExpandedFraction(float frac) {
setExpandedHeight(getMaxPanelHeight() * frac);
}
public float getExpandedHeight() {
return mExpandedHeight;
}
public float getExpandedFraction() {
return mExpandedFraction;
}
public boolean isFullyExpanded() {
return mExpandedHeight >= getMaxPanelHeight();
}
public boolean isFullyCollapsed() {
return mExpandedFraction <= 0.0f;
}
public boolean isCollapsing() {
return mClosing || mLaunchingNotification;
}
public boolean isTracking() {
return mTracking;
}
public void setBar(PanelBar panelBar) {
mBar = panelBar;
}
public void collapse(boolean delayed, float speedUpFactor) {
if (DEBUG) logf("collapse: " + this);
if (canPanelBeCollapsed()) {
cancelHeightAnimator();
notifyExpandingStarted();
mClosing = true;
if (delayed) {
mNextCollapseSpeedUpFactor = speedUpFactor;
postDelayed(mFlingCollapseRunnable, 120);
} else {
fling(0, false , speedUpFactor, false );
}
}
}
public boolean canPanelBeCollapsed() {
return !isFullyCollapsed() && !mTracking && !mClosing;
}
private final Runnable mFlingCollapseRunnable = new Runnable() {
@Override
public void run() {
fling(0, false , mNextCollapseSpeedUpFactor,
false );
}
};
public void cancelPeek() {
boolean cancelled = false;
if (mPeekAnimator != null) {
cancelled = true;
mPeekAnimator.cancel();
}
if (cancelled) {
notifyBarPanelExpansionChanged();
}
}
public void expand(final boolean animate) {
if (!isFullyCollapsed() && !isCollapsing()) {
return;
}
mInstantExpanding = true;
mAnimateAfterExpanding = animate;
mUpdateFlingOnLayout = false;
abortAnimations();
cancelPeek();
if (mTracking) {
onTrackingStopped(true );
}
if (mExpanding) {
notifyExpandingFinished();
}
notifyBarPanelExpansionChanged();
getViewTreeObserver().addOnGlobalLayoutListener(
new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (!mInstantExpanding) {
getViewTreeObserver().removeOnGlobalLayoutListener(this);
return;
}
if (mStatusBar.getStatusBarWindow().getHeight()
!= mStatusBar.getStatusBarHeight()) {
getViewTreeObserver().removeOnGlobalLayoutListener(this);
if (mAnimateAfterExpanding) {
notifyExpandingStarted();
fling(0, true );
} else {
setExpandedFraction(1f);
}
mInstantExpanding = false;
}
}
});
requestLayout();
}
public void instantCollapse() {
abortAnimations();
setExpandedFraction(0f);
if (mExpanding) {
notifyExpandingFinished();
}
if (mInstantExpanding) {
mInstantExpanding = false;
notifyBarPanelExpansionChanged();
}
}
private void abortAnimations() {
cancelPeek();
cancelHeightAnimator();
removeCallbacks(mPostCollapseRunnable);
removeCallbacks(mFlingCollapseRunnable);
}
protected void onClosingFinished() {
mBar.onClosingFinished();
}
protected void startUnlockHintAnimation() {
if (mHeightAnimator != null || mTracking) {
return;
}
cancelPeek();
notifyExpandingStarted();
startUnlockHintAnimationPhase1(() -> {
notifyExpandingFinished();
onUnlockHintFinished();
mHintAnimationRunning = false;
});
onUnlockHintStarted();
mHintAnimationRunning = true;
}
protected void onUnlockHintFinished() {
mStatusBar.onHintFinished();
}
protected void onUnlockHintStarted() {
mStatusBar.onUnlockHintStarted();
}
public boolean isUnlockHintRunning() {
return mHintAnimationRunning;
}
private void startUnlockHintAnimationPhase1(final Runnable onAnimationFinished) {
float target = Math.max(0, getMaxPanelHeight() - mHintDistance);
ValueAnimator animator = createHeightAnimator(target);
animator.setDuration(250);
animator.setInterpolator(Interpolators.FAST_OUT_SLOW_IN);
animator.addListener(new AnimatorListenerAdapter() {
private boolean mCancelled;
@Override
public void onAnimationCancel(Animator animation) {
mCancelled = true;
}
@Override
public void onAnimationEnd(Animator animation) {
if (mCancelled) {
setAnimator(null);
onAnimationFinished.run();
} else {
startUnlockHintAnimationPhase2(onAnimationFinished);
}
}
});
animator.start();
setAnimator(animator);
View[] viewsToAnimate = {
mKeyguardBottomArea.getIndicationArea(),
mStatusBar.getAmbientIndicationContainer()};
for (View v : viewsToAnimate) {
if (v == null) {
continue;
}
v.animate()
.translationY(-mHintDistance)
.setDuration(250)
.setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
.withEndAction(() -> v.animate()
.translationY(0)
.setDuration(450)
.setInterpolator(mBounceInterpolator)
.start())
.start();
}
}
private void setAnimator(ValueAnimator animator) {
mHeightAnimator = animator;
if (animator == null && mPanelUpdateWhenAnimatorEnds) {
mPanelUpdateWhenAnimatorEnds = false;
requestPanelHeightUpdate();
}
}
private void startUnlockHintAnimationPhase2(final Runnable onAnimationFinished) {
ValueAnimator animator = createHeightAnimator(getMaxPanelHeight());
animator.setDuration(450);
animator.setInterpolator(mBounceInterpolator);
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
setAnimator(null);
onAnimationFinished.run();
notifyBarPanelExpansionChanged();
}
});
animator.start();
setAnimator(animator);
}
private ValueAnimator createHeightAnimator(float targetHeight) {
ValueAnimator animator = ValueAnimator.ofFloat(mExpandedHeight, targetHeight);
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
setExpandedHeightInternal((Float) animation.getAnimatedValue());
}
});
return animator;
}
protected void notifyBarPanelExpansionChanged() {
mBar.panelExpansionChanged(mExpandedFraction, mExpandedFraction > 0f
|| mPeekAnimator != null || mInstantExpanding || isPanelVisibleBecauseOfHeadsUp()
|| mTracking || mHeightAnimator != null);
if (mExpansionListener != null) {
mExpansionListener.accept(mExpandedFraction, mTracking);
}
}
public void setExpansionListener(BiConsumer<Float, Boolean> consumer) {
mExpansionListener = consumer;
}
protected abstract boolean isPanelVisibleBecauseOfHeadsUp();
protected boolean onEmptySpaceClick(float x) {
if (mHintAnimationRunning) {
return true;
}
return onMiddleClicked();
}
protected final Runnable mPostCollapseRunnable = new Runnable() {
@Override
public void run() {
collapse(false , 1.0f );
}
};
protected abstract boolean onMiddleClicked();
protected abstract boolean isDozing();
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println(String.format("[PanelView(%s): expandedHeight=%f maxPanelHeight=%d closing=%s"
+ " tracking=%s justPeeked=%s peekAnim=%s%s timeAnim=%s%s touchDisabled=%s"
+ "]",
this.getClass().getSimpleName(),
getExpandedHeight(),
getMaxPanelHeight(),
mClosing?"T":"f",
mTracking?"T":"f",
mJustPeeked?"T":"f",
mPeekAnimator, ((mPeekAnimator!=null && mPeekAnimator.isStarted())?" (started)":""),
mHeightAnimator, ((mHeightAnimator !=null && mHeightAnimator.isStarted())?" (started)":""),
mTouchDisabled?"T":"f"
));
}
public abstract void resetViews();
protected abstract float getPeekHeight();
protected abstract boolean fullyExpandedClearAllVisible();
protected abstract boolean isClearAllVisible();
protected abstract int getClearAllHeight();
public void setHeadsUpManager(HeadsUpManagerPhone headsUpManager) {
mHeadsUpManager = headsUpManager;
}
public void setLaunchingNotification(boolean launchingNotification) {
mLaunchingNotification = launchingNotification;
}
public void collapseWithDuration(int animationDuration) {
mFixedDuration = animationDuration;
collapse(false , 1.0f );
mFixedDuration = NO_FIXED_DURATION;
}
}