Ancoraggi cloud ARCore con anchor cloud permanenti

1. Panoramica

ARCore è una piattaforma per la creazione di app di realtà aumentata su dispositivi mobili. L'API Cloud Anchors ti consente di creare app AR che condividono un frame di riferimento comune, consentendo a più utenti di posizionare contenuti virtuali nella stessa posizione del mondo reale.

Questo codelab ti guida nell'utilizzo dell'API Cloud Anchors. Prenderai un'app ARCore esistente, la modificherai per utilizzare Cloud Anchors e creerai un'esperienza AR condivisa.

Ancore ARCore e ancore cloud persistenti

Un concetto fondamentale di ARCore è quello di ancora, 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 ancoraggi ospitati nel cloud. Possono essere risolti da più utenti per stabilire un quadro di riferimento comune tra gli utenti e i loro dispositivi.

Ospitare un anchor

Quando viene ospitato un ancoraggio, si verificano le seguenti operazioni:

  1. La posa dell'ancora rispetto al mondo viene caricata sul cloud e viene ottenuto un ID ancora cloud.
    L'ID ancora cloud è una stringa che deve essere inviata a chiunque voglia risolvere questa ancora.
  2. Un set di dati contenente i dati visivi dell'ancora viene caricato sui server di Google.
    Questo set di dati contiene i dati visivi visti di recente dal dispositivo. Spostare leggermente il dispositivo per acquisire l'area intorno all'ancora da diversi punti di vista prima dell'hosting migliorerà la localizzazione.

Trasferimento degli ID ancoraggio cloud

In questo codelab, trasferirai gli ID Cloud Anchor utilizzando Firebase. Puoi condividere gli ID ancoraggio cloud con altri mezzi.

Risoluzione di un ancoraggio

Puoi utilizzare l'API Cloud Anchor per risolvere un ancoraggio utilizzando il relativo ID Cloud Anchor. Viene creato un nuovo ancoraggio nella stessa posizione fisica dell'ancoraggio ospitato originale. Durante la risoluzione, il dispositivo deve esaminare lo stesso ambiente fisico dell'ancora ospitata originale.

Cloud Anchor persistenti

Prima della versione 1.20, le ancore cloud potevano essere risolte solo per 24 ore dopo l'hosting. Con l'API Persistent Cloud Anchors, puoi creare un'ancora cloud che può essere risolta da 1 giorno a 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 Cloud Anchor persistenti e ottenere gli ID Cloud Anchor.
  • Salva gli ID ancoraggio cloud sul dispositivo per un facile recupero utilizzando Android SharedPreferences.
  • Utilizza gli ID ancoraggio cloud salvati per risolvere gli ancoraggi ospitati in precedenza. In questo modo, è facile simulare un'esperienza multiutente con un singolo dispositivo ai fini di questo codelab.
  • Condividi gli ID ancoraggio cloud con un altro dispositivo che esegue la stessa app, in modo che più utenti vedano la statua di Android nella stessa posizione.

Una statua di Android viene visualizzata nella posizione dell'ancora cloud:

Obiettivi didattici

  • Come ospitare ancore utilizzando l'SDK ARCore e ottenere un ID Cloud Anchor.
  • Come utilizzare gli ID ancoraggio cloud per risolvere gli ancoraggi.
  • Come archiviare e condividere gli ID ancoraggio cloud tra diverse sessioni AR sullo stesso dispositivo o su dispositivi diversi.

Che cosa ti serve

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 tuo dispositivo. Prima di continuare, assicurati di visualizzare un solo dispositivo.

Scaricare e installare il codice

Puoi clonare il repository:

git clone https://github.com/googlecodelabs/arcore-cloud-anchors.git

In alternativa, scarica un file ZIP ed estrailo:

Avvia Android Studio. Fai clic su Apri un progetto Android Studio esistente. Poi, vai alla directory in cui hai estratto il file ZIP scaricato in precedenza e fai doppio clic sulla directory arcore-cloud-anchors.

Si tratta di un singolo progetto Gradle con più moduli. Se il riquadro Progetto in alto a sinistra di Android Studio non è già visualizzato, fai clic su Progetti dal menu a discesa. Il risultato dovrebbe essere simile al seguente:

52282f0415fdbdcb.png

