Merge "[SysUI][Compose] Add support for adding unsafe LifecycleRegisty to...

 */

object ComposeInitializer {

    /** Function to be called on your window root view's [View.onAttachedToWindow] function. */

    fun onAttachedToWindow(root: View) {

    @JvmOverloads

    fun onAttachedToWindow(root: View, useSeparateThreadUnsafe: Boolean = false) {

        if (root.findViewTreeLifecycleOwner() != null) {

            error("root $root already has a LifecycleOwner")

        }

        // The lifecycle owner, which is STARTED when [root] is visible and RESUMED when [root] is

        // both visible and focused.

        val lifecycleOwner = ViewLifecycleOwner(root)

        val lifecycleOwner = ViewLifecycleOwner(root, useSeparateThreadUnsafe)

        // We create a trivial implementation of [SavedStateRegistryOwner] that does not do any save

        // or restore because SystemUI process is always running and top-level windows using this

package com.android.systemui.lifecycle

import android.annotation.SuppressLint

import android.view.View

import android.view.ViewTreeObserver

import androidx.annotation.MainThread

import androidx.lifecycle.LifecycleOwner

import androidx.lifecycle.LifecycleRegistry

import androidx.lifecycle.lifecycleScope

import com.android.app.tracing.coroutines.launchTraced as launch

import com.android.systemui.coroutines.newTracingContext

import com.android.systemui.util.Assert

import com.android.systemui.utils.coroutines.flow.conflatedCallbackFlow

import kotlinx.coroutines.flow.emptyFlow

import kotlinx.coroutines.flow.map

import kotlinx.coroutines.flow.onStart

import com.android.app.tracing.coroutines.launchTraced as launch

/**

 * Runs the given [block] every time the [View] becomes attached (or immediately after calling this

 * └───────────────┴───────────────────┴──────────────┴─────────────────┘

 * ```

 */

class ViewLifecycleOwner(private val view: View) : LifecycleOwner {

class ViewLifecycleOwner(private val view: View, useSeparateThreadUnsafe: Boolean = false) :

    LifecycleOwner {

    private val windowVisibleListener =

        ViewTreeObserver.OnWindowVisibilityChangeListener { updateState() }

    private val windowFocusListener = ViewTreeObserver.OnWindowFocusChangeListener { updateState() }

    private val registry = LifecycleRegistry(this)

    @SuppressLint("VisibleForTests") // required due to "createUnsafe" usage

    private val registry =

        if (useSeparateThreadUnsafe) {

            LifecycleRegistry.createUnsafe(this)

        } else {

            LifecycleRegistry(this)

        }

    fun onCreate() {

        registry.currentState = Lifecycle.State.CREATED

     * Indicates that the [View] is attached to a [android.view.Window], and the window is visible

     * and focused.

     */

    FOCUSED

    FOCUSED,

}

private val View.isAttached