FakeJxrPlatformAdapter

open fun addSpatialCapabilitiesChangedListener(
    callbackExecutor: Executor,
    listener: Consumer<SpatialCapabilities>
): Unit

Adds the given {@link Consumer} as a listener to be invoked when this Session's current SpatialCapabilities change. {@link Consumer#accept(SpatialCapabilities)} will be invoked on the given Executor.

open fun borrowReflectionTexture(): TextureResource?

Borrows the reflection texture from the currently set environment IBL.

open fun clearSpatialVisibilityChangedListener(): Unit

Releases the listener previously added by setSpatialVisibilityChangedListener.

open fun createActivityPanelEntity(
    pose: Pose,
    windowBoundsPx: PixelDimensions,
    name: String,
    hostActivity: Activity,
    parent: Entity
): ActivityPanelEntity

Factory function to create ActivityPanel to launch/move activity into.

open fun createAnchorEntity(anchor: Anchor): AnchorEntity

A factory function to create an Anchor entity from a {@link androidx.xr.runtime.internal.Anchor}.

open fun createAnchorEntity(
    bounds: Dimensions,
    planeType: PlaneType,
    planeSemantic: PlaneSemantic,
    searchTimeout: Duration
): AnchorEntity

A factory function to create an Anchor entity.

open fun createAnchorPlacementForPlanes(
    planeTypeFilter: Set<PlaneType>,
    planeSemanticFilter: Set<PlaneSemantic>
): AnchorPlacement

Creates an instance of an AnchorPlacement object.

This can be used in movable components to specify the anchor placement for the entity.

open fun createEntity(pose: Pose, name: String, parent: Entity): Entity

A factory function to create a content-less entity. This entity is used as a connection point for attaching children entities and managing them (i.e. setPose()) as a group.

open fun createGltfEntity(
    pose: Pose,
    loadedGltf: GltfModelResource,
    parentEntity: Entity
): GltfEntity

A factory function to create a SceneCore GltfEntity. The parent may be the activity space or GltfEntity in the scene.

open fun createInteractableComponent(
    executor: Executor,
    listener: InputEventListener
): InteractableComponent

Create an Interactable component.

open fun createLoggingEntity(pose: Pose): LoggingEntity

A function to create a XR Runtime Entity.

open fun createMovableComponent(
    systemMovable: Boolean,
    scaleInZ: Boolean,
    anchorPlacement: Set<AnchorPlacement>,
    shouldDisposeParentAnchor: Boolean
): MovableComponent

Create an instance of MovableComponent. This component allows the user to move the entity.

open fun createPanelEntity(
    context: Context,
    pose: Pose,
    view: View,
    dimensions: Dimensions,
    name: String,
    parent: Entity
): PanelEntity

A factory function to create a platform PanelEntity. The parent can be any entity.

open fun createPanelEntity(
    context: Context,
    pose: Pose,
    view: View,
    pixelDimensions: PixelDimensions,
    name: String,
    parent: Entity
): PanelEntity

A factory function to create a platform PanelEntity. The parent can be any entity.

open fun createPersistedAnchorEntity(uuid: UUID, searchTimeout: Duration): AnchorEntity

A factory function to recreate an Anchor entity which was persisted in a previous session.

open fun createPointerCaptureComponent(
    executor: Executor,
    stateListener: PointerCaptureComponent.StateListener,
    inputListener: InputEventListener
): PointerCaptureComponent

Create an instance of {@link PointerCaptureComponent}. This component allows the user to capture and redirect to itself all input that would be received by entities other than the Entity it is attached to and that entity's children.

In order to enable pointer capture, an application must be in full space and the entity it is attached to must be visible.

Attach this component to the entity to enable pointer capture, detach the component to restore normal input flow.

open fun createResizableComponent(
    minimumSize: Dimensions,
    maximumSize: Dimensions
): ResizableComponent

Create an instance of ResizableComponent. This component allows the user to resize the entity.

open fun createSubspaceNodeEntity(subspaceNode: SubspaceNode, size: Dimensions): SubspaceNodeEntity

A factory function to create a SubspaceNodeEntity.

open fun createSurfaceEntity(
    stereoMode: Int,
    canvasShape: SurfaceEntity.CanvasShape,
    pose: Pose,
    parentEntity: Entity
): SurfaceEntity

A factory function for an Entity which displays drawable surfaces.

