AugmentedObject

fun subscribe(session: Session): StateFlow<Collection<AugmentedObject>>

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.repeatOnLifecycle
import androidx.xr.arcore.AugmentedObject
import androidx.xr.runtime.TrackingState
import androidx.xr.runtime.math.Pose
import androidx.xr.scenecore.scene

// Use a coroutine to listen to changes to the set of detected objects.
yourCoroutineScope.launch {
    val activeObjects = mutableMapOf<AugmentedObject, Job>()

    lifecycle.repeatOnLifecycle(Lifecycle.State.RESUMED) {
        val supervisor = SupervisorJob()
        val supervisorScope = CoroutineScope(yourCoroutineScope.coroutineContext + supervisor)
        try {
            AugmentedObject.subscribe(session).collect { augmentedObjects ->
                // The list of detected objects has changed.
                for (obj in augmentedObjects) {

                    // If an object doesn't exist in our set of active objects, set up a
                    // coroutine to respond to its state changes.
                    if (!activeObjects.contains(obj)) {
                        val job =
                            supervisorScope.launch {
                                obj.state.collect {
                                    // if the object is not currently reporting as tracked, then
                                    // we don't want to render it.
                                    if (it.trackingState != TrackingState.TRACKING)
                                        return@collect

                                    // Transform the pose from its original coordinate space to
                                    // one suitable for rendering to the display.
                                    val pose =
                                        it.centerPose.let { p ->
                                            session.scene.perceptionSpace.transformPoseTo(
                                                p,
                                                session.scene.activitySpace,
                                            )
                                        }

                                    // This function is where you'll actually render the object
                                    // to the display.
                                    renderFunction(pose, it.extents, it.category)
                                }
                            }
                        activeObjects[obj] = job
                    }

                    // Likewise, if a object exists in the `activeObjects` map, but not in our
                    // `augmentedObjects` list, it needs to be removed, and its corresponding
                    // job canceled.
                    for (obj in activeObjects.keys.toList()) {
                        if (augmentedObjects.none { it == obj }) {
                            activeObjects.remove(obj)?.cancel()
                        }
                    }
                }
            }
        } finally {
            // cancel any coroutines still running.
            supervisor.cancel()
            activeObjects.clear()
        }
    }
}

open val state: StateFlow<AugmentedObject.State>