Merge "Fix issues when shade window is moved very fast between displays" into main

     */

    @Synchronized

    fun onShadeDisplayChanging(displayId: Int) {

        previousJob?.cancel(CancellationException("New shade move in progress"))

        previousJob?.cancel(CancellationException("New shade move in progress to $displayId"))

        previousJob = bgScope.launch { onShadeDisplayChangingAsync(displayId) }

    }

            val reason =

                when (e) {

                    is CancellationException ->

                        "Shade move cancelled as a new move is being done " +

                            "before the previous one finished."

                        "Shade move to $displayId cancelled as a new move is being done " +

                            "before the previous one finished. Message: ${e.message}"

                    else -> "Shade move cancelled."

                }

package com.android.systemui.shade.domain.interactor

import android.util.Log

import com.android.systemui.dagger.SysUISingleton

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

import com.android.systemui.scene.shared.flag.SceneContainerFlag

import com.android.systemui.util.kotlin.Utils.Companion.combineState

import javax.inject.Inject

import kotlin.coroutines.CoroutineContext

import kotlin.time.Duration

import kotlin.time.Duration.Companion.seconds

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.first

import kotlinx.coroutines.withContext

import kotlinx.coroutines.withTimeout

import kotlinx.coroutines.withTimeoutOrNull

/**

 * Wrapper around [ShadeInteractor] to facilitate expansion and collapse of Notifications and quick

    }

}

private val EXPAND_COLLAPSE_TIMEOUT: Duration = 1.seconds

@SysUISingleton

class ShadeExpandedStateInteractorImpl

@Inject

private suspend fun StateFlow<Float>.waitUntil(f: Float, coroutineContext: CoroutineContext) {

    // it's important to not do this in the main thread otherwise it will block any rendering.

    withContext(coroutineContext) {

        withTimeout(1.seconds) { traceWaitForExpansion(expansion = f) { first { it == f } } }

        withTimeoutOrNull(EXPAND_COLLAPSE_TIMEOUT) {

            traceWaitForExpansion(expansion = f) { first { it == f } }

        }

            ?: Log.e(

                "ShadeExpStateInteractor",

                "Timed out after ${EXPAND_COLLAPSE_TIMEOUT.inWholeMilliseconds}ms while waiting " +

                        "for expansion to match $f. Current one: $value",

            )

    }

}