1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.systemui.statusbar.notification.stack; 18 19 import static com.android.systemui.statusbar.notification.NotificationUtils.logKey; 20 21 import android.annotation.NonNull; 22 import android.annotation.Nullable; 23 import android.content.Context; 24 import android.util.MathUtils; 25 26 import androidx.annotation.VisibleForTesting; 27 28 import com.android.systemui.Dumpable; 29 import com.android.systemui.R; 30 import com.android.systemui.dagger.SysUISingleton; 31 import com.android.systemui.dump.DumpManager; 32 import com.android.systemui.flags.FeatureFlags; 33 import com.android.systemui.shade.transition.LargeScreenShadeInterpolator; 34 import com.android.systemui.statusbar.NotificationShelf; 35 import com.android.systemui.statusbar.StatusBarState; 36 import com.android.systemui.statusbar.notification.collection.NotificationEntry; 37 import com.android.systemui.statusbar.notification.row.ActivatableNotificationView; 38 import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow; 39 import com.android.systemui.statusbar.notification.row.ExpandableView; 40 import com.android.systemui.statusbar.notification.stack.StackScrollAlgorithm.BypassController; 41 import com.android.systemui.statusbar.notification.stack.StackScrollAlgorithm.SectionProvider; 42 import com.android.systemui.statusbar.phone.StatusBarKeyguardViewManager; 43 44 import java.io.PrintWriter; 45 46 import javax.inject.Inject; 47 48 /** 49 * Global state to track all input states for 50 * {@link com.android.systemui.statusbar.notification.stack.StackScrollAlgorithm}. 51 */ 52 @SysUISingleton 53 public class AmbientState implements Dumpable { 54 55 private static final float MAX_PULSE_HEIGHT = 100000f; 56 private static final boolean NOTIFICATIONS_HAVE_SHADOWS = false; 57 58 private final SectionProvider mSectionProvider; 59 private final BypassController mBypassController; 60 private final LargeScreenShadeInterpolator mLargeScreenShadeInterpolator; 61 private final FeatureFlags mFeatureFlags; 62 /** 63 * Used to read bouncer states. 64 */ 65 private StatusBarKeyguardViewManager mStatusBarKeyguardViewManager; 66 private int mScrollY; 67 private boolean mDimmed; 68 private ActivatableNotificationView mActivatedChild; 69 private float mOverScrollTopAmount; 70 private float mOverScrollBottomAmount; 71 private boolean mDozing; 72 private boolean mHideSensitive; 73 private float mStackTranslation; 74 private int mLayoutHeight; 75 private int mTopPadding; 76 private boolean mShadeExpanded; 77 private float mMaxHeadsUpTranslation; 78 private boolean mClearAllInProgress; 79 private int mLayoutMinHeight; 80 private int mLayoutMaxHeight; 81 private NotificationShelf mShelf; 82 private int mZDistanceBetweenElements; 83 private int mBaseZHeight; 84 private int mContentHeight; 85 private ExpandableView mLastVisibleBackgroundChild; 86 private float mCurrentScrollVelocity; 87 private int mStatusBarState; 88 private float mExpandingVelocity; 89 private boolean mPanelTracking; 90 private boolean mExpansionChanging; 91 private boolean mIsSmallScreen; 92 private boolean mPulsing; 93 private boolean mUnlockHintRunning; 94 private float mHideAmount; 95 private boolean mAppearing; 96 private float mPulseHeight = MAX_PULSE_HEIGHT; 97 98 /** Fraction of lockscreen to shade animation (on lockscreen swipe down). */ 99 private float mFractionToShade; 100 101 /** 102 * @param fractionToShade Fraction of lockscreen to shade transition 103 */ setFractionToShade(float fractionToShade)104 public void setFractionToShade(float fractionToShade) { 105 mFractionToShade = fractionToShade; 106 } 107 108 /** 109 * @return fractionToShade Fraction of lockscreen to shade transition 110 */ getFractionToShade()111 public float getFractionToShade() { 112 return mFractionToShade; 113 } 114 115 /** How we much we are sleeping. 1f fully dozing (AOD), 0f fully awake (for all other states) */ 116 private float mDozeAmount = 0.0f; 117 118 private Runnable mOnPulseHeightChangedListener; 119 private ExpandableNotificationRow mTrackedHeadsUpRow; 120 private float mAppearFraction; 121 private float mOverExpansion; 122 private int mStackTopMargin; 123 124 /** Distance of top of notifications panel from top of screen. */ 125 private float mStackY = 0; 126 127 /** Height of notifications panel. */ 128 private float mStackHeight = 0; 129 130 /** Fraction of shade expansion. */ 131 private float mExpansionFraction; 132 133 /** Height of the notifications panel without top padding when expansion completes. */ 134 private float mStackEndHeight; 135 136 /** Whether we are swiping up. */ 137 private boolean mIsSwipingUp; 138 139 /** Whether we are flinging the shade open or closed. */ 140 private boolean mIsFlinging; 141 142 /** 143 * Whether we need to do a fling down after swiping up on lockscreen. 144 * True right after we swipe up on lockscreen and have not finished the fling down that follows. 145 * False when we stop flinging or leave lockscreen. 146 */ 147 private boolean mIsFlingRequiredAfterLockScreenSwipeUp = false; 148 149 /** 150 * Whether the shade is currently closing. 151 */ 152 private boolean mIsClosing; 153 154 @VisibleForTesting isFlingRequiredAfterLockScreenSwipeUp()155 public boolean isFlingRequiredAfterLockScreenSwipeUp() { 156 return mIsFlingRequiredAfterLockScreenSwipeUp; 157 } 158 159 @VisibleForTesting setFlingRequiredAfterLockScreenSwipeUp(boolean value)160 public void setFlingRequiredAfterLockScreenSwipeUp(boolean value) { 161 mIsFlingRequiredAfterLockScreenSwipeUp = value; 162 } 163 164 /** 165 * @return Height of the notifications panel without top padding when expansion completes. 166 */ getStackEndHeight()167 public float getStackEndHeight() { 168 return mStackEndHeight; 169 } 170 171 /** 172 * @param stackEndHeight Height of the notifications panel without top padding 173 * when expansion completes. 174 */ setStackEndHeight(float stackEndHeight)175 public void setStackEndHeight(float stackEndHeight) { 176 mStackEndHeight = stackEndHeight; 177 } 178 179 /** 180 * @param stackY Distance of top of notifications panel from top of screen. 181 */ setStackY(float stackY)182 public void setStackY(float stackY) { 183 mStackY = stackY; 184 } 185 186 /** 187 * @return Distance of top of notifications panel from top of screen. 188 */ getStackY()189 public float getStackY() { 190 return mStackY; 191 } 192 193 /** 194 * @param expansionFraction Fraction of shade expansion. 195 */ setExpansionFraction(float expansionFraction)196 public void setExpansionFraction(float expansionFraction) { 197 mExpansionFraction = expansionFraction; 198 } 199 200 /** 201 * @param isSwipingUp Whether we are swiping up. 202 */ setSwipingUp(boolean isSwipingUp)203 public void setSwipingUp(boolean isSwipingUp) { 204 if (!isSwipingUp && mIsSwipingUp) { 205 // Just stopped swiping up. 206 mIsFlingRequiredAfterLockScreenSwipeUp = true; 207 } 208 mIsSwipingUp = isSwipingUp; 209 } 210 211 /** 212 * @return Whether we are swiping up. 213 */ isSwipingUp()214 public boolean isSwipingUp() { 215 return mIsSwipingUp; 216 } 217 218 /** 219 * @param isFlinging Whether we are flinging the shade open or closed. 220 */ setFlinging(boolean isFlinging)221 public void setFlinging(boolean isFlinging) { 222 if (isOnKeyguard() && !isFlinging && mIsFlinging) { 223 // Just stopped flinging. 224 mIsFlingRequiredAfterLockScreenSwipeUp = false; 225 } 226 mIsFlinging = isFlinging; 227 } 228 229 /** 230 * @return Fraction of shade expansion. 231 */ getExpansionFraction()232 public float getExpansionFraction() { 233 return mExpansionFraction; 234 } 235 236 /** 237 * @param stackHeight Height of notifications panel. 238 */ setStackHeight(float stackHeight)239 public void setStackHeight(float stackHeight) { 240 mStackHeight = stackHeight; 241 } 242 243 /** 244 * @return Height of notifications panel. 245 */ getStackHeight()246 public float getStackHeight() { 247 return mStackHeight; 248 } 249 250 /** Tracks the state from AlertingNotificationManager#hasNotifications() */ 251 private boolean mHasAlertEntries; 252 253 @Inject AmbientState( @onNull Context context, @NonNull DumpManager dumpManager, @NonNull SectionProvider sectionProvider, @NonNull BypassController bypassController, @Nullable StatusBarKeyguardViewManager statusBarKeyguardViewManager, @NonNull LargeScreenShadeInterpolator largeScreenShadeInterpolator, @NonNull FeatureFlags featureFlags)254 public AmbientState( 255 @NonNull Context context, 256 @NonNull DumpManager dumpManager, 257 @NonNull SectionProvider sectionProvider, 258 @NonNull BypassController bypassController, 259 @Nullable StatusBarKeyguardViewManager statusBarKeyguardViewManager, 260 @NonNull LargeScreenShadeInterpolator largeScreenShadeInterpolator, 261 @NonNull FeatureFlags featureFlags) { 262 mSectionProvider = sectionProvider; 263 mBypassController = bypassController; 264 mStatusBarKeyguardViewManager = statusBarKeyguardViewManager; 265 mLargeScreenShadeInterpolator = largeScreenShadeInterpolator; 266 mFeatureFlags = featureFlags; 267 reload(context); 268 dumpManager.registerDumpable(this); 269 } 270 271 /** 272 * Reload the dimens e.g. if the density changed. 273 */ reload(Context context)274 public void reload(Context context) { 275 mZDistanceBetweenElements = getZDistanceBetweenElements(context); 276 mBaseZHeight = getBaseHeight(mZDistanceBetweenElements); 277 } 278 setOverExpansion(float overExpansion)279 void setOverExpansion(float overExpansion) { 280 mOverExpansion = overExpansion; 281 } 282 getOverExpansion()283 float getOverExpansion() { 284 return mOverExpansion; 285 } 286 getZDistanceBetweenElements(Context context)287 private static int getZDistanceBetweenElements(Context context) { 288 return Math.max(1, context.getResources() 289 .getDimensionPixelSize(R.dimen.z_distance_between_notifications)); 290 } 291 getBaseHeight(int zdistanceBetweenElements)292 private static int getBaseHeight(int zdistanceBetweenElements) { 293 return NOTIFICATIONS_HAVE_SHADOWS ? 4 * zdistanceBetweenElements : 0; 294 } 295 296 /** 297 * @return the launch height for notifications that are launched 298 */ getNotificationLaunchHeight(Context context)299 public static int getNotificationLaunchHeight(Context context) { 300 int zDistance = getZDistanceBetweenElements(context); 301 return NOTIFICATIONS_HAVE_SHADOWS ? 2 * getBaseHeight(zDistance) : 4 * zDistance; 302 } 303 304 /** 305 * @return the basic Z height on which notifications remain. 306 */ getBaseZHeight()307 public int getBaseZHeight() { 308 return mBaseZHeight; 309 } 310 311 /** 312 * @return the distance in Z between two overlaying notifications. 313 */ getZDistanceBetweenElements()314 public int getZDistanceBetweenElements() { 315 return mZDistanceBetweenElements; 316 } 317 getScrollY()318 public int getScrollY() { 319 return mScrollY; 320 } 321 322 /** 323 * Set the new Scroll Y position. 324 */ setScrollY(int scrollY)325 public void setScrollY(int scrollY) { 326 // Because we're dealing with an overscroller, scrollY could sometimes become smaller than 327 // 0. However this is only for internal purposes and the scroll position when read 328 // should never be smaller than 0, otherwise it can lead to flickers. 329 this.mScrollY = Math.max(scrollY, 0); 330 } 331 332 /** 333 * @param dimmed Whether we are in a dimmed state (on the lockscreen), where the backgrounds are 334 * translucent and everything is scaled back a bit. 335 */ setDimmed(boolean dimmed)336 public void setDimmed(boolean dimmed) { 337 mDimmed = dimmed; 338 } 339 340 /** While dozing, we draw as little as possible, assuming a black background */ setDozing(boolean dozing)341 public void setDozing(boolean dozing) { 342 mDozing = dozing; 343 } 344 345 /** Hide ratio of the status bar **/ setHideAmount(float hidemount)346 public void setHideAmount(float hidemount) { 347 if (hidemount == 1.0f && mHideAmount != hidemount) { 348 // Whenever we are fully hidden, let's reset the pulseHeight again 349 setPulseHeight(MAX_PULSE_HEIGHT); 350 } 351 mHideAmount = hidemount; 352 } 353 354 /** Returns the hide ratio of the status bar */ getHideAmount()355 public float getHideAmount() { 356 return mHideAmount; 357 } 358 setHideSensitive(boolean hideSensitive)359 public void setHideSensitive(boolean hideSensitive) { 360 mHideSensitive = hideSensitive; 361 } 362 363 /** 364 * In dimmed mode, a child can be activated, which happens on the first tap of the double-tap 365 * interaction. This child is then scaled normally and its background is fully opaque. 366 */ setActivatedChild(ActivatableNotificationView activatedChild)367 public void setActivatedChild(ActivatableNotificationView activatedChild) { 368 mActivatedChild = activatedChild; 369 } 370 isDimmed()371 public boolean isDimmed() { 372 // While we are expanding from pulse, we want the notifications not to be dimmed, otherwise 373 // you'd see the difference to the pulsing notification 374 return mDimmed && !(isPulseExpanding() && mDozeAmount == 1.0f); 375 } 376 isDozing()377 public boolean isDozing() { 378 return mDozing; 379 } 380 isHideSensitive()381 public boolean isHideSensitive() { 382 return mHideSensitive; 383 } 384 getActivatedChild()385 public ActivatableNotificationView getActivatedChild() { 386 return mActivatedChild; 387 } 388 setOverScrollAmount(float amount, boolean onTop)389 public void setOverScrollAmount(float amount, boolean onTop) { 390 if (onTop) { 391 mOverScrollTopAmount = amount; 392 } else { 393 mOverScrollBottomAmount = amount; 394 } 395 } 396 397 /** 398 * Is bypass currently enabled? 399 */ isBypassEnabled()400 public boolean isBypassEnabled() { 401 return mBypassController.isBypassEnabled(); 402 } 403 getOverScrollAmount(boolean top)404 public float getOverScrollAmount(boolean top) { 405 return top ? mOverScrollTopAmount : mOverScrollBottomAmount; 406 } 407 getSectionProvider()408 public SectionProvider getSectionProvider() { 409 return mSectionProvider; 410 } 411 getStackTranslation()412 public float getStackTranslation() { 413 return mStackTranslation; 414 } 415 setStackTranslation(float stackTranslation)416 public void setStackTranslation(float stackTranslation) { 417 mStackTranslation = stackTranslation; 418 } 419 setLayoutHeight(int layoutHeight)420 public void setLayoutHeight(int layoutHeight) { 421 mLayoutHeight = layoutHeight; 422 } 423 setLayoutMaxHeight(int maxLayoutHeight)424 public void setLayoutMaxHeight(int maxLayoutHeight) { 425 mLayoutMaxHeight = maxLayoutHeight; 426 } 427 getLayoutMaxHeight()428 public int getLayoutMaxHeight() { 429 return mLayoutMaxHeight; 430 } 431 getTopPadding()432 public float getTopPadding() { 433 return mTopPadding; 434 } 435 setTopPadding(int topPadding)436 public void setTopPadding(int topPadding) { 437 mTopPadding = topPadding; 438 } 439 getInnerHeight()440 public int getInnerHeight() { 441 return getInnerHeight(false /* ignorePulseHeight */); 442 } 443 444 /** 445 * @param ignorePulseHeight ignore the pulse height for this request 446 * @return the inner height of the algorithm. 447 */ getInnerHeight(boolean ignorePulseHeight)448 public int getInnerHeight(boolean ignorePulseHeight) { 449 if (mDozeAmount == 1.0f && !isPulseExpanding()) { 450 return mShelf.getHeight(); 451 } 452 int height = (int) Math.max(mLayoutMinHeight, 453 Math.min(mLayoutHeight, mContentHeight) - mTopPadding); 454 if (ignorePulseHeight) { 455 return height; 456 } 457 float pulseHeight = Math.min(mPulseHeight, (float) height); 458 return (int) MathUtils.lerp(height, pulseHeight, mDozeAmount); 459 } 460 isPulseExpanding()461 public boolean isPulseExpanding() { 462 return mPulseHeight != MAX_PULSE_HEIGHT && mDozeAmount != 0.0f && mHideAmount != 1.0f; 463 } 464 isShadeExpanded()465 public boolean isShadeExpanded() { 466 return mShadeExpanded; 467 } 468 setShadeExpanded(boolean shadeExpanded)469 public void setShadeExpanded(boolean shadeExpanded) { 470 mShadeExpanded = shadeExpanded; 471 } 472 setMaxHeadsUpTranslation(float maxHeadsUpTranslation)473 public void setMaxHeadsUpTranslation(float maxHeadsUpTranslation) { 474 mMaxHeadsUpTranslation = maxHeadsUpTranslation; 475 } 476 getMaxHeadsUpTranslation()477 public float getMaxHeadsUpTranslation() { 478 return mMaxHeadsUpTranslation; 479 } 480 setClearAllInProgress(boolean clearAllInProgress)481 public void setClearAllInProgress(boolean clearAllInProgress) { 482 mClearAllInProgress = clearAllInProgress; 483 } 484 isClearAllInProgress()485 public boolean isClearAllInProgress() { 486 return mClearAllInProgress; 487 } 488 setLayoutMinHeight(int layoutMinHeight)489 public void setLayoutMinHeight(int layoutMinHeight) { 490 mLayoutMinHeight = layoutMinHeight; 491 } 492 setShelf(NotificationShelf shelf)493 public void setShelf(NotificationShelf shelf) { 494 mShelf = shelf; 495 } 496 497 @Nullable getShelf()498 public NotificationShelf getShelf() { 499 return mShelf; 500 } 501 setContentHeight(int contentHeight)502 public void setContentHeight(int contentHeight) { 503 mContentHeight = contentHeight; 504 } 505 getContentHeight()506 public float getContentHeight() { 507 return mContentHeight; 508 } 509 510 /** 511 * Sets the last visible view of the host layout, that has a background, i.e the very last 512 * view in the shade, without the clear all button. 513 */ setLastVisibleBackgroundChild( ExpandableView lastVisibleBackgroundChild)514 public void setLastVisibleBackgroundChild( 515 ExpandableView lastVisibleBackgroundChild) { 516 mLastVisibleBackgroundChild = lastVisibleBackgroundChild; 517 } 518 getLastVisibleBackgroundChild()519 public ExpandableView getLastVisibleBackgroundChild() { 520 return mLastVisibleBackgroundChild; 521 } 522 setCurrentScrollVelocity(float currentScrollVelocity)523 public void setCurrentScrollVelocity(float currentScrollVelocity) { 524 mCurrentScrollVelocity = currentScrollVelocity; 525 } 526 getCurrentScrollVelocity()527 public float getCurrentScrollVelocity() { 528 return mCurrentScrollVelocity; 529 } 530 isOnKeyguard()531 public boolean isOnKeyguard() { 532 return mStatusBarState == StatusBarState.KEYGUARD; 533 } 534 setStatusBarState(int statusBarState)535 public void setStatusBarState(int statusBarState) { 536 if (mStatusBarState != StatusBarState.KEYGUARD) { 537 mIsFlingRequiredAfterLockScreenSwipeUp = false; 538 } 539 mStatusBarState = statusBarState; 540 } 541 setExpandingVelocity(float expandingVelocity)542 public void setExpandingVelocity(float expandingVelocity) { 543 mExpandingVelocity = expandingVelocity; 544 } 545 setExpansionChanging(boolean expansionChanging)546 public void setExpansionChanging(boolean expansionChanging) { 547 mExpansionChanging = expansionChanging; 548 } 549 isExpansionChanging()550 public boolean isExpansionChanging() { 551 return mExpansionChanging; 552 } 553 getExpandingVelocity()554 public float getExpandingVelocity() { 555 return mExpandingVelocity; 556 } 557 setPanelTracking(boolean panelTracking)558 public void setPanelTracking(boolean panelTracking) { 559 mPanelTracking = panelTracking; 560 } 561 hasPulsingNotifications()562 public boolean hasPulsingNotifications() { 563 return mPulsing && mHasAlertEntries; 564 } 565 setPulsing(boolean hasPulsing)566 public void setPulsing(boolean hasPulsing) { 567 mPulsing = hasPulsing; 568 } 569 570 /** 571 * @return if we're pulsing in general 572 */ isPulsing()573 public boolean isPulsing() { 574 return mPulsing; 575 } 576 isPulsing(NotificationEntry entry)577 public boolean isPulsing(NotificationEntry entry) { 578 return mPulsing && entry.isAlerting(); 579 } 580 isPanelTracking()581 public boolean isPanelTracking() { 582 return mPanelTracking; 583 } 584 isSmallScreen()585 public boolean isSmallScreen() { 586 return mIsSmallScreen; 587 } 588 setSmallScreen(boolean smallScreen)589 public void setSmallScreen(boolean smallScreen) { 590 mIsSmallScreen = smallScreen; 591 } 592 setUnlockHintRunning(boolean unlockHintRunning)593 public void setUnlockHintRunning(boolean unlockHintRunning) { 594 mUnlockHintRunning = unlockHintRunning; 595 } 596 isUnlockHintRunning()597 public boolean isUnlockHintRunning() { 598 return mUnlockHintRunning; 599 } 600 601 /** 602 * @return Whether we need to do a fling down after swiping up on lockscreen. 603 */ isFlingingAfterSwipeUpOnLockscreen()604 public boolean isFlingingAfterSwipeUpOnLockscreen() { 605 return mIsFlinging && mIsFlingRequiredAfterLockScreenSwipeUp; 606 } 607 608 /** 609 * @return whether a view is dozing and not pulsing right now 610 */ isDozingAndNotPulsing(ExpandableView view)611 public boolean isDozingAndNotPulsing(ExpandableView view) { 612 if (view instanceof ExpandableNotificationRow) { 613 return isDozingAndNotPulsing((ExpandableNotificationRow) view); 614 } 615 return false; 616 } 617 618 /** 619 * @return whether a row is dozing and not pulsing right now 620 */ isDozingAndNotPulsing(ExpandableNotificationRow row)621 public boolean isDozingAndNotPulsing(ExpandableNotificationRow row) { 622 return isDozing() && !isPulsing(row.getEntry()); 623 } 624 625 /** 626 * @return {@code true } when shade is completely hidden: in AOD, ambient display or when 627 * bypassing. 628 */ isFullyHidden()629 public boolean isFullyHidden() { 630 return mHideAmount == 1; 631 } 632 isHiddenAtAll()633 public boolean isHiddenAtAll() { 634 return mHideAmount != 0; 635 } 636 setAppearing(boolean appearing)637 public void setAppearing(boolean appearing) { 638 mAppearing = appearing; 639 } 640 isAppearing()641 public boolean isAppearing() { 642 return mAppearing; 643 } 644 setPulseHeight(float height)645 public void setPulseHeight(float height) { 646 if (height != mPulseHeight) { 647 mPulseHeight = height; 648 if (mOnPulseHeightChangedListener != null) { 649 mOnPulseHeightChangedListener.run(); 650 } 651 } 652 } 653 getPulseHeight()654 public float getPulseHeight() { 655 if (mPulseHeight == MAX_PULSE_HEIGHT) { 656 // If we're not pulse expanding, the height should be 0 657 return 0; 658 } 659 return mPulseHeight; 660 } 661 setDozeAmount(float dozeAmount)662 public void setDozeAmount(float dozeAmount) { 663 if (dozeAmount != mDozeAmount) { 664 mDozeAmount = dozeAmount; 665 if (dozeAmount == 0.0f || dozeAmount == 1.0f) { 666 // We woke all the way up, let's reset the pulse height 667 setPulseHeight(MAX_PULSE_HEIGHT); 668 } 669 } 670 } 671 getDozeAmount()672 public float getDozeAmount() { 673 return mDozeAmount; 674 } 675 676 /** 677 * Is the device fully awake, which is different from not tark at all when there are pulsing 678 * notifications. 679 */ isFullyAwake()680 public boolean isFullyAwake() { 681 return mDozeAmount == 0.0f; 682 } 683 setOnPulseHeightChangedListener(Runnable onPulseHeightChangedListener)684 public void setOnPulseHeightChangedListener(Runnable onPulseHeightChangedListener) { 685 mOnPulseHeightChangedListener = onPulseHeightChangedListener; 686 } 687 setTrackedHeadsUpRow(ExpandableNotificationRow row)688 public void setTrackedHeadsUpRow(ExpandableNotificationRow row) { 689 mTrackedHeadsUpRow = row; 690 } 691 692 /** 693 * Returns the currently tracked heads up row, if there is one and it is currently above the 694 * shelf (still appearing). 695 */ getTrackedHeadsUpRow()696 public ExpandableNotificationRow getTrackedHeadsUpRow() { 697 if (mTrackedHeadsUpRow == null || !mTrackedHeadsUpRow.isAboveShelf()) { 698 return null; 699 } 700 return mTrackedHeadsUpRow; 701 } 702 setAppearFraction(float appearFraction)703 public void setAppearFraction(float appearFraction) { 704 mAppearFraction = appearFraction; 705 } 706 getAppearFraction()707 public float getAppearFraction() { 708 return mAppearFraction; 709 } 710 setHasAlertEntries(boolean hasAlertEntries)711 public void setHasAlertEntries(boolean hasAlertEntries) { 712 mHasAlertEntries = hasAlertEntries; 713 } 714 setStackTopMargin(int stackTopMargin)715 public void setStackTopMargin(int stackTopMargin) { 716 mStackTopMargin = stackTopMargin; 717 } 718 getStackTopMargin()719 public int getStackTopMargin() { 720 return mStackTopMargin; 721 } 722 723 /** 724 * Check to see if we are about to show bouncer. 725 * 726 * @return if bouncer expansion is between 0 and 1. 727 */ isBouncerInTransit()728 public boolean isBouncerInTransit() { 729 return mStatusBarKeyguardViewManager != null 730 && mStatusBarKeyguardViewManager.isPrimaryBouncerInTransit(); 731 } 732 733 /** 734 * @param isClosing Whether the shade is currently closing. 735 */ setIsClosing(boolean isClosing)736 public void setIsClosing(boolean isClosing) { 737 mIsClosing = isClosing; 738 } 739 740 /** 741 * @return Whether the shade is currently closing. 742 */ isClosing()743 public boolean isClosing() { 744 return mIsClosing; 745 } 746 getLargeScreenShadeInterpolator()747 public LargeScreenShadeInterpolator getLargeScreenShadeInterpolator() { 748 return mLargeScreenShadeInterpolator; 749 } 750 getFeatureFlags()751 public FeatureFlags getFeatureFlags() { 752 return mFeatureFlags; 753 } 754 755 @Override dump(PrintWriter pw, String[] args)756 public void dump(PrintWriter pw, String[] args) { 757 pw.println("mTopPadding=" + mTopPadding); 758 pw.println("mStackTopMargin=" + mStackTopMargin); 759 pw.println("mStackTranslation=" + mStackTranslation); 760 pw.println("mLayoutMinHeight=" + mLayoutMinHeight); 761 pw.println("mLayoutMaxHeight=" + mLayoutMaxHeight); 762 pw.println("mLayoutHeight=" + mLayoutHeight); 763 pw.println("mContentHeight=" + mContentHeight); 764 pw.println("mHideSensitive=" + mHideSensitive); 765 pw.println("mShadeExpanded=" + mShadeExpanded); 766 pw.println("mClearAllInProgress=" + mClearAllInProgress); 767 pw.println("mDimmed=" + mDimmed); 768 pw.println("mStatusBarState=" + mStatusBarState); 769 pw.println("mExpansionChanging=" + mExpansionChanging); 770 pw.println("mPanelFullWidth=" + mIsSmallScreen); 771 pw.println("mPulsing=" + mPulsing); 772 pw.println("mPulseHeight=" + mPulseHeight); 773 pw.println("mTrackedHeadsUpRow.key=" + logKey(mTrackedHeadsUpRow)); 774 pw.println("mMaxHeadsUpTranslation=" + mMaxHeadsUpTranslation); 775 pw.println("mUnlockHintRunning=" + mUnlockHintRunning); 776 pw.println("mDozeAmount=" + mDozeAmount); 777 pw.println("mDozing=" + mDozing); 778 pw.println("mFractionToShade=" + mFractionToShade); 779 pw.println("mHideAmount=" + mHideAmount); 780 pw.println("mAppearFraction=" + mAppearFraction); 781 pw.println("mAppearing=" + mAppearing); 782 pw.println("mExpansionFraction=" + mExpansionFraction); 783 pw.println("mExpandingVelocity=" + mExpandingVelocity); 784 pw.println("mOverScrollTopAmount=" + mOverScrollTopAmount); 785 pw.println("mOverScrollBottomAmount=" + mOverScrollBottomAmount); 786 pw.println("mOverExpansion=" + mOverExpansion); 787 pw.println("mStackHeight=" + mStackHeight); 788 pw.println("mStackEndHeight=" + mStackEndHeight); 789 pw.println("mStackY=" + mStackY); 790 pw.println("mScrollY=" + mScrollY); 791 pw.println("mCurrentScrollVelocity=" + mCurrentScrollVelocity); 792 pw.println("mIsSwipingUp=" + mIsSwipingUp); 793 pw.println("mPanelTracking=" + mPanelTracking); 794 pw.println("mIsFlinging=" + mIsFlinging); 795 pw.println("mIsFlingRequiredAfterLockScreenSwipeUp=" 796 + mIsFlingRequiredAfterLockScreenSwipeUp); 797 pw.println("mZDistanceBetweenElements=" + mZDistanceBetweenElements); 798 pw.println("mBaseZHeight=" + mBaseZHeight); 799 pw.println("mIsClosing=" + mIsClosing); 800 } 801 } 802