Lavorerai principalmente nel modulo work. Altri moduli includono un modulo helpers che contiene un insieme di classi wrapper utili che utilizzerai. Sono disponibili anche soluzioni complete per ogni parte del codelab. Ad eccezione del modulo helpers, ogni modulo è un'app compilabile.

Se viene visualizzata una finestra di dialogo che consiglia di eseguire l'upgrade del plug-in Android Gradle, fai clic su Non ricordarmelo più per questo progetto:

31a93c7e9cc58b53.png

Fai clic su Esegui > Esegui… > "lavoro". Nella finestra di dialogo Seleziona destinazione di distribuzione visualizzata, il tuo dispositivo dovrebbe essere elencato nella sezione 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.

f7ea81f71a4b969e.png

Come utilizzare l'app

  1. Sposta il dispositivo per aiutare l'app a trovare un aereo. Quando viene trovato un piano, viene visualizzato come una superficie punteggiata.
  2. Tocca un punto qualsiasi della superficie piana per posizionare un ancoraggio. Verrà disegnato un robot Android nel punto in cui è stato posizionato l'ancoraggio. Questa app ti consente di posizionare un solo ancoraggio alla volta.
  3. Sposta il dispositivo. La figura dovrebbe rimanere nello stesso punto anche se il dispositivo si sposta.
  4. Premi il pulsante CANCELLA per rimuovere l'ancora. In questo modo potrai posizionare un altro ancoraggio.

Al momento, questa app utilizza solo il monitoraggio del movimento fornito da ARCore per monitorare un ancoraggio in una singola esecuzione dell'app. Se decidi di uscire, chiudere e riavviare l'app, l'ancoraggio posizionato in precedenza e tutte le informazioni correlate, inclusa la sua posa, andranno persi.

Nelle prossime sezioni, creerai questa app per vedere come gli ancoraggi possono essere condivisi tra le sessioni AR.

3. Ospitare un anchor

In questa sezione modificherai il progetto work per ospitare un ancoraggio. Prima di scrivere il codice, devi implementare alcune modifiche alla configurazione dell'app.

Dichiarare le autorizzazioni INTERNET

Poiché Cloud Anchor richiede la comunicazione con il servizio API ARCore Cloud Anchor, la tua app deve disporre dell'autorizzazione per accedere a internet.

Nel file AndroidManifest.xml, aggiungi la seguente riga subito sotto la dichiarazione dell'autorizzazione 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"/>

Attivare l'API ARCore

  1. Vai alla pagina del servizio API ARCore.
  2. Nell'elenco dei progetti, seleziona un progetto o creane uno nuovo.
  3. Fai clic su Abilita.

Configurare l'autenticazione senza chiave

Per utilizzare Persistent Cloud Anchors, devi utilizzare l'autenticazione senza chiave per autenticarti con l'API ARCore.

  1. Vai alla console di Google Cloud Platform.
  2. Seleziona un progetto dall'elenco.
  3. Se la pagina API e servizi non è già aperta, apri il menu a sinistra della console e seleziona API e servizi.
  4. A sinistra, fai clic su Credenziali.
  5. Fai clic su Crea credenziali, quindi seleziona ID client OAuth.
  6. Inserisci i seguenti valori:
    • Tipo di applicazione: Android
    • Nome pacchetto: com.google.ar.core.codelab.cloudanchor
  7. Recupera l'impronta del certificato di firma di debug:
    1. Nel progetto Android Studio, apri il riquadro degli strumenti Gradle.
    2. In cloud-anchors > work > Tasks > android, esegui l'attività signingReport.
    3. Copia l'impronta SHA-1 nel campo Impronta digitale certificato SHA-1 in Google Cloud.

Configurare ARCore

Ora modificherai l'app in modo che ospiti un ancoraggio al tocco di un utente anziché 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. La tua app dovrebbe essere compilata correttamente e funzionare come prima.

Ospitare un ancoraggio

È il momento di ospitare un ancoraggio che verrà caricato nell'API ARCore.

Aggiungi il seguente nuovo campo alla classe 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 nel seguente modo:

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;
  }
}

