Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 53f6ece1 authored by Nick Chameyev's avatar Nick Chameyev Committed by Automerger Merge Worker
Browse files

Merge changes I3dc2590f,I59c57cbc into 24D1-dev am: 45b19f36 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/26485131



Change-Id: I3228fd0da5f3f673b9f1f797290e619ba8364fbe
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents b0b6dee5 45b19f36

packages/SystemUI/src/com/android/systemui/unfold/FoldLightRevealOverlayAnimation.kt

+57 −32
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 


package com.android.systemui.unfold



import android.animation.Animator

import android.animation.AnimatorListenerAdapter

import android.animation.ValueAnimator

import android.annotation.BinderThread

import android.content.Context
@@ -23,7 +25,6 @@ import android.os.Handler 
import android.os.SystemProperties

import android.util.Log

import android.view.animation.DecelerateInterpolator

import androidx.core.animation.addListener

import com.android.internal.foldables.FoldLockSettingAvailabilityProvider

import com.android.systemui.dagger.qualifiers.Background

import com.android.systemui.display.data.repository.DeviceStateRepository
@@ -36,17 +37,25 @@ import com.android.systemui.unfold.FullscreenLightRevealAnimationController.Comp 
import com.android.systemui.unfold.dagger.UnfoldBg

import com.android.systemui.util.animation.data.repository.AnimationStatusRepository

import javax.inject.Inject

import kotlin.coroutines.resume

import kotlinx.coroutines.CompletableDeferred

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.TimeoutCancellationException

import kotlinx.coroutines.android.asCoroutineDispatcher

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.catch

import kotlinx.coroutines.flow.distinctUntilChanged

import kotlinx.coroutines.flow.filter

import kotlinx.coroutines.flow.first

import kotlinx.coroutines.flow.flatMapLatest

import kotlinx.coroutines.flow.flow

import kotlinx.coroutines.flow.map

import kotlinx.coroutines.flow.onCompletion

import kotlinx.coroutines.launch

import kotlinx.coroutines.suspendCancellableCoroutine

import kotlinx.coroutines.withTimeout



@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)

class FoldLightRevealOverlayAnimation

@Inject

constructor(
@@ -61,6 +70,9 @@ constructor( 


    private val revealProgressValueAnimator: ValueAnimator =

        ValueAnimator.ofFloat(ALPHA_OPAQUE, ALPHA_TRANSPARENT)

    private val areAnimationEnabled: Flow<Boolean>

        get() = animationStatusRepository.areAnimationsEnabled()



    private lateinit var controller: FullscreenLightRevealAnimationController

    @Volatile private var readyCallback: CompletableDeferred<Runnable>? = null
@@ -89,33 +101,31 @@ constructor( 


        applicationScope.launch(bgHandler.asCoroutineDispatcher()) {

            deviceStateRepository.state

                .map { it != DeviceStateRepository.DeviceState.FOLDED }

                .map { it == DeviceStateRepository.DeviceState.FOLDED }

                .distinctUntilChanged()

                .filter { isUnfolded -> isUnfolded }

                .collect { controller.ensureOverlayRemoved() }

        }



        applicationScope.launch(bgHandler.asCoroutineDispatcher()) {

            deviceStateRepository.state

                .filter {

                    animationStatusRepository.areAnimationsEnabled().first() &&

                        it == DeviceStateRepository.DeviceState.FOLDED

                .flatMapLatest { isFolded ->

                    flow<Nothing> {

                            if (!areAnimationEnabled.first() || !isFolded) {

                                return@flow

                            }

                .collect {

                    try {

                            withTimeout(WAIT_FOR_ANIMATION_TIMEOUT_MS) {

                                readyCallback = CompletableDeferred()

                                val onReady = readyCallback?.await()

                                readyCallback = null

                                controller.addOverlay(ALPHA_OPAQUE, onReady)

                                waitForScreenTurnedOn()

                            }

                            playFoldLightRevealOverlayAnimation()

                        }

                    } catch (e: TimeoutCancellationException) {

                        Log.e(TAG, "Fold light reveal animation timed out")

                        ensureOverlayRemovedInternal()

                        .catchTimeoutAndLog()

                        .onCompletion {

                            controller.ensureOverlayRemoved()

                            val onReady = readyCallback?.takeIf { it.isCompleted }?.getCompleted()

                            onReady?.run()

                            readyCallback = null

                        }

                }

                .collect {}

        }

    }
@@ -128,19 +138,34 @@ constructor( 
        powerInteractor.screenPowerState.filter { it == ScreenPowerState.SCREEN_ON }.first()

    }



    private fun ensureOverlayRemovedInternal() {

        revealProgressValueAnimator.cancel()

        controller.ensureOverlayRemoved()

    }



    private fun playFoldLightRevealOverlayAnimation() {

    private suspend fun playFoldLightRevealOverlayAnimation() {

        revealProgressValueAnimator.duration = ANIMATION_DURATION

        revealProgressValueAnimator.interpolator = DecelerateInterpolator()

        revealProgressValueAnimator.addUpdateListener { animation ->

            controller.updateRevealAmount(animation.animatedFraction)

        }

        revealProgressValueAnimator.addListener(onEnd = { controller.ensureOverlayRemoved() })

        revealProgressValueAnimator.start()

        revealProgressValueAnimator.startAndAwaitCompletion()

    }



    private suspend fun ValueAnimator.startAndAwaitCompletion(): Unit =

        suspendCancellableCoroutine { continuation ->

            val listener =

                object : AnimatorListenerAdapter() {

                    override fun onAnimationEnd(animation: Animator) {

                        continuation.resume(Unit)

                        removeListener(this)

                    }

                }

            addListener(listener)

            continuation.invokeOnCancellation { removeListener(listener) }

            start()

        }



    private fun <T> Flow<T>.catchTimeoutAndLog() = catch { exception ->

        when (exception) {

            is TimeoutCancellationException -> Log.e(TAG, "Fold light reveal animation timed out")

            else -> throw exception

        }

    }



    private companion object {