Files
Flexera-Launcher/quickstep/src/com/android/quickstep/util/unfold/PreemptiveUnfoldTransitionProgressProvider.kt
T
Nick Chameyev 705c665c06 [Unfold animation] Start Launcher animation preemptively to synchronize the first frame
Starts unfold animation in Launcher right after receiving
configuration change for the unfolded screen.
This makes sure that before we unblock the screen we
have the first frame of the unfold animation ready
in Launcher (transformations are applied).

Bug: 271099882
Test: atest com.android.systemui.unfold.util.PreemptiveUnfoldTransitionProgressProviderTest
Test: manual testing fold/unfold, checking perfetto traces
Test: test with flag enabled/disabled
Change-Id: Icb8f91f9264248600d4bed14811445f50aac99c7
2023-05-03 11:35:03 +01:00

162 lines
6.0 KiB
Kotlin

/*
* Copyright (C) 2023 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.quickstep.util.unfold
import android.os.Handler
import android.os.Trace
import android.util.Log
import com.android.systemui.unfold.UnfoldTransitionProgressProvider
import com.android.systemui.unfold.UnfoldTransitionProgressProvider.TransitionProgressListener
/**
* Transition progress provider wrapper that can preemptively start the transition on demand
* without relying on the source provider. When the source provider has started the animation
* it switches to it.
*
* This might be useful when we want to synchronously start the unfold animation and render
* the first frame during turning on the screen. For example, this is used in Launcher where
* we need to render the first frame of the animation immediately after receiving a configuration
* change event so Window Manager will wait for this frame to be rendered before unblocking
* the screen. We can't rely on the original transition progress as it starts the animation
* after the screen fully turned on (and unblocked), at this moment it is already too late to
* start the animation.
*
* Using this provider we could render the first frame preemptively by sending 'transition started'
* and '0' transition progress before the original progress provider sends these events.
*/
class PreemptiveUnfoldTransitionProgressProvider(
private val source: UnfoldTransitionProgressProvider,
private val handler: Handler
) : UnfoldTransitionProgressProvider, TransitionProgressListener {
private val timeoutRunnable = Runnable {
if (isRunning) {
listeners.forEach { it.onTransitionFinished() }
onPreemptiveStartFinished()
Log.wtf(TAG, "Timeout occurred when waiting for the source transition to start")
}
}
private val listeners = arrayListOf<TransitionProgressListener>()
private var isPreemptivelyRunning = false
private var isSourceRunning = false
private val isRunning: Boolean
get() = isPreemptivelyRunning || isSourceRunning
private val sourceListener =
object : TransitionProgressListener {
override fun onTransitionStarted() {
handler.removeCallbacks(timeoutRunnable)
if (!isRunning) {
listeners.forEach { it.onTransitionStarted() }
}
onPreemptiveStartFinished()
isSourceRunning = true
}
override fun onTransitionProgress(progress: Float) {
if (isRunning) {
listeners.forEach { it.onTransitionProgress(progress) }
isSourceRunning = true
}
}
override fun onTransitionFinishing() {
if (isRunning) {
listeners.forEach { it.onTransitionFinishing() }
isSourceRunning = true
}
}
override fun onTransitionFinished() {
if (isRunning) {
listeners.forEach { it.onTransitionFinished() }
}
isSourceRunning = false
onPreemptiveStartFinished()
handler.removeCallbacks(timeoutRunnable)
}
}
fun init() {
source.addCallback(sourceListener)
}
/**
* Starts the animation preemptively.
*
* - If the source provider is already running, this method won't change any behavior
* - If the source provider has not started running yet, it will call onTransitionStarted
* for all listeners and optionally onTransitionProgress(initialProgress) if supplied.
* When the source provider starts the animation it will switch to send progress and finished
* events from it.
* If the source provider won't start the animation within a timeout, the animation will be
* cancelled and onTransitionFinished will be delivered to the current listeners.
*/
@JvmOverloads
fun preemptivelyStartTransition(initialProgress: Float? = null) {
if (!isRunning) {
Trace.beginAsyncSection("$TAG#startedPreemptively", 0)
listeners.forEach { it.onTransitionStarted() }
initialProgress?.let { progress ->
listeners.forEach { it.onTransitionProgress(progress) }
}
handler.removeCallbacks(timeoutRunnable)
handler.postDelayed(timeoutRunnable, PREEMPTIVE_UNFOLD_TIMEOUT_MS)
}
isPreemptivelyRunning = true
}
fun cancelPreemptiveStart() {
handler.removeCallbacks(timeoutRunnable)
if (isRunning) {
listeners.forEach { it.onTransitionFinished() }
}
onPreemptiveStartFinished()
}
private fun onPreemptiveStartFinished() {
if (isPreemptivelyRunning) {
Trace.endAsyncSection("$TAG#startedPreemptively", 0)
isPreemptivelyRunning = false
}
}
override fun destroy() {
handler.removeCallbacks(timeoutRunnable)
source.removeCallback(sourceListener)
source.destroy()
}
override fun addCallback(listener: TransitionProgressListener) {
listeners += listener
}
override fun removeCallback(listener: TransitionProgressListener) {
listeners -= listener
}
}
const val TAG = "PreemptiveUnfoldTransitionProgressProvider"
const val PREEMPTIVE_UNFOLD_TIMEOUT_MS = 1700L