* @param entry the entry that changed
* @param isPulsing true if the entry is now pulsing, false otherwise
*/
- void onAmbientStateChanged(NotificationEntry entry, boolean isPulsing);
+ void onAmbientStateChanged(@NonNull NotificationEntry entry, boolean isPulsing);
}
private final class AmbientEntry extends AlertEntry {
openedAmount = Math.min(1.0f, openedAmount);
viewState.openedAmount = openedAmount;
viewState.clipTopAmount = 0;
- viewState.alpha = mAmbientState.hasPulsingNotifications()
- && !mAmbientState.isPulseExpanding() ? 0 : 1;
+ viewState.alpha = 1;
viewState.belowSpeedBump = mAmbientState.getSpeedBumpIndex() == 0;
viewState.hideSensitive = false;
viewState.xTranslation = getTranslationX();
float viewEnd = row.getTranslationY() + row.getActualHeight();
boolean isPinned = (row.isPinned() || row.isHeadsUpAnimatingAway())
&& !mAmbientState.isDozingAndNotPulsing(row);
- boolean shouldClipOwnTop = row.isAmbientPulsing()
+ boolean shouldClipOwnTop = row.showingAmbientPulsing()
|| (mAmbientState.isPulseExpanding() && childIndex == 0);
if (viewEnd > notificationClipEnd && !shouldClipOwnTop
&& (mAmbientState.isShadeExpanded() || !isPinned)) {
? fullTransitionAmount
: transitionAmount;
iconState.clampedAppearAmount = clampedAmount;
- float contentTransformationAmount = !mAmbientState.isAboveShelf(row)
+ float contentTransformationAmount = !row.isAboveShelf()
&& (isLastChild || iconState.translateContent)
? iconTransitionAmount
: 0.0f;
iconState.scaleY = 1.0f;
iconState.hidden = false;
}
- if (mAmbientState.isAboveShelf(row) || (!row.isInShelf() && (isLastChild && row.areGutsExposed()
+ if (row.isAboveShelf() || (!row.isInShelf() && (isLastChild && row.areGutsExposed()
|| row.getTranslationZ() > mAmbientState.getBaseZHeight()))) {
iconState.hidden = true;
}
private var mDarkAnimator: ObjectAnimator? = null
private var mVisibilityAmount = 0.0f
private var mLinearVisibilityAmount = 0.0f
- private var mPulsing: Boolean = false
+ private var mWakingUp = false
+ private val mEntrySetToClearWhenFinished = mutableSetOf<NotificationEntry>()
init {
mAmbientPulseManager.addListener(this)
}
private fun updateNotificationVisibility(animate: Boolean, increaseSpeed: Boolean) {
- var visible = false
- if (mPulsing) {
- visible = mNotificationsVisibleForExpansion || mAmbientPulseManager.hasNotifications()
+ var visible = mNotificationsVisibleForExpansion || mAmbientPulseManager.hasNotifications()
+ if (!visible && mNotificationsVisible && mWakingUp && mDozeAmount != 0.0f) {
+ // let's not make notifications invisible while waking up, otherwise the animation
+ // is strange
+ return;
}
setNotificationsVisible(visible, animate, increaseSpeed)
}
mDozeAmount = interpolatedAmount
mStackScroller.setDozeAmount(mDozeAmount)
updateDarkAmount()
+ if (linearAmount == 0.0f) {
+ setNotificationsVisible(visible = false, animate = false, increaseSpeed = false);
+ setNotificationsVisibleForExpansion(visible = false, animate = false,
+ increaseSpeed = false)
+ }
}
private fun startVisibilityAnimation(increaseSpeed: Boolean) {
mLinearVisibilityAmount = visibilityAmount
mVisibilityAmount = mVisibilityInterpolator.getInterpolation(
visibilityAmount)
+ handleAnimationFinished();
updateDarkAmount()
}
+ private fun handleAnimationFinished() {
+ if (mLinearDozeAmount == 0.0f || mLinearVisibilityAmount == 0.0f) {
+ mEntrySetToClearWhenFinished.forEach { it.setAmbientGoingAway(false) }
+ }
+ }
+
fun getWakeUpHeight() : Float {
return mStackScroller.wakeUpHeight
}
fun setDozing(dozing: Boolean, animate: Boolean) {
if (dozing) {
- mNotificationsVisible = false
- mNotificationsVisibleForExpansion = false
+ setNotificationsVisible(visible = false, animate = false, increaseSpeed = false)
}
if (animate) {
notifyAnimationStart(!dozing)
return mStackScroller.setPulseHeight(height)
}
- fun setPulsing(pulsing: Boolean) {
- mPulsing = pulsing;
- updateNotificationVisibility(animate = true, increaseSpeed = false)
+ fun setWakingUp(wakingUp: Boolean) {
+ mWakingUp = wakingUp
+ if (wakingUp && mNotificationsVisible && !mNotificationsVisibleForExpansion) {
+ // We're waking up while pulsing, let's make sure the animation looks nice
+ mStackScroller.wakeUpFromPulse();
+ }
}
- override fun onAmbientStateChanged(entry: NotificationEntry?, isPulsing: Boolean) {
+ override fun onAmbientStateChanged(entry: NotificationEntry, isPulsing: Boolean) {
+ if (!isPulsing && mLinearDozeAmount != 0.0f) {
+ entry.setAmbientGoingAway(true)
+ mEntrySetToClearWhenFinished.add(entry)
+ } else if (isPulsing && mEntrySetToClearWhenFinished.contains(entry)) {
+ mEntrySetToClearWhenFinished.remove(entry)
+ entry.setAmbientGoingAway(false)
+ }
updateNotificationVisibility(animate = true, increaseSpeed = false)
}
}
\ No newline at end of file
} else if (isHeadsUp) {
// Provide consistent ranking with headsUpManager
return mHeadsUpManager.compare(a, b);
- } else if (a.getRow().isAmbientPulsing() != b.getRow().isAmbientPulsing()) {
- return a.getRow().isAmbientPulsing() ? -1 : 1;
+ } else if (a.getRow().showingAmbientPulsing() != b.getRow().showingAmbientPulsing()) {
+ return a.getRow().showingAmbientPulsing() ? -1 : 1;
} else if (aMedia != bMedia) {
// Upsort current media notification.
return aMedia ? -1 : 1;
if (row != null) row.setHeadsUp(shouldHeadsUp);
}
+
+ public void setAmbientGoingAway(boolean goingAway) {
+ if (row != null) row.setAmbientGoingAway(goingAway);
+ }
+
+
public boolean mustStayOnScreen() {
return row != null && row.mustStayOnScreen();
}
private boolean mIsAmbientPulsing;
/**
+ * Happens when the notification was pulsing before and goes away to ensure smooth animations.
+ */
+ private boolean mAmbientGoingAway;
+
+ /**
* Whether or not the notification should be redacted on the lock screen, i.e has sensitive
* content which should be redacted on the lock screen.
*/
}
@Override
- public boolean isAmbientPulsing() {
- return mIsAmbientPulsing;
+ public boolean showingAmbientPulsing() {
+ return mIsAmbientPulsing || mAmbientGoingAway;
}
public void setAmbientPulsing(boolean isAmbientPulsing) {
@Override
public boolean isAboveShelf() {
- return isAmbientPulsing() || (!isOnKeyguard()
+ return showingAmbientPulsing() || (!isOnKeyguard()
&& (mIsPinned || mHeadsupDisappearRunning || (mIsHeadsUp && mAboveShelf)
|| mExpandAnimationRunning || mChildIsExpanding));
}
}
}
+ public void setAmbientGoingAway(boolean goingAway) {
+ mAmbientGoingAway = goingAway;
+ }
+
@VisibleForTesting
protected void setChildrenContainer(NotificationChildrenContainer childrenContainer) {
mChildrenContainer = childrenContainer;
public void setHeadsUpIsVisible() {
}
- public boolean isAmbientPulsing() {
+ public boolean showingAmbientPulsing() {
return false;
}
/** Dark ratio of the status bar **/
public void setDarkAmount(float darkAmount) {
- mDarkAmount = darkAmount;
- if (darkAmount == 1.0f) {
+ if (darkAmount == 1.0f && mDarkAmount != darkAmount) {
+ // Whenever we are fully dark, let's reset the pulseHeight again
mPulseHeight = MAX_PULSE_HEIGHT;
}
+ mDarkAmount = darkAmount;
}
/** Returns the dark ratio of the status bar */
}
public boolean isPulseExpanding() {
- return mPulseHeight != MAX_PULSE_HEIGHT && mDarkAmount != 1.0f;
+ return mPulseHeight != MAX_PULSE_HEIGHT && mDozeAmount != 0.0f && mDarkAmount != 1.0f;
}
public boolean isShadeExpanded() {
}
/**
- * Similar to the normal is above shelf logic but doesn't allow it to be above in AOD1.
- *
- * @param expandableView the view to check
- */
- public boolean isAboveShelf(ExpandableView expandableView) {
- if (!(expandableView instanceof ExpandableNotificationRow)) {
- return expandableView.isAboveShelf();
- }
- ExpandableNotificationRow row = (ExpandableNotificationRow) expandableView;
- return row.isAboveShelf() && !isDozingAndNotPulsing(row);
- }
-
- /**
* @return whether a view is dozing and not pulsing right now
*/
public boolean isDozingAndNotPulsing(ExpandableView view) {
public void setDozeAmount(float dozeAmount) {
if (dozeAmount != mDozeAmount) {
mDozeAmount = dozeAmount;
- if (dozeAmount == 1.0f) {
+ if (dozeAmount == 0.0f || dozeAmount == 1.0f) {
// We woke all the way up, let's reset the pulse height
mPulseHeight = MAX_PULSE_HEIGHT;
}
newTop = (int) Math.ceil(firstView.getTranslationY());
}
top = Math.max(newTop, top);
- if (firstView.isAmbientPulsing()) {
+ if (firstView.showingAmbientPulsing()) {
// If we're pulsing, the notification can actually go below!
bottom = Math.max(bottom, finalTranslationY
+ ExpandableViewState.getFinalActualHeight(firstView));
private boolean isHeadsUpTransition() {
NotificationSection firstVisibleSection = getFirstVisibleSection();
return mTrackingHeadsUp && firstVisibleSection != null
- && mAmbientState.isAboveShelf(firstVisibleSection.getFirstVisibleChild());
+ && firstVisibleSection.getFirstVisibleChild().isAboveShelf();
}
/**
requestChildrenUpdate();
}
+ public void wakeUpFromPulse() {
+ setPulseHeight(getWakeUpHeight());
+ // Let's place the hidden views at the end of the pulsing notification to make sure we have
+ // a smooth animation
+ boolean firstVisibleView = true;
+ float wakeUplocation = -1f;
+ int childCount = getChildCount();
+ for (int i = 0; i < childCount; i++) {
+ ExpandableView view = (ExpandableView) getChildAt(i);
+ if (view.getVisibility() == View.GONE) {
+ continue;
+ }
+ boolean isShelf = view == mShelf;
+ if (!(view instanceof ExpandableNotificationRow) && !isShelf) {
+ continue;
+ }
+ if (view.getVisibility() == View.VISIBLE && !isShelf) {
+ if (firstVisibleView) {
+ firstVisibleView = false;
+ wakeUplocation = view.getTranslationY()
+ + view.getActualHeight() - mShelf.getIntrinsicHeight();
+ }
+ } else if (!firstVisibleView) {
+ view.setTranslationY(wakeUplocation);
+ }
+ }
+ }
+
/**
* A listener that is notified when the empty space below the notifications is clicked on
*/
continue;
}
ExpandableNotificationRow row = (ExpandableNotificationRow) child;
- if (!row.isAmbientPulsing() || (i == 0 && ambientState.isPulseExpanding())) {
+ if (!row.showingAmbientPulsing() || (i == 0 && ambientState.isPulseExpanding())) {
continue;
}
ExpandableViewState viewState = row.getViewState();
if (row.mustStayOnScreen() && !childState.headsUpIsVisible) {
// Ensure that the heads up is always visible even when scrolled off
clampHunToTop(ambientState, row, childState);
- if (i == 0 && ambientState.isAboveShelf(row)) {
+ if (i == 0 && row.isAboveShelf()) {
// the first hun can't get off screen.
clampHunToMaxTranslation(ambientState, row, childState);
childState.hidden = false;
}
childViewState.zTranslation = baseZ
+ childrenOnTop * zDistanceBetweenElements;
- } else if (i == 0 && ambientState.isAboveShelf(child)) {
+ } else if (i == 0 && child.isAboveShelf()) {
// In case this is a new view that has never been measured before, we don't want to
// elevate if we are currently expanded more then the notification
int shelfHeight = ambientState.getShelf() == null ? 0 :
@Override
public void onStartedWakingUp() {
mDeviceInteractive = true;
+ mWakeUpCoordinator.setWakingUp(true);
mAmbientPulseManager.releaseAllImmediately();
mVisualStabilityManager.setScreenOn(true);
updateNotificationPanelTouchState();
mDozeServiceHost.stopDozing();
mPulseExpansionHandler.onStartedWakingUp();
}
+
+ @Override
+ public void onFinishedWakingUp() {
+ mWakeUpCoordinator.setWakingUp(false);
+ }
};
/**
}
updateScrimController();
mPulseExpansionHandler.setPulsing(pulsing);
- mWakeUpCoordinator.setPulsing(pulsing);
}
}, reason);
// DozeScrimController is in pulse state, now let's ask ScrimController to start
OSDN Git Service