Dopodiché, aggiungi il seguente metodo alla 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. Quando posizioni un ancoraggio, dovresti vedere il messaggio "Ora ospita l'ancoraggio…". Al termine dell'hosting, dovresti visualizzare un altro messaggio. Se visualizzi il messaggio "Errore di hosting dell'ancora: ERROR_NOT_AUTHORIZED", verifica che il client OAuth sia configurato correttamente.

Chiunque conosca l'ID ancora e si trovi nello stesso spazio fisico dell'ancora può utilizzare l'ID ancora per creare un'ancora nella stessa posa (posizione e orientamento) rispetto all'ambiente circostante.

Tuttavia, l'ID ancora è lungo e non è facile da inserire manualmente per un altro utente. Nelle sezioni seguenti, memorizzerai gli ID di Cloud Anchor in modo semplice da recuperare per consentire la risoluzione degli ancoraggi sullo stesso dispositivo o su un altro.

4. ID negozio e risoluzione degli ancoraggi

In questa parte, assegnerai codici brevi agli ID Cloud Anchor lunghi per semplificare l'inserimento manuale da parte di un altro utente. Utilizzerai l'API Shared Preferences per archiviare gli ID ancoraggio cloud come valori in una tabella chiave-valore. Questa tabella verrà mantenuta anche se l'app viene chiusa e riavviata.

È già disponibile una classe helper denominata StorageManager. Si tratta di un wrapper intorno all'API SharedPreferences che dispone di metodi per generare nuovi codici brevi univoci e leggere/scrivere ID Cloud Anchor.

Utilizzare StorageManager

Modifica CloudAnchorFragment per utilizzare StorageManager per archiviare gli ID di ancoraggio 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());
  }
}

Ora crea ed esegui l'app da Android Studio. Quando crei e ospiti un ancoraggio, dovresti visualizzare i codici brevi anziché gli ID ancoraggio cloud lunghi.

Subito dopo aver posizionato un ancoraggio

Dopo aver atteso un po'

Tieni presente che i codici brevi generati da StorageManager vengono attualmente sempre assegnati in ordine crescente.

Successivamente, aggiungerai alcuni elementi della UI che ti consentiranno di inserire codici brevi e ricreare gli ancoraggi.

Aggiungere il pulsante Risolvi

Aggiungerai un altro pulsante accanto al pulsante CLEAR. Questo sarà il pulsante RISOLVI. Se fai clic sul pulsante RISOLVI, si apre una finestra di dialogo che chiede all'utente un codice breve. Il codice breve viene utilizzato per recuperare l'ID Cloud Anchor da StorageManager e risolvere l'ancora.

Per aggiungere il pulsante, devi modificare il file res/layout/cloud_anchor_fragment.xml. In Android Studio, fai doppio clic sul file, poi fai clic sulla scheda "Testo" in basso per visualizzare il codice 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 aprirsi una finestra di dialogo come mostrato di seguito.

Il pulsante RISOLVI è ora visibile

Se fai clic sul pulsante, viene visualizzata questa finestra di dialogo

Toccando l'aereo e ospitando un ancoraggio, il pulsante RISOLVI dovrebbe essere disattivato, ma toccando il pulsante CANCELLA dovrebbe essere riattivato. Questa è una scelta progettuale, in modo che nella scena sia presente un solo ancoraggio alla volta.

La finestra di dialogo "Risolvi ancora" non fa nulla, ma ora cambierai questa situazione.

Risolvi gli ancoraggi

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 e segui questi passaggi:

  1. Crea un ancoraggio su una superficie piana e attendi che venga ospitato.
    Ricorda lo shortcode.
  2. Premi il pulsante CLEAR per eliminare l'ancora.
  3. Premi il pulsante RISOLVI. Inserisci il codice breve del passaggio 1.
  4. Dovresti vedere un ancoraggio nella stessa posizione relativa all'ambiente in cui l'hai posizionato originariamente.
  5. Chiudi e termina l'app, quindi riaprila.
  6. Ripeti i passaggi (3) e (4). Dovresti vedere un nuovo ancoraggio, sempre nella stessa posizione.

Inserimento di un codice breve

L'ancora è stata risolta

5. Condividere contenuti tra dispositivi

Hai visto come puoi memorizzare l'ID Cloud Anchor di un ancoraggio nello spazio di archiviazione locale del dispositivo e recuperarlo in un secondo momento per ricreare lo stesso ancoraggio. Tuttavia, il pieno potenziale di Cloud Anchor si sblocca solo quando puoi condividere gli ID Cloud Anchor tra dispositivi diversi.