open fun createWaterMaterial(isAlphaMapVersion: Boolean): ListenableFuture<MaterialResource>?

Creates a water material by querying it from the system's built-in materials. The future returned by this method will fire listeners on the UI thread if Runnable::run is supplied.

open fun destroyTexture(texture: TextureResource): Unit

Destroys the given texture resource.

open fun destroyWaterMaterial(material: MaterialResource): Unit

Destroys the given water material resource.

open fun dispose(): Unit

Disposes of the resources used by the platform adapter.

open fun getCameraViewActivityPose(cameraType: Int): CameraViewActivityPose?

Returns the CameraViewActivityPose for the specified camera type or null if it is not ready/available.

open fun getReflectionTextureFromIbl(iblToken: ExrImageResource): TextureResource?

Returns the reflection texture from the given IBL.

open fun loadExrImageByAssetName(assetName: String): ListenableFuture<ExrImageResource>

Loads an ExrImage for the given asset name from the assets folder using the Split Engine route.

open fun loadExrImageByByteArray(assetData: ByteArray, assetKey: String): ListenableFuture<ExrImageResource>

Loads an ExrImage from a provided byte array using the Split Engine route.

open fun loadGltfByAssetName(assetName: String): ListenableFuture<GltfModelResource>

Loads glTF Asset for the given asset name from the assets folder using the Split Engine route. The future returned by this method will fire listeners on the UI thread if Runnable::run is supplied.

open fun loadGltfByByteArray(assetData: ByteArray, assetKey: String): ListenableFuture<GltfModelResource>

Loads glTF Asset from a provided byte array. The future returned by this method will fire listeners on the UI thread if Runnable::run is supplied.

open fun loadTexture(assetName: String, sampler: TextureSampler): ListenableFuture<TextureResource>?

Loads a texture resource for the given asset name or URL. The future returned by this method will fire listeners on the UI thread if Runnable::run is supplied.

open fun removeSpatialCapabilitiesChangedListener(
    listener: Consumer<SpatialCapabilities>
): Unit

Releases the given {@link Consumer} from receiving updates when the Session's {@link SpatialCapabilities} change.

open fun requestFullSpaceMode(): Unit

If the primary Activity for the Session that owns this object has focus, causes it to be placed in FullSpace Mode. Otherwise, this call does nothing.

open fun requestHomeSpaceMode(): Unit

If the primary Activity for the Session that owns this object has focus, causes it to be placed in HomeSpace Mode. Otherwise, this call does nothing.

open fun setAlphaMap(material: MaterialResource, alphaMap: TextureResource): Unit

Sets the alpha map for the water material.

open fun setAlphaStepMultiplier(
    material: MaterialResource,
    alphaStepMultiplier: Float
): Unit

Sets the alpha step multiplier for the water material.

open fun setFullSpaceMode(bundle: Bundle): Bundle

Sets the full space mode flag to the given {@link Bundle}.

