Anchor

public static final @NonNull AnchorResult create(@NonNull Session session, @NonNull Pose pose)

import androidx.xr.arcore.Anchor
import androidx.xr.arcore.AnchorCreateResourcesExhausted
import androidx.xr.arcore.AnchorCreateSuccess
import androidx.xr.arcore.AnchorCreateTrackingUnavailable
import androidx.xr.arcore.AnchorRuntimeFailureException
import androidx.xr.arcore.AnchorUnsupportedLocationException
import androidx.xr.arcore.TrackingState
import androidx.xr.runtime.math.Pose
import androidx.xr.scenecore.scene

// We need to first translate the pose from activity space to perception space.
val perceptionPose =
    session.scene.activitySpace.transformPoseTo(pose, session.scene.perceptionSpace)

// Now we can try and create the anchor.
// Anchor creation can fail for a variety of reasons, so we need to handle those various cases.
try {
    when (val anchorResult = Anchor.create(session, perceptionPose)) {
        is AnchorCreateSuccess -> {
            // Our call succeeded, and we can now make use of our new anchor. In this example,
            // we are simply going to convert our pose back to activity space and then pass it
            // to a rendering function for rendering.
            val anchor = anchorResult.anchor
            yourCoroutineScope.launch {
                anchor.state.collect {
                    // Early out if tracking is lost on the anchor; we only want to render it
                    // when we have confidence it is in the correct position.
                    if (it.trackingState != TrackingState.TRACKING) return@collect

                    // Convert our anchor pose back into activity space.
                    val activityPose =
                        session.scene.perceptionSpace.transformPoseTo(
                            it.pose,
                            session.scene.activitySpace,
                        )

                    // Render the anchor.
                    yourAnchorRenderingFunction(activityPose)
                }
            }
        }
        is AnchorCreateResourcesExhausted -> {
            // In order to conserve resources, runtimes impose a limit on how many anchors may
            // be in use concurrently. When that limit is reached, subsequent `Anchor.create()`
            // will fail with this result. Depending on your use case, you can either notify the
            // user that no more anchors can be created, or you can try and free up resources by
            // removing older anchors if they're no longer necessary.
        }
        is AnchorCreateTrackingUnavailable -> {
            // This result indicates that tracking is currently unavailable. Depending on the
            // situation, tracking may or may not return, so this result could just indicate a
            // temporary problem. Repeatedly getting this result for a prolonged period of time
            // may indicate a non-recoverable loss of tracking, which will likely severely
            // impact application functionality.
        }
        else -> {
            // Exhaustive when not allowed for AnchorResult.
        }
    }
} catch (e: AnchorUnsupportedLocationException) {
    // This exception is thrown when the underlying runtime does not support creating an anchor
    // at the provided location.
} catch (e: AnchorRuntimeFailureException) {
    // This exception is thrown when an unspecified error was encountered in the runtime while
    // attempting to create the anchor.
}

public final void detach()

public boolean equals(Object other)

public static final @NonNull List<@NonNull UUID> getPersistedAnchorUuids(@NonNull Session session)

public @NonNull StateFlow<@NonNull Anchor.State> getState()

public int hashCode()

public static final @NonNull AnchorResult load(@NonNull Session session, @NonNull UUID uuid)

public final @NonNull UUID persist()

public static final void unpersist(@NonNull Session session, @NonNull UUID uuid)