L'SDK Android XR è ora disponibile in Anteprima per gli sviluppatori. Vorremmo sapere cosa ne pensi. Per contattarci, visita la nostra pagina di assistenza.

Questa pagina è stata tradotta dall'API Cloud Translation.

Estensione OpenXR XR_ANDROID_device_anchor_persistence

Stringa del nome

XR_ANDROID_device_anchor_persistence

Tipo di estensione

Estensione dell'istanza

Numero di estensione registrato

458

Revisione

Dipendenze di estensioni e versioni

XR_EXT_uuid e XR_ANDROID_trackables

Data ultima modifica

2024-10-10

Stato IP

Nessuna rivendicazione IP nota.

Collaboratori

Nihav Jain, Google

Levana Chen, Google

Spencer Quin, Google

Kenny Vercaemer, Google

Panoramica

Questa estensione consente all'applicazione di mantenere, recuperare e annullare la persistenza degli ancoraggi sul dispositivo corrente per l'utente corrente, tra applicazioni e sessioni del dispositivo.

Controlla la funzionalità del sistema

La struttura XrSystemDeviceAnchorPersistencePropertiesANDROID è definita come:

typedef struct XrSystemDeviceAnchorPersistencePropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsAnchorPersistence;
} XrSystemDeviceAnchorPersistencePropertiesANDROID;

Descrizioni dei membri

type è il XrStructureType di questa struttura.
next è NULL o un puntatore alla struttura successiva in una catena di strutture. Queste strutture non sono definite in OpenXR di base o in questa estensione.
supportsAnchorPersistence è un XrBool32 che indica se il sistema corrente supporta la persistenza degli ancoraggi per gli ancoraggi spaziali.

Un'applicazione può verificare se il sistema è in grado di mantenere permanenti gli ancoraggi spaziali (vedi xrCreateAnchorSpaceANDROID) estendendo XrSystemProperties con la struttura XrSystemDeviceAnchorPersistencePropertiesANDROID quando chiama xrGetSystemProperties. Per gli ancoraggi tracciabili supportati, un'applicazione può utilizzare xrEnumerateSupportedPersistenceAnchorTypesANDROID per eseguire query sui tipi supportati.

Se per supportsAnchorPersistence viene restituito XR_FALSE, XR_ERROR_FEATURE_UNSUPPORTED verrà restituito dalle funzioni di persistenza dell'ancora del dispositivo che operano su un'ancora spaziale.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di utilizzare XrSystemDeviceAnchorPersistencePropertiesANDROID
type deve essere XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID
next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

La funzione xrEnumerateSupportedPersistenceAnchorTypesANDROID è definita come:

XrResult xrEnumerateSupportedPersistenceAnchorTypesANDROID(
    XrInstance                                  instance,
    XrSystemId                                  systemId,
    uint32_t                                    trackableTypeCapacityInput,
    uint32_t*                                   trackableTypeCountOutput,
    XrTrackableTypeANDROID*                     trackableTypes);

Descrizioni dei parametri

session è la XrSession che crea la XrDeviceAnchorPersistenceANDROID.
trackableTypeCapacityInput è la capacità del trackableTypes o 0 per recuperare la capacità richiesta.
trackableTypeCountOutput è un puntatore al conteggio dell'array o un puntatore alla capacità richiesta nel caso in cui trackableTypeCapacityInput sia insufficiente.
trackableTypes è un puntatore a un array di XrTrackableTypeANDROID, ma può essere NULL se trackableTypeCapacityInput è 0.
Per una descrizione dettagliata del recupero della dimensione trackableTypes richiesta, consulta la sezione Parametri di dimensione del buffer.

L'applicazione può utilizzare xrEnumerateSupportedPersistenceAnchorTypesANDROID per verificare la presenza del supporto della persistenza dell'ancora su altri elementi tracciabili XrTrackableTypeANDROID.

Se un determinato valore XrTrackableTypeANDROID non viene restituito nell'array trackableTypes, verrà restituito XR_ERROR_FEATURE_UNSUPPORTED dalle funzioni di persistenza dell'ancora del dispositivo che operano su un'ancora di quel tipo.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrEnumerateSupportedPersistenceAnchorTypesANDROID
instance deve essere un handle XrInstance valido
trackableTypeCountOutput deve essere un puntatore a un valore uint32_t
Se trackableTypeCapacityInput non è 0, trackableTypes, deve essere un puntatore a un array di valori trackableTypeCapacityInput XrTrackableTypeANDROID

