1. Panoramica
ARCore è una piattaforma per la creazione di app di realtà aumentata sui dispositivi mobili. L'API Cloud Anchors ti offre la possibilità di creare app AR che condividono un frame di riferimento comune, consentendo a più utenti di posizionare contenuti virtuali nella stessa posizione reale.
Questo codelab ti guida attraverso l'API Cloud Anchors. Dovrai prendere un'app ARCore esistente, modificarla in modo da utilizzare gli ancoraggi Cloud e creare un'esperienza AR condivisa.
Ancoraggi ARCore e ancora cloud permanenti
Un concetto fondamentale in ARCore è quello di anchor, che descrive una posizione fissa nel mondo reale. ARCore regola automaticamente il valore della posa di un ancoraggio man mano che il rilevamento del movimento migliora nel tempo.
Gli ancoraggi cloud sono ancora ospitati nel cloud. Possono essere risolte da più utenti per stabilire un quadro di riferimento comune tra utenti e dispositivi.
Hosting di un ancoraggio
Quando viene ospitato un ancoraggio, si verifica quanto segue:
- La posa dell'ancoraggio rispetto al mondo viene caricata nel cloud e si ottiene un ID ancoraggio Cloud.
L'ID ancoraggio Cloud è una stringa che deve essere inviata a chiunque voglia risolvere questo ancoraggio. - Un set di dati contenente dati visivi per l'anchor viene caricato sui server di Google.
Questo set di dati contiene dati visivi rilevati dal dispositivo di recente. Muovi leggermente il dispositivo per acquisire l'area intorno all'ancoraggio da diversi punti di vista prima dell'hosting per migliorare la localizzazione.
Trasferimento degli ID ancoraggio Cloud
In questo codelab, trasferirai gli ID ancoraggi Cloud utilizzando Firebase. Puoi condividere gli ID degli ancoraggi Cloud utilizzando altri mezzi.
Risolvere un ancoraggio
Puoi utilizzare l'API Cloud Anchor per risolvere un ancoraggio utilizzando il relativo ID ancorare Cloud. In questo modo viene creato un nuovo ancoraggio nella stessa posizione fisica dell'ancoraggio ospitato originale. Durante la risoluzione, il dispositivo deve guardare lo stesso ambiente fisico dell'ancoraggio ospitato originale.
Ancoraggi cloud permanenti
Prima della versione 1.20, gli ancoraggi Cloud potevano essere risolti solo per 24 ore dopo la loro hosting. Con l'API Persistent Cloud Anchors, puoi creare un ancoraggio cloud che può essere risolto per un periodo compreso tra 1 e 365 giorni dopo la creazione.
Cosa creerai
In questo codelab, creerai un'app ARCore preesistente. Al termine del codelab, la tua app:
- Essere in grado di ospitare gli anchor Cloud permanenti e di ottenere gli ID degli ancoraggi Cloud.
- Salva gli ID Cloud Anchor sul dispositivo per recuperarli facilmente utilizzando Android
SharedPreferences. - Utilizza gli ID ancoraggio Cloud salvati per risolvere gli ancoraggi ospitati in precedenza. In questo modo, ai fini di questo codelab, è più semplice simulare un'esperienza multiutente con un singolo dispositivo.
- Condividi gli ID ancoraggi Cloud con un altro dispositivo che esegue la stessa app, in modo che più utenti vedano la statua Android nella stessa posizione.
Viene visualizzata una statua Android nella posizione dell'ancoraggio cloud:
Obiettivi didattici
- Come ospitare gli ancoraggi utilizzando l'SDK ARCore e ottenere un ID ancoraggio Cloud.
- Come utilizzare gli ID degli ancoraggi Cloud per risolvere gli ancoraggi.
- Come archiviare e condividere gli ID Cloud Anchor tra diverse sessioni AR sullo stesso dispositivo o su dispositivi diversi.
Che cosa ti serve
- Un dispositivo ARCore supportato, collegato tramite cavo USB al computer di sviluppo.
- Google Play Services per AR 1.22 o versioni successive.
- Una macchina di sviluppo con Android Studio (v3.0 o versioni successive).
2. Configurazione dell'ambiente di sviluppo
Configurazione della macchina di sviluppo
Collega il dispositivo ARCore al computer tramite il cavo USB. Assicurati che il dispositivo consenta il debug USB.
Apri un terminale ed esegui adb devices, come mostrato di seguito:
adb devices List of devices attached <DEVICE_SERIAL_NUMBER> device
<DEVICE_SERIAL_NUMBER> sarà una stringa univoca per il dispositivo. Prima di continuare, assicurati di vedere esattamente un solo dispositivo.
Download e installazione del codice
Puoi clonare il repository:
git clone https://github.com/googlecodelabs/arcore-cloud-anchors.git
Oppure scarica un file ZIP ed estrailo:
Avvia Android Studio. Fai clic su Apri un progetto Android Studio esistente. Passa quindi alla directory in cui hai estratto il file ZIP scaricato e fai doppio clic sulla directory arcore-cloud-anchors.
Questo è un singolo progetto Gradle con più moduli. Se il riquadro Progetto nella parte superiore sinistra di Android Studio non è già visualizzato nel riquadro Progetto, fai clic su Progetti dal menu a discesa. Il risultato dovrebbe essere simile al seguente:
Lavorerai principalmente nel modulo work. Gli altri moduli includono un modulo helpers che contiene un insieme di utili classi wrapper che utilizzerai. Ci sono anche soluzioni complete per ogni parte del codelab. Ad eccezione del modulo helpers, ogni modulo è un'app sviluppabile.
Se viene visualizzata una finestra di dialogo che ti consiglia di eseguire l'upgrade del plug-in Android Gradle, fai clic su Non ricordarmi di nuovo per questo progetto:
Fai clic su Esegui > Esegui... > "lavoro". Nella finestra di dialogo Seleziona la destinazione del deployment visualizzata, il tuo dispositivo dovrebbe essere elencato in Dispositivi connessi. Seleziona il tuo dispositivo e fai clic su Ok. Android Studio creerà l'app iniziale e la eseguirà sul tuo dispositivo.
Quando esegui l'app per la prima volta, ti verrà richiesta l'autorizzazione CAMERA. Tocca CONSENTI per continuare.
Come utilizzare l'app
- Sposta il dispositivo per aiutare l'app a trovare un aereo. Quando viene trovato, un piano viene mostrato come superficie tratteggiata.
- Tocca un punto qualsiasi dell'aereo per posizionare un ancoraggio. Nel punto in cui è stato posizionato l'ancoraggio verrà disegnata una figura Android. Quest'app ti consente di posizionare un solo ancoraggio alla volta.
- Sposta il dispositivo. La figura dovrebbe apparire nella stessa posizione anche se il dispositivo si muove.
- Premi il pulsante CANCELLA per rimuovere l'ancoraggio. In questo modo potrai posizionare un altro ancoraggio.
Al momento, questa app utilizza solo il rilevamento del movimento fornito da ARCore per tracciare un ancoraggio in una singola esecuzione dell'app. Se decidi di chiudere, chiudere e riavviare l'app, l'ancoraggio posizionato in precedenza e tutte le informazioni correlate, inclusa la sua posa, andranno persi.
Nelle prossime sezioni, utilizzerai quest'app per vedere in che modo è possibile condividere gli ancoraggi tra le sessioni AR.
3. Ospita un ancoraggio
In questa sezione modificherai il progetto work per ospitare un ancoraggio. Prima di scrivere il codice, devi implementare alcune modifiche alla configurazione dell'app.
Dichiara le autorizzazioni INTERNET
Poiché gli ancoraggi Cloud richiedono la comunicazione con il servizio API Cloud Anchor ARCore, la tua app deve avere l'autorizzazione ad accedere a internet.
Nel file AndroidManifest.xml, aggiungi la seguente riga appena sotto la dichiarazione delle autorizzazioni android.permission.CAMERA:
<!-- Find this line... -->
<uses-permission android:name="android.permission.CAMERA"/>
<!-- Add the line right below -->
<uses-permission android:name="android.permission.INTERNET"/>
Abilita l'API ARCore
- Vai alla pagina del servizio API ARCore.
- Nell'elenco dei progetti, seleziona un progetto o creane uno nuovo.
- Fai clic su Abilita.
Configura l'autenticazione senza chiave
Per utilizzare gli anchor Cloud permanenti, devi utilizzare l'autenticazione senza chiave per eseguire l'autenticazione con l'API ARCore.
- Vai alla console di Google Cloud Platform.
- Seleziona un progetto dall'elenco di progetti.
- Se le API e non è già aperta, apri il menu a sinistra della console e seleziona API e Servizi.
- A sinistra, fai clic su Credenziali.
- Fai clic su Crea credenziali, quindi seleziona ID client OAuth.
- Inserisci i seguenti valori:
- Tipo di applicazione: Android
- Nome del pacchetto:
com.google.ar.core.codelab.cloudanchor
- Recupera l'impronta digitale del certificato di firma di debug:
- Nel tuo progetto Android Studio, apri il riquadro degli strumenti di Gradle.
- In Cloud-anchors > lavoro > Attività > Android, esegui l'attività signingReport.
- Copia l'impronta SHA-1 nel campo Fingerprint del certificato SHA-1 in Google Cloud.
Configura ARCore
Successivamente, modificherai l'app in modo da ospitare un ancoraggio su un tocco dell'utente anziché su uno normale. Per farlo, devi configurare la sessione ARCore per abilitare gli ancoraggi Cloud.
Nel file CloudAnchorFragment.java, aggiungi il seguente codice:
// Find this line...
session = new Session(requireActivity());
// Add these lines right below:
// Configure the session.
Config config = new Config(session);
config.setCloudAnchorMode(CloudAnchorMode.ENABLED);
session.configure(config);
Prima di procedere, crea ed esegui l'app. Assicurati di creare solo il modulo work. L'app dovrebbe essere creata correttamente e funzionare come prima.
Ospita un ancoraggio
È il momento di ospitare un ancoraggio che verrà caricato nell'API ARCore.
Aggiungi il seguente nuovo campo al tuo corso CloudAnchorFragment:
// Find this line...
private Anchor currentAnchor = null;
// Add these lines right below.
@Nullable
private Future future = null;
Ricordati di aggiungere un'importazione per com.google.ar.core.Future.
Modifica il metodo onClearButtonPressed come segue:
private void onClearButtonPressed() {
// Clear the anchor from the scene.
if (currentAnchor != null) {
currentAnchor.detach();
currentAnchor = null;
}
// The next part is the new addition.
// Cancel any ongoing asynchronous operations.
if (future != null) {
future.cancel();
future = null;
}
}
Poi, aggiungi il seguente metodo alla tua classe CloudAnchorFragment:
private void onHostComplete(String cloudAnchorId, CloudAnchorState cloudState) {
if (cloudState == CloudAnchorState.SUCCESS) {
messageSnackbarHelper.showMessage(getActivity(), "Cloud Anchor Hosted. ID: " + cloudAnchorId);
} else {
messageSnackbarHelper.showMessage(getActivity(), "Error while hosting: " + cloudState.toString());
}
}
Trova il metodo handleTap nella classe CloudAnchorFragment e aggiungi queste righe:
// Find this line...
currentAnchor = hit.createAnchor();
// Add these lines right below:
messageSnackbarHelper.showMessage(getActivity(), "Now hosting anchor...");
future = session.hostCloudAnchorAsync(currentAnchor, 300, this::onHostComplete);
Esegui di nuovo l'app da Android Studio. Dovresti visualizzare il messaggio "Ora hosting anchor..." quando posizioni un ancoraggio. Al termine dell'hosting, dovrebbe essere visualizzato un altro messaggio. Se viene visualizzato il messaggio "Errore durante l'hosting dell'anchor: ERROR_NOT_AUTHORIZED", verifica che il client OAuth sia configurato correttamente.
Chiunque conosca l'ID ancoraggio e sia presente nello stesso spazio fisico dell'ancoraggio può utilizzarlo per creare un ancoraggio nella stessa esatta posa (posizione e orientamento) rispetto all'ambiente circostante.
Tuttavia, l'ID ancoraggio è lungo e non è facile da inserire manualmente per un altro utente. Nelle sezioni seguenti, archivierai gli ID degli ancoraggi Cloud in modo facile da recuperare per consentire la risoluzione degli anchor sullo stesso dispositivo o su un altro.
4. Archivia gli ID e risolvi gli anchor
In questa parte, assegnerai codici brevi agli ID ancorati Cloud lunghi per semplificare l'inserimento manuale da parte di un altro utente. Utilizzerai l'API Shared preference (Preferenze condivise) per archiviare gli ID ancoraggio Cloud come valori in una tabella chiave-valore. Questa tabella persiste anche se l'app viene interrotta e riavviata.
È già stato fornito un corso per assistente chiamato StorageManager. Si tratta di un wrapper per l'API SharedPreferences che offre metodi per generare nuovi codici brevi univoci e leggere/scrivere ID ancoraggi Cloud.
Utilizzare StorageManager
Modifica CloudAnchorFragment per utilizzare StorageManager per archiviare gli ID anchor Cloud con codici brevi, in modo che possano essere recuperati facilmente.
Crea il seguente nuovo campo in CloudAnchorFragment:
// Find this line...
private TapHelper tapHelper;
// And add the storageManager.
private final StorageManager storageManager = new StorageManager();
Quindi, modifica il metodo onHostComplete:
private void onHostComplete(String cloudAnchorId, CloudAnchorState cloudState) {
if (cloudState == CloudAnchorState.SUCCESS) {
int shortCode = storageManager.nextShortCode(getActivity());
storageManager.storeUsingShortCode(getActivity(), shortCode, anchor.getCloudAnchorId());
messageSnackbarHelper.showMessage(
getActivity(), "Cloud Anchor Hosted. Short code: " + shortCode);
} else {
messageSnackbarHelper.showMessage(getActivity(), "Error while hosting: " + cloudState.toString());
}
}
A questo punto, crea ed esegui l'app da Android Studio. Quando crei e ospiti un ancoraggio, dovresti vedere visualizzati codici brevi al posto dei lunghi ID degli ancoraggi Cloud.
Subito dopo aver posizionato un ancoraggio | Dopo aver atteso un po' |
|
|
Tieni presente che i codici brevi generati da StorageManager vengono attualmente assegnati sempre in ordine crescente.
Successivamente, aggiungerai alcuni elementi dell'interfaccia utente che ti consentiranno di inserire codici brevi e ricreare gli ancoraggi.
Aggiungi il pulsante Risolvi
Aggiungi un altro pulsante accanto al pulsante CANCELLA. Questo sarà il pulsante RISOLVI. Se fai clic sul pulsante RISOLVI si aprirà una finestra di dialogo che richiede all'utente un breve codice. Il codice breve viene utilizzato per recuperare l'ID ancoraggio Cloud da StorageManager e risolvere l'ancoraggio.
Per aggiungere il pulsante, dovrai modificare il file res/layout/cloud_anchor_fragment.xml. In Android Studio, fai doppio clic sul file, poi fai clic su "Testo" in basso per visualizzare il file XML non elaborato. Apporta le seguenti modifiche:
<!-- Find this element. -->
<Button
android:text="CLEAR"
android:id="@+id/clear_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<!-- Add this element right below. -->
<Button
android:text="RESOLVE"
android:id="@+id/resolve_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
Ora aggiungi un nuovo campo a CloudAnchorFragment:
private Button resolveButton;
Aggiungi un nuovo metodo:
private void onResolveButtonPressed() {
ResolveDialogFragment dialog = new ResolveDialogFragment();
dialog.show(getFragmentMagetActivity().getSupportFragmentManagernager(), "Resolve");
}
Inizializza resolveButton nel metodo onCreateView come segue:
// Find these lines...
Button clearButton = rootView.findViewById(R.id.clear_button);
clearButton.setOnClickListener(v -> onClearButtonPressed());
// Add these lines right below.
resolveButton = rootView.findViewById(R.id.resolve_button);
resolveButton.setOnClickListener(v -> onResolveButtonPressed());
Trova il metodo handleTap e modificalo:
private void handleTap(Frame frame, Camera camera) {
// ...
// Find this line.
currentAnchor = hit.createAnchor();
// Add this line right below.
getActivity().runOnUiThread(() -> resolveButton.setEnabled(false));
}
Aggiungi una riga nel metodo onClearButtonPressed:
private void onClearButtonPressed() {
// Clear the anchor from the scene.
if (currentAnchor != null) {
currentAnchor.detach();
currentAnchor = null;
}
// Cancel any ongoing async operations.
if (future != null) {
future.cancel();
future = null;
}
// The next line is the new addition.
resolveButton.setEnabled(true);
}
Crea ed esegui l'app da Android Studio. Dovresti vedere il pulsante RISOLVI accanto al pulsante CANCELLA. Se fai clic sul pulsante RISOLVI, dovrebbe comparire una finestra di dialogo come mostrato di seguito.
Il pulsante RISOLVI è ora visibile | Se fai clic sul pulsante, viene visualizzata questa finestra di dialogo |
|
|
Se tocchi l'aereo e ospiti un ancoraggio, il pulsante RISOLVI dovrebbe essere disattivato, ma se tocchi il pulsante CANCELLA dovresti attivarlo di nuovo. Questa funzionalità è stata progettata, in modo che nella scena sia presente un solo ancoraggio alla volta.
L'elemento "Resolve Anchor" la finestra di dialogo non fa nulla, ma la modificherai ora.
Risolvi anchor
Aggiungi i seguenti metodi nella classe CloudAnchorFragment:
private void onShortCodeEntered(int shortCode) {
String cloudAnchorId = storageManager.getCloudAnchorId(getActivity(), shortCode);
if (cloudAnchorId == null || cloudAnchorId.isEmpty()) {
messageSnackbarHelper.showMessage(
getActivity(),
"A Cloud Anchor ID for the short code " + shortCode + " was not found.");
return;
}
resolveButton.setEnabled(false);
future = session.resolveCloudAnchorAsync(
cloudAnchorId, (anchor, cloudState) -> onResolveComplete(anchor, cloudState, shortCode));
}
private void onResolveComplete(Anchor anchor, CloudAnchorState cloudState, int shortCode) {
if (cloudState == CloudAnchorState.SUCCESS) {
messageSnackbarHelper.showMessage(getActivity(), "Cloud Anchor Resolved. Short code: " + shortCode);
currentAnchor = anchor;
} else {
messageSnackbarHelper.showMessage(
getActivity(),
"Error while resolving anchor with short code "
+ shortCode
+ ". Error: "
+ cloudState.toString());
resolveButton.setEnabled(true);
}
}
Quindi, modifica il metodo onResolveButtonPressed:
private void onResolveButtonPressed() {
ResolveDialogFragment dialog = ResolveDialogFragment.createWithOkListener(
this::onShortCodeEntered);
dialog.show(getActivity().getSupportFragmentManager(), "Resolve");
}
Crea ed esegui l'app da Android Studio, quindi procedi nel seguente modo:
- Crea un ancoraggio su un aereo e attendi che venga ospitato.
Ricorda il codice breve. - Premi il pulsante CANCELLA per eliminare l'ancoraggio.
- Premi il pulsante RISOLVI. Inserisci il codice breve del passaggio 1.
- Dovresti vedere un ancoraggio nella stessa posizione rispetto all'ambiente in cui l'hai posizionato inizialmente.
- Chiudi e termina l'app, quindi riaprila.
- Ripeti i passaggi (3) e (4). Dovresti vedere un nuovo ancoraggio, sempre nella stessa posizione.
Inserimento di un codice breve | Ancoraggio risolto |
|
|
5. Condividi tra dispositivi
Hai visto come archiviare l'ID ancoraggio Cloud di un ancoraggio nello spazio di archiviazione locale del dispositivo e recuperarlo in un secondo momento per ricreare lo stesso ancoraggio. Tuttavia, tutto il potenziale degli ancoraggi Cloud si sblocca solo quando puoi condividere gli ID degli ancoraggi Cloud tra dispositivi diversi.
Sei tu a decidere in che modo l'app condivide gli ID Cloud Anchor. Qualsiasi cosa può essere utilizzata per trasferire la stringa da un dispositivo all'altro. Per questo codelab, utilizzerai Firebase Realtime Database per trasferire gli ID anchor Cloud tra istanze dell'app.
Configurazione di Firebase
Devi configurare un Firebase Realtime Database con il tuo Account Google da utilizzare con questa app. È facile con l'Assistente Firebase in Android Studio.
In Android Studio, fai clic su Strumenti > Firebase. Nel riquadro Assistente che viene visualizzato, fai clic su Realtime Database, quindi su Salva e recupera i dati:
Fai clic sul pulsante Connetti a Firebase per collegare il tuo progetto Android Studio a un progetto Firebase nuovo o esistente.
Ti verrà chiesto di selezionare un modulo. Seleziona il modulo work:
Viene visualizzata la finestra di dialogo Avvio di connessione. L'operazione potrebbe richiedere un po' di tempo.
Accedi con il tuo Account Google e segui il flusso di lavoro sul web per creare un progetto Firebase per la tua app finché non torni ad Android Studio.
Nel riquadro Assistente, fai clic su Aggiungi Realtime Database alla tua app:
Nella finestra di dialogo visualizzata, seleziona lavoro dall'elenco a discesa Modulo di destinazione, quindi fai clic su Accetta modifiche.
Questo ti permetterà di:
- Aggiungi un file
google-services.jsonalla directorywork - Aggiungi un paio di righe al file
build.gradlenella stessa directory. - Crea ed esegui l'app (potresti visualizzare un errore di risoluzione relativo al numero di versione del database Firebase).
Nel modulo work build.gradle file, trova e rimuovi la seguente riga (il xxxx è un segnaposto per l'ultimo numero di versione)
dependencies {
...
implementation 'com.google.firebase:firebase-database:xxxx'
Quindi, rivedi (ma non ancora seguire) le istruzioni nella pagina Configura le regole per l'accesso pubblico per configurare Firebase Realtime Database in modo che sia scrivibile da tutti. Ciò contribuisce a semplificare i test in questo codelab:
Nella Console Firebase, seleziona il progetto a cui hai collegato il progetto Android Studio e poi CREA > Realtime Database.
Fai clic su Crea database per configurare e impostare Realtime Database:
Scegli una località del database.
Nel passaggio successivo, seleziona le regole di sicurezza della modalità di test e fai clic su Attiva:
La tua app è ora configurata per utilizzare il database Firebase.
Utilizzo di FirebaseManager
Ora sostituirai StorageManager con FirebaseManager.
In Android Studio, trova il corso CloudAnchorFragment nella directory work. Sostituisci StorageManager con un FirebaseManager:
// Find this line.
private final StorageManager storageManager = new StorageManager();
// And replace it with this line.
private FirebaseManager firebaseManager;
Inizializza firebaseManager nel metodo onAttach:
public void onAttach(@NonNull Context context) {
super.onAttach(context);
tapHelper = new TapHelper(context);
trackingStateHelper = new TrackingStateHelper(requireActivity());
// The next line is the new addition.
firebaseManager = new FirebaseManager(context);
}
Modifica il metodo onShortCodeEntered come segue:
private void onShortCodeEntered(int shortCode) {
firebaseManager.getCloudAnchorId(shortCode, cloudAnchorId -> {
if (cloudAnchorId == null || cloudAnchorId.isEmpty()) {
messageSnackbarHelper.showMessage(
getActivity(),
"A Cloud Anchor ID for the short code " + shortCode + " was not found.");
return;
}
resolveButton.setEnabled(false);
future = session.resolveCloudAnchorAsync(
cloudAnchorId, (anchor, cloudState) -> onResolveComplete(anchor, cloudState, shortCode));
});
}
Quindi, modifica il metodo onHostComplete come segue:
private void onHostComplete(String cloudAnchorId, CloudAnchorState cloudState) {
if (cloudState == CloudAnchorState.SUCCESS) {
firebaseManager.nextShortCode(shortCode -> {
if (shortCode != null) {
firebaseManager.storeUsingShortCode(shortCode, cloudAnchorId);
messageSnackbarHelper.showMessage(getActivity(), "Cloud Anchor Hosted. Short code: " + shortCode);
} else {
// Firebase could not provide a short code.
messageSnackbarHelper.showMessage(getActivity(), "Cloud Anchor Hosted, but could not "
+ "get a short code from Firebase.");
}
});
} else {
messageSnackbarHelper.showMessage(getActivity(), "Error while hosting: " + cloudState.toString());
}
}
Crea ed esegui la tua app. Dovresti vedere lo stesso flusso dell'interfaccia utente della sezione precedente, con la differenza che ora il database Firebase online viene utilizzato per archiviare gli ID e i codici brevi di ancoraggio Cloud al posto dello spazio di archiviazione locale del dispositivo.
Test multiutente
Per testare un'esperienza multiutente, utilizza due telefoni diversi:
- Installa l'app su due dispositivi.
- Usa un dispositivo per ospitare un ancoraggio e generare un breve codice.
- Usa l'altro dispositivo per risolvere l'ancoraggio usando quel breve codice.
Dovresti riuscire a ospitare gli ancoraggi da un dispositivo, ottenere un codice breve e utilizzare il codice breve sull'altro dispositivo per vedere l'ancoraggio nello stesso punto.
6. Conclusione
Complimenti! Hai raggiunto la fine di questo codelab.
Argomenti trattati
- Come ospitare gli ancoraggi utilizzando l'SDK ARCore e ottenere un ID ancoraggio Cloud.
- Come utilizzare gli ID degli ancoraggi Cloud per risolvere gli ancoraggi.
- Come archiviare e condividere gli ID Cloud Anchor tra diverse sessioni AR sullo stesso dispositivo o su dispositivi diversi.
Scopri di più
- Dai un'occhiata alla panoramica degli ancoraggi Cloud per Android