Plane

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

open fun createAnchor(pose: Pose): AnchorCreateResult

open val state: StateFlow<Plane.State>

import androidx.lifecycle.Lifecycle
import androidx.lifecycle.repeatOnLifecycle
import androidx.xr.arcore.Plane
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 planes.
yourCoroutineScope.launch {
    val activePlanes = mutableMapOf<Plane, Job>()

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

                    // If a plane doesn't exist in our set of active planes, set up a
                    // coroutine to respond to its state changes.
                    if (!activePlanes.contains(plane)) {
                        val job =
                            supervisorScope.launch {
                                plane.state.collect {
                                    // if the plane 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 plane
                                    // to the display.
                                    renderFunction(pose, it.extents, it.vertices, it.label)
                                }
                            }
                        activePlanes[plane] = job
                    }

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

val type: Plane.Type

val Plane.stateAsFlowable: Flowable<Plane.State>