The {@link Bundle} then could be used to launch an {@link Activity} with requesting to enter full space mode through {@link Activity#startActivity}. If there's a bundle used for customizing how the {@link Activity} should be started by {@link ActivityOptions.toBundle} or {@link androidx.core.app.ActivityOptionsCompat.toBundle}, it's suggested to use the bundle to call this method.

The flag will be ignored when no {@link Intent.FLAG_ACTIVITY_NEW_TASK} is set in the bundle, or it is not started from a focused Activity context.

This flag is also ignored when the {@link android.window.PROPERTY_XR_ACTIVITY_START_MODE} property is set to a value other than XR_ACTIVITY_START_MODE_UNDEFINED in the AndroidManifest.xml file for the activity being launched.

open fun setFullSpaceModeWithEnvironmentInherited(bundle: Bundle): Bundle

Sets the inherit full space mode environment flag to the given {@link Bundle}.

The {@link Bundle} then could be used to launch an {@link Activity} with requesting to enter full space mode while inherit the existing environment through {@link Activity#startActivity}. If there's a bundle used for customizing how the {@link Activity} should be started by {@link ActivityOptions.toBundle} or {@link androidx.core.app.ActivityOptionsCompat.toBundle}, it's suggested to use the bundle to call this method.

When launched, the activity will be in full space mode and also inherits the environment from the launching activity. If the inherited environment needs to be animated, the launching activity has to continue updating the environment even after the activity is put into the stopped state.

The flag will be ignored when no {@link Intent.FLAG_ACTIVITY_NEW_TASK} is set in the intent, or it is not started from a focused Activity context.

The flag will also be ignored when there is no environment to inherit or the activity has its own environment set already.

This flag is ignored too when the {@link android.window.PROPERTY_XR_ACTIVITY_START_MODE} property is set to a value other than XR_ACTIVITY_START_MODE_UNDEFINED in the AndroidManifest.xml file for the activity being launched.

For security reasons, Z testing for the new activity is disabled, and the activity is always drawn on top of the inherited environment. Because Z testing is disabled, the activity should not spatialize itself.

open fun setNormalBoundary(material: MaterialResource, normalBoundary: Float): Unit

Sets the normal boundary for the water material.

open fun setNormalMap(material: MaterialResource, normalMap: TextureResource): Unit

Sets the normal map texture for the water material.

open fun setNormalSpeed(material: MaterialResource, normalSpeed: Float): Unit

Sets the normal speed for the water material.

open fun setNormalTiling(material: MaterialResource, normalTiling: Float): Unit

Sets the normal tiling for the water material.

open fun setNormalZ(material: MaterialResource, normalZ: Float): Unit

Sets the normal z for the water material.

open fun setPreferredAspectRatio(activity: Activity, preferredRatio: Float): Unit

Sets a preferred main panel aspect ratio for home space mode.

The ratio is only applied to the activity. If the activity launches another activity in the same task, the ratio is not applied to the new activity. Also, while the activity is in full space mode, the preference is temporarily removed.

If the activity's current aspect ratio differs from the {@code preferredRatio}, the panel is automatically resized. This resizing preserves the panel's area. To avoid runtime resizing, consider specifying the desired aspect ratio in your {@code AndroidManifest.xml}. This ensures your activity launches with the preferred aspect ratio from the start.

open fun setReflectionCube(
    material: MaterialResource,
    reflectionCube: TextureResource
): Unit

Sets the reflection cube texture for the water material.

open fun setSpatialVisibilityChangedListener(
    callbackExecutor: Executor,
    listener: Consumer<SpatialVisibility>
): Unit

Sets the listener to be invoked when the spatial visibility of the rendered content of the entire scene (all entities, including children of anchors and activitySpace) changes within the user's field of view.

This API only checks if the bounds of the renderable content are within the user's field of view. It does not check if the rendered content is visible to the user. For example, if the user is looking straight ahead, and there's only a single invisible child entity (alpha = 0) in front of the user, this API will return SpatialVisibility.WITHIN_FOV even though the user cannot see anything.

The listener is invoked on the provided executor. If the app intends to modify the UI elements/views during the callback, the app should provide the thread executor that is appropriate for the UI operations. For example, if the app is using the main thread to render the UI, the app should provide the main thread (Looper.getMainLooper()) executor. If the app is using a separate thread to render the UI, the app should provide the executor for that thread.

There can only be one listener set at a time. If a new listener is set, the previous listener will be released.

open fun startRenderer(): Unit

Starts the renderer.

open fun stopRenderer(): Unit

Stops the renderer.

open val activitySpace: ActivitySpace

Returns the Activity Space entity at the root of the scene.

open val activitySpaceRootImpl: Entity

Returns the entity that represents the ActivitySpace root.

SDK's factory methods are expected to use this entity as the default parent for all content entities when no parent is specified.

open val audioTrackExtensionsWrapper: AudioTrackExtensionsWrapper

Returns a AudioTrackExtensionsWrapper instance.

open val headActivityPose: HeadActivityPose?

Returns the HeadActivityPose for the session or null if it not ready.

open val mainPanelEntity: PanelEntity

Get the PanelEntity associated with the main window for the Runtime.

open val mediaPlayerExtensionsWrapper: MediaPlayerExtensionsWrapper

Returns a MediaPlayerExtensionsWrapper instance.

open val perceptionSpaceActivityPose: PerceptionSpaceActivityPose

Returns the PerceptionSpaceActivityPose for the Session.

open val soundPoolExtensionsWrapper: SoundPoolExtensionsWrapper

Returns a SoundPoolExtensionsWrapper instance.

open val spatialCapabilities: SpatialCapabilities

Return the Spatial Capabilities set that are currently supported by the platform.

open val spatialEnvironment: SpatialEnvironment

Returns the Environment for the Session.