package com.android.systemui.statusbar 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.os.SystemClock import android.util.IndentingPrintWriter import android.util.MathUtils import android.view.MotionEvent import android.view.View import android.view.ViewConfiguration import androidx.annotation.VisibleForTesting import com.android.systemui.Dumpable import com.android.systemui.ExpandHelper import com.android.systemui.Gefingerpoken import com.android.systemui.R import com.android.systemui.animation.Interpolators import com.android.systemui.biometrics.UdfpsKeyguardViewController import com.android.systemui.classifier.Classifier import com.android.systemui.classifier.FalsingCollector import com.android.systemui.dagger.SysUISingleton import com.android.systemui.dump.DumpManager import com.android.systemui.keyguard.WakefulnessLifecycle import com.android.systemui.media.MediaHierarchyManager import com.android.systemui.plugins.ActivityStarter.OnDismissAction import com.android.systemui.plugins.FalsingManager import com.android.systemui.plugins.qs.QS import com.android.systemui.plugins.statusbar.StatusBarStateController import com.android.systemui.statusbar.notification.collection.NotificationEntry import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow import com.android.systemui.statusbar.notification.row.ExpandableView import com.android.systemui.statusbar.notification.stack.AmbientState import com.android.systemui.statusbar.notification.stack.NotificationStackScrollLayoutController import com.android.systemui.statusbar.phone.KeyguardBypassController import com.android.systemui.statusbar.phone.LSShadeTransitionLogger import com.android.systemui.statusbar.phone.NotificationPanelViewController import com.android.systemui.statusbar.phone.ScrimController import com.android.systemui.statusbar.phone.StatusBar import com.android.systemui.statusbar.policy.ConfigurationController import com.android.systemui.util.Utils import java.io.FileDescriptor import java.io.PrintWriter import javax.inject.Inject private const val SPRING_BACK_ANIMATION_LENGTH_MS = 375L private const val RUBBERBAND_FACTOR_STATIC = 0.15f private const val RUBBERBAND_FACTOR_EXPANDABLE = 0.5f /** * A class that controls the lockscreen to shade transition */ @SysUISingleton class LockscreenShadeTransitionController @Inject constructor( private val statusBarStateController: SysuiStatusBarStateController, private val logger: LSShadeTransitionLogger, private val keyguardBypassController: KeyguardBypassController, private val lockScreenUserManager: NotificationLockscreenUserManager, private val falsingCollector: FalsingCollector, private val ambientState: AmbientState, private val mediaHierarchyManager: MediaHierarchyManager, private val scrimController: ScrimController, private val depthController: NotificationShadeDepthController, private val context: Context, wakefulnessLifecycle: WakefulnessLifecycle, configurationController: ConfigurationController, falsingManager: FalsingManager, dumpManager: DumpManager, ) : Dumpable { private var pulseHeight: Float = 0f private var useSplitShade: Boolean = false private lateinit var nsslController: NotificationStackScrollLayoutController lateinit var notificationPanelController: NotificationPanelViewController lateinit var statusbar: StatusBar lateinit var qS: QS /** * A handler that handles the next keyguard dismiss animation. */ private var animationHandlerOnKeyguardDismiss: ((Long) -> Unit)? = null /** * The entry that was just dragged down on. */ private var draggedDownEntry: NotificationEntry? = null /** * The current animator if any */ @VisibleForTesting internal var dragDownAnimator: ValueAnimator? = null /** * The current pulse height animator if any */ @VisibleForTesting internal var pulseHeightAnimator: ValueAnimator? = null /** * Distance that the full shade transition takes in order for scrim to fully transition to * the shade (in alpha) */ private var scrimTransitionDistance = 0 /** * Distance that the full transition takes in order for us to fully transition to the shade */ private var fullTransitionDistance = 0 /** * Flag to make sure that the dragDownAmount is applied to the listeners even when in the * locked down shade. */ private var forceApplyAmount = false /** * A flag to suppress the default animation when unlocking in the locked down shade. */ private var nextHideKeyguardNeedsNoAnimation = false /** * Are we currently waking up to the shade locked */ var isWakingToShadeLocked: Boolean = false private set /** * The distance until we're showing the notifications when pulsing */ val distanceUntilShowingPulsingNotifications get() = scrimTransitionDistance /** * The udfpsKeyguardViewController if it exists. */ var udfpsKeyguardViewController: UdfpsKeyguardViewController? = null /** * The touch helper responsible for the drag down animation. */ val touchHelper = DragDownHelper(falsingManager, falsingCollector, this, context) init { updateResources() configurationController.addCallback(object : ConfigurationController.ConfigurationListener { override fun onConfigChanged(newConfig: Configuration?) { updateResources() touchHelper.updateResources(context) } }) dumpManager.registerDumpable(this) statusBarStateController.addCallback(object : StatusBarStateController.StateListener { override fun onExpandedChanged(isExpanded: Boolean) { // safeguard: When the panel is fully collapsed, let's make sure to reset. // See b/198098523 if (!isExpanded) { if (dragDownAmount != 0f && dragDownAnimator?.isRunning != true) { logger.logDragDownAmountResetWhenFullyCollapsed() dragDownAmount = 0f } if (pulseHeight != 0f && pulseHeightAnimator?.isRunning != true) { logger.logPulseHeightNotResetWhenFullyCollapsed() setPulseHeight(0f, animate = false) } } } }) wakefulnessLifecycle.addObserver(object : WakefulnessLifecycle.Observer { override fun onPostFinishedWakingUp() { // when finishing waking up, the UnlockedScreenOffAnimation has another attempt // to reset keyguard. Let's do it in post isWakingToShadeLocked = false } }) } private fun updateResources() { scrimTransitionDistance = context.resources.getDimensionPixelSize( R.dimen.lockscreen_shade_scrim_transition_distance) fullTransitionDistance = context.resources.getDimensionPixelSize( R.dimen.lockscreen_shade_qs_transition_distance) useSplitShade = Utils.shouldUseSplitNotificationShade(context.resources) } fun setStackScroller(nsslController: NotificationStackScrollLayoutController) { this.nsslController = nsslController touchHelper.host = nsslController.view touchHelper.expandCallback = nsslController.expandHelperCallback } /** * Initialize the shelf controller such that clicks on it will expand the shade */ fun bindController(notificationShelfController: NotificationShelfController) { // Bind the click listener of the shelf to go to the full shade notificationShelfController.setOnClickListener { if (statusBarStateController.state == StatusBarState.KEYGUARD) { statusbar.wakeUpIfDozing(SystemClock.uptimeMillis(), it, "SHADE_CLICK") goToLockedShade(it) } } } /** * @return true if the interaction is accepted, false if it should be cancelled */ internal fun canDragDown(): Boolean { return (statusBarStateController.state == StatusBarState.KEYGUARD || nsslController.isInLockedDownShade()) && (qS.isFullyCollapsed || useSplitShade) } /** * Called by the touch helper when when a gesture has completed all the way and released. */ internal fun onDraggedDown(startingChild: View?, dragLengthY: Int) { if (canDragDown()) { val cancelRunnable = Runnable { logger.logGoingToLockedShadeAborted() setDragDownAmountAnimated(0f) } if (nsslController.isInLockedDownShade()) { logger.logDraggedDownLockDownShade(startingChild) statusBarStateController.setLeaveOpenOnKeyguardHide(true) statusbar.dismissKeyguardThenExecute(OnDismissAction { nextHideKeyguardNeedsNoAnimation = true false }, cancelRunnable, false /* afterKeyguardGone */) } else { logger.logDraggedDown(startingChild, dragLengthY) if (!ambientState.isDozing() || startingChild != null) { // go to locked shade while animating the drag down amount from its current // value val animationHandler = { delay: Long -> if (startingChild is ExpandableNotificationRow) { startingChild.onExpandedByGesture( true /* drag down is always an open */) } notificationPanelController.animateToFullShade(delay) notificationPanelController.setTransitionToFullShadeAmount(0f, true /* animated */, delay) // Let's reset ourselves, ready for the next animation // changing to shade locked will make isInLockDownShade true, so let's // override that forceApplyAmount = true // Reset the behavior. At this point the animation is already started dragDownAmount = 0f forceApplyAmount = false } goToLockedShadeInternal(startingChild, animationHandler, cancelRunnable) } } } else { logger.logUnSuccessfulDragDown(startingChild) setDragDownAmountAnimated(0f) } } /** * Called by the touch helper when the drag down was aborted and should be reset. */ internal fun onDragDownReset() { logger.logDragDownAborted() nsslController.setDimmed(true /* dimmed */, true /* animated */) nsslController.resetScrollPosition() nsslController.resetCheckSnoozeLeavebehind() setDragDownAmountAnimated(0f) } /** * The user has dragged either above or below the threshold which changes the dimmed state. * @param above whether they dragged above it */ internal fun onCrossedThreshold(above: Boolean) { nsslController.setDimmed(!above /* dimmed */, true /* animate */) } /** * Called by the touch helper when the drag down was started */ internal fun onDragDownStarted(startingChild: ExpandableView?) { logger.logDragDownStarted(startingChild) nsslController.cancelLongPress() nsslController.checkSnoozeLeavebehind() dragDownAnimator?.apply { if (isRunning) { logger.logAnimationCancelled(isPulse = false) cancel() } } } /** * Do we need a falsing check currently? */ internal val isFalsingCheckNeeded: Boolean get() = statusBarStateController.state == StatusBarState.KEYGUARD /** * Is dragging down enabled on a given view * @param view The view to check or `null` to check if it's enabled at all */ internal fun isDragDownEnabledForView(view: ExpandableView?): Boolean { if (isDragDownAnywhereEnabled) { return true } if (nsslController.isInLockedDownShade()) { if (view == null) { // Dragging down is allowed in general return true } if (view is ExpandableNotificationRow) { // Only drag down on sensitive views, otherwise the ExpandHelper will take this return view.entry.isSensitive } } return false } /** * @return if drag down is enabled anywhere, not just on selected views. */ internal val isDragDownAnywhereEnabled: Boolean get() = (statusBarStateController.getState() == StatusBarState.KEYGUARD && !keyguardBypassController.bypassEnabled && (qS.isFullyCollapsed || useSplitShade)) /** * The amount in pixels that the user has dragged down. */ internal var dragDownAmount = 0f set(value) { if (field != value || forceApplyAmount) { field = value if (!nsslController.isInLockedDownShade() || field == 0f || forceApplyAmount) { nsslController.setTransitionToFullShadeAmount(field) notificationPanelController.setTransitionToFullShadeAmount(field, false /* animate */, 0 /* delay */) val progress = MathUtils.saturate(dragDownAmount / scrimTransitionDistance) qS.setTransitionToFullShadeAmount(field, progress) // TODO: appear media also in split shade val mediaAmount = if (useSplitShade) 0f else field mediaHierarchyManager.setTransitionToFullShadeAmount(mediaAmount) transitionToShadeAmountCommon(field) } } } private fun transitionToShadeAmountCommon(dragDownAmount: Float) { val scrimProgress = MathUtils.saturate(dragDownAmount / scrimTransitionDistance) scrimController.setTransitionToFullShadeProgress(scrimProgress) // Fade out all content only visible on the lockscreen notificationPanelController.setKeyguardOnlyContentAlpha(1.0f - scrimProgress) depthController.transitionToFullShadeProgress = scrimProgress udfpsKeyguardViewController?.setTransitionToFullShadeProgress(scrimProgress) } private fun setDragDownAmountAnimated( target: Float, delay: Long = 0, endlistener: (() -> Unit)? = null ) { logger.logDragDownAnimation(target) val dragDownAnimator = ValueAnimator.ofFloat(dragDownAmount, target) dragDownAnimator.interpolator = Interpolators.FAST_OUT_SLOW_IN dragDownAnimator.duration = SPRING_BACK_ANIMATION_LENGTH_MS dragDownAnimator.addUpdateListener { animation: ValueAnimator -> dragDownAmount = animation.animatedValue as Float } if (delay > 0) { dragDownAnimator.startDelay = delay } if (endlistener != null) { dragDownAnimator.addListener(object : AnimatorListenerAdapter() { override fun onAnimationEnd(animation: Animator?) { endlistener.invoke() } }) } dragDownAnimator.start() this.dragDownAnimator = dragDownAnimator } /** * Animate appear the drag down amount. */ private fun animateAppear(delay: Long = 0) { // changing to shade locked will make isInLockDownShade true, so let's override // that forceApplyAmount = true // we set the value initially to 1 pixel, since that will make sure we're // transitioning to the full shade. this is important to avoid flickering, // as the below animation only starts once the shade is unlocked, which can // be a couple of frames later. if we're setting it to 0, it will use the // default inset and therefore flicker dragDownAmount = 1f setDragDownAmountAnimated(fullTransitionDistance.toFloat(), delay = delay) { // End listener: // Reset dragDownAmount = 0f forceApplyAmount = false } } /** * Ask this controller to go to the locked shade, changing the state change and doing * an animation, where the qs appears from 0 from the top * * If secure with redaction: Show bouncer, go to unlocked shade. * If secure without redaction or no security: Go to [StatusBarState.SHADE_LOCKED]. * * @param expandView The view to expand after going to the shade * @param needsQSAnimation if this needs the quick settings to slide in from the top or if * that's already handled separately */ @JvmOverloads fun goToLockedShade(expandedView: View?, needsQSAnimation: Boolean = true) { val isKeyguard = statusBarStateController.state == StatusBarState.KEYGUARD logger.logTryGoToLockedShade(isKeyguard) if (isKeyguard) { val animationHandler: ((Long) -> Unit)? if (needsQSAnimation) { // Let's use the default animation animationHandler = null } else { // Let's only animate notifications animationHandler = { delay: Long -> notificationPanelController.animateToFullShade(delay) } } goToLockedShadeInternal(expandedView, animationHandler, cancelAction = null) } } /** * If secure with redaction: Show bouncer, go to unlocked shade. * * If secure without redaction or no security: Go to [StatusBarState.SHADE_LOCKED]. * * @param expandView The view to expand after going to the shade. * @param animationHandler The handler which performs the go to full shade animation. If null, * the default handler will do the animation, otherwise the caller is * responsible for the animation. The input value is a Long for the * delay for the animation. * @param cancelAction The runnable to invoke when the transition is aborted. This happens if * the user goes to the bouncer and goes back. */ private fun goToLockedShadeInternal( expandView: View?, animationHandler: ((Long) -> Unit)? = null, cancelAction: Runnable? = null ) { if (statusbar.isShadeDisabled) { cancelAction?.run() logger.logShadeDisabledOnGoToLockedShade() return } var userId: Int = lockScreenUserManager.getCurrentUserId() var entry: NotificationEntry? = null if (expandView is ExpandableNotificationRow) { entry = expandView.entry entry.setUserExpanded(true /* userExpanded */, true /* allowChildExpansion */) // Indicate that the group expansion is changing at this time -- this way the group // and children backgrounds / divider animations will look correct. entry.setGroupExpansionChanging(true) userId = entry.sbn.userId } var fullShadeNeedsBouncer = (!lockScreenUserManager.userAllowsPrivateNotificationsInPublic( lockScreenUserManager.getCurrentUserId()) || !lockScreenUserManager.shouldShowLockscreenNotifications() || falsingCollector.shouldEnforceBouncer()) if (keyguardBypassController.bypassEnabled) { fullShadeNeedsBouncer = false } if (lockScreenUserManager.isLockscreenPublicMode(userId) && fullShadeNeedsBouncer) { statusBarStateController.setLeaveOpenOnKeyguardHide(true) var onDismissAction: OnDismissAction? = null if (animationHandler != null) { onDismissAction = OnDismissAction { // We're waiting on keyguard to hide before triggering the action, // as that will make the animation work properly animationHandlerOnKeyguardDismiss = animationHandler false } } val cancelHandler = Runnable { draggedDownEntry?.apply { setUserLocked(false) notifyHeightChanged(false /* needsAnimation */) draggedDownEntry = null } cancelAction?.run() } logger.logShowBouncerOnGoToLockedShade() statusbar.showBouncerWithDimissAndCancelIfKeyguard(onDismissAction, cancelHandler) draggedDownEntry = entry } else { logger.logGoingToLockedShade(animationHandler != null) if (statusBarStateController.isDozing) { // Make sure we don't go back to keyguard immediately again after waking up isWakingToShadeLocked = true } statusBarStateController.setState(StatusBarState.SHADE_LOCKED) // This call needs to be after updating the shade state since otherwise // the scrimstate resets too early if (animationHandler != null) { animationHandler.invoke(0 /* delay */) } else { performDefaultGoToFullShadeAnimation(0) } } } /** * Notify this handler that the keyguard was just dismissed and that a animation to * the full shade should happen. * * @param delay the delay to do the animation with * @param previousState which state were we in when we hid the keyguard? */ fun onHideKeyguard(delay: Long, previousState: Int) { logger.logOnHideKeyguard() if (animationHandlerOnKeyguardDismiss != null) { animationHandlerOnKeyguardDismiss!!.invoke(delay) animationHandlerOnKeyguardDismiss = null } else { if (nextHideKeyguardNeedsNoAnimation) { nextHideKeyguardNeedsNoAnimation = false } else if (previousState != StatusBarState.SHADE_LOCKED) { // No animation necessary if we already were in the shade locked! performDefaultGoToFullShadeAnimation(delay) } } draggedDownEntry?.apply { setUserLocked(false) draggedDownEntry = null } } /** * Perform the default appear animation when going to the full shade. This is called when * not triggered by gestures, e.g. when clicking on the shelf or expand button. */ private fun performDefaultGoToFullShadeAnimation(delay: Long) { logger.logDefaultGoToFullShadeAnimation(delay) notificationPanelController.animateToFullShade(delay) animateAppear(delay) } // // PULSE EXPANSION // /** * Set the height how tall notifications are pulsing. This is only set whenever we are expanding * from a pulse and determines how much the notifications are expanded. */ fun setPulseHeight(height: Float, animate: Boolean = false) { if (animate) { val pulseHeightAnimator = ValueAnimator.ofFloat(pulseHeight, height) pulseHeightAnimator.interpolator = Interpolators.FAST_OUT_SLOW_IN pulseHeightAnimator.duration = SPRING_BACK_ANIMATION_LENGTH_MS pulseHeightAnimator.addUpdateListener { animation: ValueAnimator -> setPulseHeight(animation.animatedValue as Float) } pulseHeightAnimator.start() this.pulseHeightAnimator = pulseHeightAnimator } else { pulseHeight = height val overflow = nsslController.setPulseHeight(height) notificationPanelController.setOverStrechAmount(overflow) val transitionHeight = if (keyguardBypassController.bypassEnabled) height else 0.0f transitionToShadeAmountCommon(transitionHeight) } } /** * Finish the pulse animation when the touch interaction finishes * @param cancelled was the interaction cancelled and this is a reset? */ fun finishPulseAnimation(cancelled: Boolean) { logger.logPulseExpansionFinished(cancelled) if (cancelled) { setPulseHeight(0f, animate = true) } else { notificationPanelController.onPulseExpansionFinished() setPulseHeight(0f, animate = false) } } /** * Notify this class that a pulse expansion is starting */ fun onPulseExpansionStarted() { logger.logPulseExpansionStarted() pulseHeightAnimator?.apply { if (isRunning) { logger.logAnimationCancelled(isPulse = true) cancel() } } } override fun dump(fd: FileDescriptor, pw: PrintWriter, args: Array) { IndentingPrintWriter(pw, " ").let { it.println("LSShadeTransitionController:") it.increaseIndent() it.println("pulseHeight: $pulseHeight") it.println("useSplitShade: $useSplitShade") it.println("dragDownAmount: $dragDownAmount") it.println("isDragDownAnywhereEnabled: $isDragDownAnywhereEnabled") it.println("isFalsingCheckNeeded: $isFalsingCheckNeeded") it.println("isWakingToShadeLocked: $isWakingToShadeLocked") it.println("hasPendingHandlerOnKeyguardDismiss: " + "${animationHandlerOnKeyguardDismiss != null}") } } } /** * A utility class to enable the downward swipe on the lockscreen to go to the full shade and expand * the notification where the drag started. */ class DragDownHelper( private val falsingManager: FalsingManager, private val falsingCollector: FalsingCollector, private val dragDownCallback: LockscreenShadeTransitionController, context: Context ) : Gefingerpoken { private var dragDownAmountOnStart = 0.0f lateinit var expandCallback: ExpandHelper.Callback lateinit var host: View private var minDragDistance = 0 private var initialTouchX = 0f private var initialTouchY = 0f private var touchSlop = 0f private var slopMultiplier = 0f private val temp2 = IntArray(2) private var draggedFarEnough = false private var startingChild: ExpandableView? = null private var lastHeight = 0f var isDraggingDown = false private set private val isFalseTouch: Boolean get() { return if (!dragDownCallback.isFalsingCheckNeeded) { false } else { falsingManager.isFalseTouch(Classifier.NOTIFICATION_DRAG_DOWN) || !draggedFarEnough } } val isDragDownEnabled: Boolean get() = dragDownCallback.isDragDownEnabledForView(null) init { updateResources(context) } fun updateResources(context: Context) { minDragDistance = context.resources.getDimensionPixelSize( R.dimen.keyguard_drag_down_min_distance) val configuration = ViewConfiguration.get(context) touchSlop = configuration.scaledTouchSlop.toFloat() slopMultiplier = configuration.scaledAmbiguousGestureMultiplier } override fun onInterceptTouchEvent(event: MotionEvent): Boolean { val x = event.x val y = event.y when (event.actionMasked) { MotionEvent.ACTION_DOWN -> { draggedFarEnough = false isDraggingDown = false startingChild = null initialTouchY = y initialTouchX = x } MotionEvent.ACTION_MOVE -> { val h = y - initialTouchY // Adjust the touch slop if another gesture may be being performed. val touchSlop = if (event.classification == MotionEvent.CLASSIFICATION_AMBIGUOUS_GESTURE) touchSlop * slopMultiplier else touchSlop if (h > touchSlop && h > Math.abs(x - initialTouchX)) { falsingCollector.onNotificationStartDraggingDown() isDraggingDown = true captureStartingChild(initialTouchX, initialTouchY) initialTouchY = y initialTouchX = x dragDownCallback.onDragDownStarted(startingChild) dragDownAmountOnStart = dragDownCallback.dragDownAmount return startingChild != null || dragDownCallback.isDragDownAnywhereEnabled } } } return false } override fun onTouchEvent(event: MotionEvent): Boolean { if (!isDraggingDown) { return false } val x = event.x val y = event.y when (event.actionMasked) { MotionEvent.ACTION_MOVE -> { lastHeight = y - initialTouchY captureStartingChild(initialTouchX, initialTouchY) dragDownCallback.dragDownAmount = lastHeight + dragDownAmountOnStart if (startingChild != null) { handleExpansion(lastHeight, startingChild!!) } if (lastHeight > minDragDistance) { if (!draggedFarEnough) { draggedFarEnough = true dragDownCallback.onCrossedThreshold(true) } } else { if (draggedFarEnough) { draggedFarEnough = false dragDownCallback.onCrossedThreshold(false) } } return true } MotionEvent.ACTION_UP -> if (!falsingManager.isUnlockingDisabled && !isFalseTouch && dragDownCallback.canDragDown()) { dragDownCallback.onDraggedDown(startingChild, (y - initialTouchY).toInt()) if (startingChild != null) { expandCallback.setUserLockedChild(startingChild, false) startingChild = null } isDraggingDown = false } else { stopDragging() return false } MotionEvent.ACTION_CANCEL -> { stopDragging() return false } } return false } private fun captureStartingChild(x: Float, y: Float) { if (startingChild == null) { startingChild = findView(x, y) if (startingChild != null) { if (dragDownCallback.isDragDownEnabledForView(startingChild)) { expandCallback.setUserLockedChild(startingChild, true) } else { startingChild = null } } } } private fun handleExpansion(heightDelta: Float, child: ExpandableView) { var hDelta = heightDelta if (hDelta < 0) { hDelta = 0f } val expandable = child.isContentExpandable val rubberbandFactor = if (expandable) { RUBBERBAND_FACTOR_EXPANDABLE } else { RUBBERBAND_FACTOR_STATIC } var rubberband = hDelta * rubberbandFactor if (expandable && rubberband + child.collapsedHeight > child.maxContentHeight) { var overshoot = rubberband + child.collapsedHeight - child.maxContentHeight overshoot *= 1 - RUBBERBAND_FACTOR_STATIC rubberband -= overshoot } child.actualHeight = (child.collapsedHeight + rubberband).toInt() } private fun cancelChildExpansion(child: ExpandableView) { if (child.actualHeight == child.collapsedHeight) { expandCallback.setUserLockedChild(child, false) return } val anim = ObjectAnimator.ofInt(child, "actualHeight", child.actualHeight, child.collapsedHeight) anim.interpolator = Interpolators.FAST_OUT_SLOW_IN anim.duration = SPRING_BACK_ANIMATION_LENGTH_MS anim.addListener(object : AnimatorListenerAdapter() { override fun onAnimationEnd(animation: Animator) { expandCallback.setUserLockedChild(child, false) } }) anim.start() } private fun stopDragging() { falsingCollector.onNotificationStopDraggingDown() if (startingChild != null) { cancelChildExpansion(startingChild!!) startingChild = null } isDraggingDown = false dragDownCallback.onDragDownReset() } private fun findView(x: Float, y: Float): ExpandableView? { host.getLocationOnScreen(temp2) return expandCallback.getChildAtRawPosition(x + temp2[0], y + temp2[1]) } }