Codici di ritorno

Operazione riuscita

XR_SUCCESS

Errore

XR_ERROR_SYSTEM_INVALID
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SIZE_INSUFFICIENT
XR_ERROR_FUNCTION_UNSUPPORTED

Creare un handle di persistenza dell'ancora del dispositivo

Un XrDeviceAnchorPersistenceANDROID è un handle che rappresenta le risorse necessarie per mantenere e tenere traccia degli ancoraggi permanenti.

XR_DEFINE_HANDLE(XrDeviceAnchorPersistenceANDROID)

La funzione xrCreateDeviceAnchorPersistenceANDROID è definita come segue:

XrResult xrCreateDeviceAnchorPersistenceANDROID(
    XrSession                                   session,
    const XrDeviceAnchorPersistenceCreateInfoANDROID* createInfo,
    XrDeviceAnchorPersistenceANDROID*           outHandle);

Descrizioni dei parametri

session è la XrSession che crea la XrDeviceAnchorPersistenceANDROID.
createInfo è il XrDeviceAnchorPersistenceCreateInfoANDROID contenente i parametri per XrDeviceAnchorPersistenceANDROID.
outHandle è un puntatore a un handle in cui viene restituito il valore creato XrDeviceAnchorPersistenceANDROID.

Un'applicazione può creare un handle XrDeviceAnchorPersistenceANDROID chiamando xrCreateDeviceAnchorPersistenceANDROID. XrDeviceAnchorPersistenceANDROID può essere utilizzato nelle chiamate API successive per mantenere o annullare la persistenza degli ancoraggi. L'handle XrDeviceAnchorPersistenceANDROID deve essere eventualmente liberato utilizzando la funzione xrDestroyDeviceAnchorPersistenceANDROID.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrCreateDeviceAnchorPersistenceANDROID
session deve essere un handle XrSession valido
createInfo deve essere un puntatore a una struttura XrDeviceAnchorPersistenceCreateInfoANDROID valida
outHandle deve essere un puntatore a un handle XrDeviceAnchorPersistenceANDROID

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_OUT_OF_MEMORY
XR_ERROR_LIMIT_REACHED

La struttura XrDeviceAnchorPersistenceCreateInfoANDROID è definita come:

typedef struct XrDeviceAnchorPersistenceCreateInfoANDROID {
    XrStructureType    type;
    void*              next;
} XrDeviceAnchorPersistenceCreateInfoANDROID;

Descrizioni dei membri

type è il XrStructureType di questa struttura.
next è NULL o un puntatore alla struttura successiva in una catena di strutture. Queste strutture non sono definite in OpenXR di base o in questa estensione.

La struttura XrDeviceAnchorPersistenceCreateInfoANDROID fornisce opzioni di creazione per XrDeviceAnchorPersistenceANDROID quando viene passata a xrCreateDeviceAnchorPersistenceANDROID.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di utilizzare XrDeviceAnchorPersistenceCreateInfoANDROID
type deve essere XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID
next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

La funzione xrDestroyDeviceAnchorPersistenceANDROID è definita come:

XrResult xrDestroyDeviceAnchorPersistenceANDROID(
    XrDeviceAnchorPersistenceANDROID            handle);

Descrizioni dei parametri

handle è un handle XrDeviceAnchorPersistenceANDROID creato in precedenza da xrCreateDeviceAnchorPersistenceANDROID.

La funzione xrDestroyDeviceAnchorPersistenceANDROID distrugge l'handle di persistenza dell'ancora del dispositivo.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrDestroyDeviceAnchorPersistenceANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido

Coerenza di thread

L'accesso a handle e a eventuali handle secondari deve essere sincronizzato esternamente

Codici di ritorno

Operazione riuscita

XR_SUCCESS

Errore

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_HANDLE_INVALID

Mantenere un ancoraggio

La funzione xrPersistAnchorANDROID è definita come:

XrResult xrPersistAnchorANDROID(
    XrDeviceAnchorPersistenceANDROID            handle,
    const XrPersistedAnchorSpaceInfoANDROID*    persistedInfo,
    XrUuidEXT*                                  anchorIdOutput);

Descrizioni dei parametri

handle è XrDeviceAnchorPersistenceANDROID.
persistedInfo è l'XrPersistedAnchorSpaceInfoANDROID contenente i parametri per la persistenza dell'ancora.
anchorIdOutput è un puntatore a un XrUuidEXT in cui viene restituito l'UUID dell'ancora persistente.