La modalità di condivisione degli ID Cloud Anchor della tua app dipende da te. 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 Cloud Anchor tra le istanze dell'app.

Configurazione di Firebase

Per utilizzare questa app, devi configurare un database Firebase Realtime con il tuo Account Google. Questa operazione è semplice con Firebase Assistant in Android Studio.

In Android Studio, fai clic su Strumenti > Firebase. Nel riquadro dell'assistente visualizzato, fai clic su Realtime Database, poi su Salva e recupera dati:

68e927cbf324a3b2.png

Fai clic sul pulsante Connetti a Firebase per connettere il tuo progetto Android Studio a un progetto Firebase nuovo o esistente.

63f3b1ffd6bd263e.png

Ti verrà chiesto di selezionare un modulo. Seleziona il modulo work:

be737c689ad6dd78.png

Viene visualizzata la finestra di dialogo Starting Connect. L'operazione potrebbe richiedere del tempo.

b48626f8672551ee.png

Accedi con il tuo Account Google e segui il flusso di lavoro web per creare un progetto Firebase per la tua app finché non torni ad Android Studio.

Successivamente, nel riquadro Assistente, fai clic su aggiungi Realtime Database alla tua app:

68e0843fa2531c4c.png

Nella finestra di dialogo visualizzata, seleziona work dal menu a discesa Modulo target, quindi fai clic su Accetta modifiche.

155fd89533c02671.png

Questo ti permetterà di:

  1. Aggiungere un file google-services.json alla directory work
  2. Aggiungi un paio di righe al file build.gradle nella stessa directory.
  3. Crea ed esegui l'app (potresti visualizzare un errore di risoluzione relativo al numero di versione del database Firebase).

Nel file build.gradle del modulo work, trova e rimuovi la seguente riga (xxxx è un segnaposto per il numero dell'ultima versione)

dependencies {
  ...
  implementation 'com.google.firebase:firebase-database:xxxx'

Successivamente, esamina (ma non seguire ancora) le istruzioni riportate nella pagina Configurare le regole per l'accesso pubblico per configurare Firebase Realtime Database in modo che sia scrivibile a livello globale. Ciò semplifica i test in questo codelab:

666ebefd39019c05.png

Dalla console Firebase, seleziona il progetto a cui hai collegato il progetto Android Studio, quindi seleziona BUILD > Realtime Database.

Località di Firebase Realtime Database

Fai clic su Crea database per configurare e impostare Realtime Database:

Crea database

Scegli una posizione del database.

Nel passaggio successivo, seleziona le regole di sicurezza della modalità di test e fai clic su Attiva:

Sicurezza del database

La tua app è ora configurata per utilizzare il database Firebase.

Utilizzo di FirebaseManager

Ora sostituirai StorageManager con FirebaseManager.

In Android Studio, trova la classe 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 nel seguente modo:

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));
  });
}

Poi, 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 l'app. Dovresti vedere lo stesso flusso dell'interfaccia utente della sezione precedente, tranne per il fatto che ora il database Firebase online viene utilizzato per archiviare gli ID Cloud Anchor e i codici brevi anziché lo spazio di archiviazione locale del dispositivo.

Test multiutente

Per testare un'esperienza multiutente, utilizza due smartphone diversi:

  1. Installa l'app su due dispositivi.
  2. Utilizza un dispositivo per ospitare un ancoraggio e generare un codice breve.
  3. Usa l'altro dispositivo per risolvere l'ancoraggio utilizzando il codice breve.

Dovresti essere in grado di ospitare ancore da un dispositivo, ottenere un codice breve e utilizzarlo sull'altro dispositivo per vedere l'ancora nello stesso punto.

6. Conclusione

Complimenti! Hai raggiunto la fine di questo codelab.

Argomenti trattati

  • Come ospitare ancore utilizzando l'SDK ARCore e ottenere un ID Cloud Anchor.
  • Come utilizzare gli ID ancoraggio cloud per risolvere gli ancoraggi.
  • Come archiviare e condividere gli ID ancoraggio cloud tra diverse sessioni AR sullo stesso dispositivo o su dispositivi diversi.

Scopri di più