L'applicazione può richiedere che le ancore vengano mantenute chiamando xrPersistAnchorANDROID. L'applicazione non deve assumere che un valore di ritorno di successo significhi che l'ancora viene immediatamente mantenuta. L'applicazione deve utilizzare xrGetAnchorPersistStateANDROID per controllare lo stato di persistenza dell'ancora utilizzando l'ancora restituita XrUuidEXT. L'applicazione può utilizzare xrUnpersistAnchorANDROID per annullare la persistenza dell'ancora.

XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID verrà restituito se l'ancora non viene monitorata al momento della chiamata.
XR_SUCCESS verrà restituito una volta che l'ancora è stata messa in coda per la persistenza.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrPersistAnchorANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido
persistedInfo deve essere un puntatore a una struttura XrPersistedAnchorSpaceInfoANDROID valida
anchorIdOutput deve essere un puntatore a una struttura XrUuidEXT

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID
XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_OUT_OF_MEMORY
XR_ERROR_LIMIT_REACHED

La struttura XrPersistedAnchorSpaceInfoANDROID è definita come:

typedef struct XrPersistedAnchorSpaceInfoANDROID {
    XrStructureType    type;
    void*              next;
    XrSpace            anchor;
} XrPersistedAnchorSpaceInfoANDROID;

Descrizioni dei membri

type è il XrStructureType di questa struttura.
next è NULL o un puntatore alla struttura successiva in una catena di strutture. Queste strutture non sono definite in OpenXR di base o in questa estensione.
anchor è un XrSpace di ancoraggio creato in precedenza da xrCreateAnchorSpaceANDROID per essere mantenuto.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di utilizzare XrPersistedAnchorSpaceInfoANDROID
type deve essere XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID
next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture
anchor deve essere un handle XrSpace valido

La funzione xrGetAnchorPersistStateANDROID è definita come:

XrResult xrGetAnchorPersistStateANDROID(
    XrDeviceAnchorPersistenceANDROID            handle,
    const XrUuidEXT*                            anchorId,
    XrAnchorPersistStateANDROID*                persistState);

Descrizioni dei parametri

handle è XrDeviceAnchorPersistenceANDROID.
anchorId è l'XrUuidEXT dell'ancora.
persistState è un puntatore a un XrAnchorPersistStateANDROID in cui viene restituito lo stato dell'ancora.
XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID viene restituito se l'ancora XrUuidEXT non viene trovata.
XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID verrà restituito se i dati persistenti di anchorId non sono pronti.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrGetAnchorPersistStateANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido
anchorId deve essere un puntatore a una struttura XrUuidEXT valida
persistState deve essere un puntatore a un valore XrAnchorPersistStateANDROID

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID

L'enum XrAnchorPersistStateANDROID è definito come:

typedef enum XrAnchorPersistStateANDROID {
    XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID = 0,
    XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID = 1,
    XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID = 2
} XrAnchorPersistStateANDROID;

Enum	Descrizione
`XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID`	Non è stato richiesto all'app di mantenere l'ancora.
`XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID`	È stato richiesto di mantenere l'ancora, ma non è ancora stata mantenuta.
`XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID`	L'ancora è stata mantenuta nel tempo dal runtime.

Creare un'ancora da dati persistenti

La funzione xrCreatePersistedAnchorSpaceANDROID è definita come segue:

XrResult xrCreatePersistedAnchorSpaceANDROID(
    XrDeviceAnchorPersistenceANDROID            handle,
    const XrPersistedAnchorSpaceCreateInfoANDROID* createInfo,
    XrSpace*                                    anchorOutput);

Descrizioni dei parametri

handle è XrDeviceAnchorPersistenceANDROID.
createInfo è l'XrPersistedAnchorSpaceCreateInfoANDROID contenente i parametri per la creazione dell'ancora.
anchorOutput è un puntatore a un XrSpace in cui viene restituito il nuovo spazio di ancoraggio.

L'applicazione può creare un'ancora XrSpace da un'ancora precedentemente persistente chiamando xrCreatePersistedAnchorSpaceANDROID con lo stesso XrUuidEXT. Questo è un altro modo per creare ancore come definito in XR_ANDROID_trackables.

XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID viene restituito se l'ancora XrUuidEXT non viene trovata.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrCreatePersistedAnchorSpaceANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido
createInfo deve essere un puntatore a una struttura XrPersistedAnchorSpaceCreateInfoANDROID valida
anchorOutput deve essere un puntatore a un handle XrSpace

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_OUT_OF_MEMORY
XR_ERROR_LIMIT_REACHED
XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID
XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID

La struttura XrPersistedAnchorSpaceCreateInfoANDROID è definita come:

typedef struct XrPersistedAnchorSpaceCreateInfoANDROID {
    XrStructureType    type;
    void*              next;
    XrUuidEXT          anchorId;
} XrPersistedAnchorSpaceCreateInfoANDROID;

Descrizioni dei membri

type è il XrStructureType di questa struttura.
next è NULL o un puntatore alla struttura successiva in una catena di strutture. Queste strutture non sono definite in OpenXR di base o in questa estensione.
anchorId è l'XrUuidEXT dell'ancora persistente da cui creare un'ancora XrSpace.

La struttura XrPersistedAnchorSpaceCreateInfoANDROID fornisce opzioni di creazione per l'ancora quando viene passata a xrCreateDeviceAnchorPersistenceANDROID.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di utilizzare XrPersistedAnchorSpaceCreateInfoANDROID
type deve essere XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID
next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

Enumera gli ancoraggi permanenti

La funzione xrEnumeratePersistedAnchorsANDROID è definita come:

XrResult xrEnumeratePersistedAnchorsANDROID(
    XrDeviceAnchorPersistenceANDROID            handle,
    uint32_t                                    anchorIdsCapacityInput,
    uint32_t*                                   anchorIdsCountOutput,
    XrUuidEXT*                                  anchorIds);

Descrizioni dei parametri

handle è XrDeviceAnchorPersistenceANDROID.
anchorIdsCapacityInput è la capacità dell'array anchorIds o 0 per indicare una richiesta di recupero della capacità richiesta.
anchorIdsCountOutput è un puntatore al conteggio di anchorIds scritto o un puntatore alla capacità richiesta nel caso in cui anchorIdsCapacityInput sia insufficiente.
anchorIds è un puntatore a un array di strutture XrUuidEXT. Può essere NULL se anchorIdsCapacityInput è 0.
Per una descrizione dettagliata del recupero della dimensione anchorIds richiesta, consulta la sezione Parametri di dimensione del buffer.

L'applicazione potrebbe enumerare tutti gli attuali ancoraggi persistenti chiamando xrEnumeratePersistedAnchorsANDROID. anchorIds conterrà gli UUID delle ancore persistenti fino alla capacità dell'array. Se la capacità non è sufficiente, le applicazioni non hanno alcuna garanzia su quali ancore vengono rese.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrEnumeratePersistedAnchorsANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido
anchorIdsCountOutput deve essere un puntatore a un valore uint32_t
Se anchorIdsCapacityInput non è 0, anchorIds deve essere un puntatore a un array di strutture anchorIdsCapacityInput XrUuidEXT

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID
XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_SIZE_INSUFFICIENT

Annullare la persistenza di un ancoraggio persistente

La funzione xrUnpersistAnchorANDROID è definita come:

XrResult xrUnpersistAnchorANDROID(
    XrDeviceAnchorPersistenceANDROID            handle,
    const XrUuidEXT*                            anchorId);

Descrizioni dei parametri

handle è XrDeviceAnchorPersistenceANDROID.
anchorId è l'XrUuidEXT dell'ancora da annullare.

L'applicazione può annullare la persistenza di un'ancora chiamando xrUnpersistAnchorANDROID e passando l'ancora XrUuidEXT da annullare.

XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID verrà restituito se i dati memorizzati non sono pronti.
XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID viene restituito se l'ancora XrUuidEXT non viene trovata.

Utilizzo valido (implicito)

L'estensione XR_ANDROID_device_anchor_persistence deve essere attivata prima di chiamare xrUnpersistAnchorANDROID
handle deve essere un handle XrDeviceAnchorPersistenceANDROID valido
anchorId deve essere un puntatore a una struttura XrUuidEXT valida

Codici di ritorno

Operazione riuscita

XR_SUCCESS
XR_SESSION_LOSS_PENDING

Errore

XR_ERROR_FUNCTION_UNSUPPORTED
XR_ERROR_VALIDATION_FAILURE
XR_ERROR_RUNTIME_FAILURE
XR_ERROR_HANDLE_INVALID
XR_ERROR_INSTANCE_LOST
XR_ERROR_SESSION_LOST
XR_ERROR_OUT_OF_MEMORY
XR_ERROR_LIMIT_REACHED
XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID
XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID

Codice di esempio per la persistenza dell'ancora

Il seguente codice di esempio mostra come ispezionare la funzionalità del sistema, memorizzare in modo persistente, enumerare e annullare la persistenza delle ancore, nonché creare un'ancora dall'ancora memorizzata in modo persistente XrUuidEXT.

XrSession session; // previously initialized
XrSpace anchor; // previously initialized

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrEnumerateSupportedPersistenceAnchorTypesANDROID xrEnumerateSupportedPersistenceAnchorTypesANDROID; // previously initialized
PFN_xrCreateDeviceAnchorPersistenceANDROID xrCreateDeviceAnchorPersistenceANDROID; // previously initialized
PFN_xrDestroyDeviceAnchorPersistenceANDROID xrDestroyDeviceAnchorPersistenceANDROID; // previously initialized
PFN_xrPersistAnchorANDROID xrPersistAnchorANDROID; // previously initialized
PFN_xrGetAnchorPersistStateANDROID xrGetAnchorPersistStateANDROID; // previously initialized
PFN_xrCreatePersistedAnchorSpaceANDROID xrCreatePersistedAnchorSpaceANDROID; // previously initialized
PFN_xrEnumeratePersistedAnchorsANDROID xrEnumeratePersistedAnchorsANDROID; // previously initialized
PFN_xrUnpersistAnchorANDROID xrUnpersistAnchorANDROID; // previously initialized

// Create a device anchor persistence handle
XrDeviceAnchorPersistenceCreateInfoANDROID persistenceHandleCreateInfo;
persistenceHandleCreateInfo.type = XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID;
persistenceHandleCreateInfo.next = nullptr;

XrDeviceAnchorPersistenceANDROID persistenceHandle;
CHK_XR(xrCreateDeviceAnchorPersistenceANDROID(session, &persistenceHandleCreateInfo, &persistenceHandle));

/// Persist an anchor
XrPersistedAnchorSpaceInfo anchorSpaceInfo;
anchorSpaceInfo.type = XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID;
anchorSpaceInfo.next = nullptr;
anchorSpaceInfo.anchor = anchor;

XrUuidEXT anchorId;
CHK_XR(xrPersistAnchorANDROID(persistenceHandle, &anchorSpaceInfo, &anchorId));

// ... Update loop ...
// Poll for anchor persist state to confirm if it was successfully persisted
XrAnchorPersistStateANDROID persistState;
CHK_XR(xrGetAnchorPersistStateANDROID(persistenceHandle, &anchorId, &persistState));
if (persistState == XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID)  {
  // The anchor was persisted successfully
}

// Enumerate all persisted anchors
uint32_t anchorCountOutput = 0;
std::vector<XrUuidEXT> allAnchors;

CHK_XR(xrEnumeratePersistedAnchorsANDROID(
  persistenceHandle,
  anchorCountOutput,
  &anchorCountOutput,
  nullptr
));
allAnchors.resize(anchorCountOutput, XR_NULL_HANDLE);

// Fetch the actual anchors in an appropriately resized array.
CHK_XR(xrEnumeratePersistedAnchorsANDROID(
  persistenceHandle,
  anchorCountOutput,
  &anchorCountOutput,
  allAnchors.data()
));

// Creating an anchor from a previously persisted anchor using its UUID
XrTime updateTime; // Time used for the current frame's simulation update.
XrUuidEXT anchorId = allAnchors[0];

XrPersistedAnchorSpaceCreateInfo createInfo;
createInfo.type = XR_TYPE_PERSISTED_ANCHOR_CREATE_INFO_ANDROID;
createInfo.next = nullptr;
createInfo.anchorId = anchorId;

XrSpace anchorSpace = XR_NULL_HANDLE;
CHK_XR(xrCreatePersistedAnchorSpaceANDROID(
  persistenceHandle,
  &createInfo,
  &anchorSpace
));

// The anchor was found and retrieved from the local device successfully.
XrSpaceLocation anchorLocation = { XR_TYPE_SPACE_LOCATION };
CHK_XR(xrLocateSpace(anchorSpace, appSpace, updateTime, &anchorLocation));
XrPosef pose = anchorLocation.pose;

// Once app is done with all persistence related tasks
CHK_XR(xrDestroySpace(anchorSpace));
CHK_XR(xrDestroyDeviceAnchorPersistenceANDROID(persistenceHandle));