Kotwice w chmurze ARCore z trwałymi kotwicami Cloud

1. Przegląd

ARCore to platforma do tworzenia aplikacji rzeczywistości rozszerzonej na urządzenia mobilne. Interfejs Cloud Anchors API umożliwia tworzenie aplikacji AR, które korzystają ze wspólnego układu odniesienia, dzięki czemu wielu użytkowników może umieszczać wirtualne treści w tej samej lokalizacji w rzeczywistym świecie.

W tym module dowiesz się, jak korzystać z interfejsu Cloud Anchors API. Weźmiesz istniejącą aplikację ARCore, zmodyfikujesz ją, aby korzystała z kotwic w chmurze, i utworzysz wspólne środowisko AR.

Kotwice ARCore i trwałe kotwice w chmurze

Podstawową koncepcją ARCore jest punkt zakotwiczenia, który opisuje stałą pozycję w świecie rzeczywistym. ARCore automatycznie dostosowuje wartość pozycji kotwicy w miarę poprawy śledzenia ruchu z biegiem czasu.

Zakotwiczenia w chmurze to zakotwiczenia hostowane w chmurze. Mogą być rozwiązywane przez wielu użytkowników, aby ustalić wspólny punkt odniesienia dla użytkowników i ich urządzeń.

Hosting Anchor

Gdy kotwica jest hostowana, dzieją się te rzeczy:

1. Pozycja kotwicy względem świata jest przesyłana do chmury i uzyskiwany jest identyfikator kotwicy w chmurze.
   Identyfikator kotwicy w chmurze to ciąg znaków, który należy wysłać do każdej osoby, która chce rozwiązać tę kotwicę.
2. Na serwery Google przesyłany jest zbiór danych zawierający dane wizualne dotyczące kotwicy.
   Ten zbiór danych zawiera dane wizualne, które były ostatnio widoczne dla urządzenia. Poruszanie urządzeniem w celu uchwycenia obszaru wokół punktu zakotwiczenia z różnych perspektyw przed rozpoczęciem hostowania poprawi lokalizację.

Przenoszenie identyfikatorów kotwic w chmurze

W tym module nauczysz się przenosić identyfikatory zakotwiczeń w chmurze za pomocą Firebase. Możesz udostępniać identyfikatory zakotwiczeń w chmurze w inny sposób.

Rozwiązywanie kotwicy

Za pomocą interfejsu Cloud Anchor API możesz rozwiązać kotwicę, używając jej identyfikatora Cloud Anchor. Spowoduje to utworzenie nowego punktu w tej samej lokalizacji fizycznej co pierwotny hostowany punkt. Podczas rozwiązywania urządzenie musi znajdować się w tym samym środowisku fizycznym co oryginalny zakotwiczony punkt.

Trwałe kotwice w chmurze

Przed wersją 1.20 kotwice w chmurze można było rozwiązywać tylko przez 24 godziny od momentu ich hostowania. Za pomocą interfejsu Persistent Cloud Anchors API możesz utworzyć kotwicę w chmurze, którą można rozwiązać w okresie od 1 dnia do 365 dni od jej utworzenia.

Co utworzysz

W tym ćwiczeniu będziesz pracować na podstawie istniejącej aplikacji ARCore. Po jego ukończeniu Twoja aplikacja będzie:

• możliwość hostowania trwałych kotwic w chmurze i uzyskiwania identyfikatorów kotwic w chmurze;
• Zapisywanie identyfikatorów kotwic w chmurze na urządzeniu, aby można je było łatwo pobrać za pomocą Androida SharedPreferences.
• Używaj zapisanych identyfikatorów zakotwiczeń w chmurze, aby rozwiązywać wcześniej hostowane zakotwiczenia. Dzięki temu możemy łatwo symulować obsługę wielu użytkowników na jednym urządzeniu na potrzeby tego laboratorium.
• Udostępniaj identyfikatory zakotwiczeń w chmurze innemu urządzeniu z tą samą aplikacją, aby wielu użytkowników widziało posąg Androida w tym samym miejscu.

W miejscu kotwicy w chmurze jest renderowany posąg Androida:

Czego się nauczysz

• Jak hostować kotwice za pomocą pakietu ARCore SDK i uzyskać identyfikator kotwicy w chmurze.
• Jak używać identyfikatorów Cloud Anchor do rozwiązywania kotwic.
• Jak przechowywać i udostępniać identyfikatory zakotwiczeń w chmurze między różnymi sesjami AR na tym samym lub różnych urządzeniach.

Czego potrzebujesz

• Obsługiwane urządzenie ARCore połączone z komputerem używanym do programowania kablem USB.
• Usługi Google Play dla AR w wersji 1.22 lub nowszej.
• komputer używany do programowania z Androidem Studio (wersja 3.0 lub nowsza);

2. Konfigurowanie środowiska programistycznego

Konfigurowanie komputera używanego do programowania

Podłącz urządzenie ARCore do komputera za pomocą kabla USB. Upewnij się, że urządzenie umożliwia debugowanie USB.

Otwórz terminal i uruchom polecenie adb devices, jak pokazano poniżej:

adb devices

List of devices attached
<DEVICE_SERIAL_NUMBER>    device

<DEVICE_SERIAL_NUMBER> to ciąg znaków unikalny dla Twojego urządzenia. Zanim przejdziesz dalej, upewnij się, że widzisz dokładnie 1 urządzenie.

Pobieranie i instalowanie kodu

Możesz sklonować repozytorium:

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

Możesz też pobrać plik ZIP i go rozpakować:

Pobierz plik ZIP

Uruchom Android Studio. Kliknij Otwórz istniejący projekt w Android Studio. Następnie przejdź do katalogu, w którym został rozpakowany pobrany wcześniej plik ZIP, i kliknij dwukrotnie katalog arcore-cloud-anchors.

Jest to pojedynczy projekt Gradle z wieloma modułami. Jeśli w lewym górnym rogu Androida Studio nie widzisz jeszcze okienka Projekt, w menu kliknij Projekty. Wynik powinien wyglądać tak:

Będziesz pracować głównie w module work. Inne moduły obejmują moduł helpers, który zawiera zestaw przydatnych klas opakowujących, z których będziesz korzystać. Dostępne są też kompletne rozwiązania dla każdej części ćwiczenia (w Codelabs). Z wyjątkiem modułu helpers każdy moduł jest aplikacją, którą można skompilować.

Jeśli zobaczysz okno z rekomendacją uaktualnienia wtyczki Androida do obsługi Gradle, kliknij Nie przypominaj mi więcej o tym projekcie:

Kliknij Uruchom > Uruchom... > „work”. W wyświetlonym oknie Select Deployment Target (Wybierz urządzenie docelowe) urządzenie powinno być widoczne w sekcji Connected Devices (Połączone urządzenia). Wybierz urządzenie i kliknij OK. Android Studio skompiluje początkową aplikację i uruchomi ją na urządzeniu.

Gdy uruchomisz aplikację po raz pierwszy, poprosi ona o uprawnienia CAMERA. Aby kontynuować, kliknij Zezwól.

Jak korzystać z tej aplikacji

1. Poruszaj urządzeniem, aby pomóc aplikacji znaleźć płaszczyznę. Po wykryciu płaszczyzny będzie ona widoczna jako powierzchnia z kropek.
2. Kliknij w dowolnym miejscu na płaszczyźnie, aby umieścić kotwicę. W miejscu, w którym umieszczono kotwicę, pojawi się postać Androida. Ta aplikacja umożliwia umieszczenie tylko jednego punktu naraz.
3. Przesuwaj urządzenie. Postać powinna pozostawać w tym samym miejscu, nawet jeśli urządzenie się porusza.
4. Aby usunąć punkt zakotwiczenia, naciśnij przycisk WYCZYŚĆ. Umożliwi to umieszczenie kolejnego kotwiczenia.

Jest to podobne do przykładowej aplikacji Hello AR opublikowanej w ARCore SDK.

Obecnie ta aplikacja używa śledzenia ruchu zapewnianego przez ARCore do śledzenia kotwicy w ramach jednego uruchomienia aplikacji. Jeśli zdecydujesz się zamknąć, zakończyć i ponownie uruchomić aplikację, wcześniej umieszczona kotwica i wszystkie powiązane z nią informacje, w tym jej pozycja, zostaną utracone.

W kolejnych sekcjach rozbudujesz tę aplikację, aby zobaczyć, jak można udostępniać kotwice w ramach sesji AR.

3. Hostowanie Anchor

W tej sekcji zmodyfikujesz projekt work, aby hostować kotwicę. Zanim napiszesz kod, musisz wprowadzić kilka zmian w konfiguracji aplikacji.

Deklarowanie uprawnień INTERNET

Ponieważ kotwice w chmurze wymagają komunikacji z usługą ARCore Cloud Anchor API, Twoja aplikacja musi mieć uprawnienia dostępu do internetu.

W pliku AndroidManifest.xml dodaj ten wiersz tuż pod deklaracją uprawnień 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"/>

Włączanie interfejsu ARCore API

1. Otwórz stronę usługi ARCore API.
2. Na liście projektów wybierz projekt lub utwórz nowy.
3. Kliknij Włącz.

Konfigurowanie uwierzytelniania bezkluczykowego

Aby korzystać z trwałych kotwic w chmurze, musisz użyć uwierzytelniania bez klucza do uwierzytelniania w interfejsie ARCore API.

1. Otwórz konsolę Google Cloud Platform.
2. Na liście projektów wybierz projekt.
3. Jeśli strona Interfejsy API i usługi nie jest jeszcze otwarta, otwórz boczne menu konsoli i kliknij Interfejsy API i usługi.
4. Po lewej stronie kliknij Dane logowania.
5. Kliknij Utwórz dane logowania i wybierz Identyfikator klienta OAuth.
6. Wpisz te wartości:
   • Typ aplikacji: Android
   • Nazwa pakietu: com.google.ar.core.codelab.cloudanchor
7. Pobierz odcisk cyfrowy certyfikatu podpisywania debugowania:
   1. W projekcie Android Studio otwórz panel narzędzi Gradle.
   2. W folderze cloud-anchors > work > Tasks > android uruchom zadanie signingReport.
   3. Skopiuj odcisk cyfrowy SHA-1 do pola Odcisk cyfrowy certyfikatu SHA-1 w Google Cloud.

Konfigurowanie ARCore

Następnie zmodyfikujesz aplikację, aby hostowała kotwicę po kliknięciu przez użytkownika, a nie w zwykły sposób. Aby to zrobić, musisz skonfigurować sesję ARCore, aby włączyć kotwice w chmurze.

W pliku CloudAnchorFragment.java dodaj ten kod:

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

Zanim przejdziesz dalej, skompiluj i uruchom aplikację. Pamiętaj, aby skompilować tylko moduł work. Aplikacja powinna zostać skompilowana i działać tak samo jak wcześniej.

Hostowanie kotwicy

Czas na hostowanie kotwicy, która zostanie przesłana do interfejsu ARCore API.

Dodaj do klasy CloudAnchorFragment to nowe pole:

// Find this line...
private Anchor currentAnchor = null;

// Add these lines right below.
@Nullable
private Future future = null;

Pamiętaj, aby dodać import dla com.google.ar.core.Future.

Zmodyfikuj metodę onClearButtonPressed w ten sposób:

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

Następnie dodaj do klasy CloudAnchorFragment tę metodę:

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

Znajdź w klasie CloudAnchorFragment metodę handleTap i dodaj te wiersze:

// Find this line...
currentAnchor = hit.createAnchor();

// Add these lines right below:
messageSnackbarHelper.showMessage(getActivity(), "Now hosting anchor...");
future = session.hostCloudAnchorAsync(currentAnchor, 300, this::onHostComplete);

Ponownie uruchom aplikację w Androidzie Studio. Po umieszczeniu kotwicy powinien pojawić się komunikat „Teraz hostuję kotwicę...”. Po zakończeniu hostingu powinien pojawić się kolejny komunikat. Jeśli zobaczysz komunikat „Error hosting anchor: ERROR_NOT_AUTHORIZED”, sprawdź, czy klient OAuth jest prawidłowo skonfigurowany.

Więcej informacji o błędach podczas hostowania kotwic znajdziesz w dokumentacji stanu kotwicy w chmurze.

Każda osoba, która zna identyfikator kotwicy i znajduje się w tej samej przestrzeni fizycznej co kotwica, może użyć tego identyfikatora, aby utworzyć kotwicę w dokładnie tej samej pozycji (położeniu i orientacji) względem otoczenia.

Identyfikator kotwicy jest jednak długi i trudny do ręcznego wpisania przez innego użytkownika. W kolejnych sekcjach zapiszesz identyfikatory zakotwiczeń w chmurze w sposób, który ułatwi ich pobieranie, aby umożliwić rozwiązywanie zakotwiczeń na tym samym lub innym urządzeniu.

4. Przechowywanie identyfikatorów i rozwiązywanie kotwic

W tej części przypiszesz krótkie kody do długich identyfikatorów Cloud Anchor, aby ułatwić innemu użytkownikowi ręczne wpisywanie. Do przechowywania identyfikatorów zakotwiczeń w chmurze jako wartości w tabeli par klucz-wartość będziesz używać interfejsu API Shared Preferences. Ta tabela będzie dostępna nawet po zamknięciu i ponownym uruchomieniu aplikacji.

Klasa pomocnicza o nazwie StorageManager jest już dostępna. Jest to otoka interfejsu SharedPreferences API, która zawiera metody generowania nowych, unikalnych krótkich kodów oraz odczytywania i zapisywania identyfikatorów zakotwiczeń w chmurze.

Korzystanie z Menedżera miejsca

Zmodyfikuj CloudAnchorFragment, aby używać StorageManager do przechowywania identyfikatorów zakotwiczeń w chmurze z krótkimi kodami, dzięki czemu można je łatwo pobrać.

Utwórz w CloudAnchorFragment to nowe pole:

// Find this line...
private TapHelper tapHelper;

// And add the storageManager.
private final StorageManager storageManager = new StorageManager();

Następnie zmień metodę 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());
  }
}

Teraz skompiluj i uruchom aplikację w Androidzie Studio. Podczas tworzenia i hostowania kotwicy zamiast długich identyfikatorów kotwic w chmurze powinny być wyświetlane krótkie kody.

Natychmiast po umieszczeniu kotwicy	Po chwili oczekiwania

Pamiętaj, że krótkie kody generowane przez StorageManager są obecnie zawsze przypisywane w kolejności rosnącej.

Następnie dodasz kilka elementów interfejsu, które umożliwią wprowadzanie krótkich kodów i ponowne tworzenie kotwic.

Dodawanie przycisku Rozwiąż

Obok przycisku CLEAR dodasz kolejny przycisk. Będzie to przycisk ROZWIĄŻ. Kliknięcie przycisku ROZWIĄŻ spowoduje otwarcie okna, w którym użytkownik zostanie poproszony o podanie krótkiego kodu. Krótki kod służy do pobierania identyfikatora zakotwiczenia w chmurze z StorageManager i rozwiązywania zakotwiczenia.

Aby dodać przycisk, musisz zmodyfikować plik res/layout/cloud_anchor_fragment.xml. W Android Studio kliknij dwukrotnie plik, a następnie kliknij kartę „Tekst” u dołu, aby wyświetlić nieprzetworzony kod XML. Wprowadź te zmiany:

<!-- 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"/>

Teraz dodaj nowe pole do CloudAnchorFragment:

private Button resolveButton;

Aby dodać nową metodę:

private void onResolveButtonPressed() {
  ResolveDialogFragment dialog = new ResolveDialogFragment();
  dialog.show(getFragmentMagetActivity().getSupportFragmentManagernager(), "Resolve");
}

Zainicjuj resolveButton w metodzie onCreateView w ten sposób:

// 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());

Znajdź metodę handleTap i zmodyfikuj ją:

private void handleTap(Frame frame, Camera camera) {
  // ...

  // Find this line.
  currentAnchor = hit.createAnchor();

  // Add this line right below.
  getActivity().runOnUiThread(() -> resolveButton.setEnabled(false)); 
}

Dodaj wiersz w metodzie 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);
}

Utwórz i uruchom aplikację w Androidzie Studio. Obok przycisku WYCZYŚĆ powinien się wyświetlić przycisk ROZWIĄŻ. Kliknięcie przycisku ROZWIĄŻ powinno spowodować wyświetlenie okna dialogowego, jak pokazano poniżej.

Przycisk ROZWIĄŻ jest teraz widoczny	Kliknięcie przycisku powoduje wyświetlenie tego okna

Dotknięcie samolotu i umieszczenie kotwicy powinno wyłączyć przycisk RESOLVE, ale dotknięcie przycisku CLEAR powinno go ponownie włączyć. Jest to celowe działanie, aby w scenie był tylko jeden punkt kotwiczenia naraz.

Okno „Resolve Anchor” (Rozwiąż kotwicę) nie robi nic, ale teraz to zmienisz.

Rozwiązywanie kotwic

Dodaj te metody w klasie 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);
  }
}

Następnie zmień metodę onResolveButtonPressed:

private void onResolveButtonPressed() {
  ResolveDialogFragment dialog = ResolveDialogFragment.createWithOkListener(
      this::onShortCodeEntered);
  dialog.show(getActivity().getSupportFragmentManager(), "Resolve");
}

Skompiluj i uruchom aplikację w Android Studio, a potem wykonaj te czynności:

1. Utwórz kotwicę na płaszczyźnie i poczekaj, aż zostanie ona umieszczona.
   Zapamiętaj krótki kod.
2. Aby usunąć kotwicę, naciśnij przycisk CLEAR.
3. Kliknij przycisk ROZWIĄŻ. Wpisz krótki kod z kroku 1.
4. Powinien pojawić się punkt zakotwiczenia w tej samej pozycji względem otoczenia, w której został pierwotnie umieszczony.
5. Zamknij aplikację i zakończ jej działanie, a potem otwórz ją ponownie.
6. Powtórz kroki (3) i (4). Powinien pojawić się nowy punkt, ponownie w tym samym miejscu.

Wpisywanie krótkiego kodu	Punkt został rozwiązany

5. Udostępnianie między urządzeniami

Wiesz już, jak zapisać identyfikator kotwicy w chmurze w pamięci lokalnej urządzenia i później go odzyskać, aby ponownie utworzyć tę samą kotwicę. Pełny potencjał kotwic w chmurze można jednak wykorzystać dopiero wtedy, gdy identyfikatory kotwic w chmurze można udostępniać na różnych urządzeniach.

Sposób udostępniania identyfikatorów zakotwiczeń w chmurze zależy od Ciebie. Do przeniesienia ciągu znaków z jednego urządzenia na drugie można użyć dowolnego sposobu. W tym laboratorium użyjesz Bazy danych czasu rzeczywistego Firebase do przesyłania identyfikatorów zakotwiczeń w chmurze między instancjami aplikacji.

Konfigurowanie Firebase

Aby korzystać z tej aplikacji, musisz skonfigurować bazę danych czasu rzeczywistego Firebase na swoim koncie Google. Możesz to łatwo zrobić za pomocą funkcji Firebase Assistant w Android Studio.

W Android Studio kliknij Narzędzia > Firebase. W wyświetlonym panelu Asystenta kliknij Baza danych czasu rzeczywistego, a potem Zapisywanie i pobieranie danych:

Kliknij przycisk Połącz z Firebase, aby połączyć projekt Android Studio z nowym lub istniejącym projektem w Firebase.

Pojawi się prośba o wybranie modułu. Wybierz moduł work:

Wyświetli się okno dialogowe Starting Connect (Rozpoczynanie połączenia). Może to chwilę potrwać.

Zaloguj się na konto Google i wykonaj w przeglądarce czynności związane z tworzeniem projektu w Firebase dla aplikacji, aż wrócisz do Android Studio.

Następnie w panelu Asystent kliknij dodaj bazę danych czasu rzeczywistego do aplikacji:

W wyświetlonym oknie wybierz work z menu Moduł docelowy, a potem kliknij Zaakceptuj zmiany.

Efekt:

1. Dodawanie pliku google-services.json do katalogu work
2. Dodaj kilka wierszy do pliku build.gradle w tym samym katalogu.
3. Skompiluj i uruchom aplikację (może pojawić się błąd dotyczący numeru wersji bazy danych Firebase).

W pliku modułu workbuild.gradle znajdź i usuń ten wiersz (xxxx to symbol zastępczy najnowszego numeru wersji):

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

Następnie zapoznaj się z instrukcjami, do których link znajdziesz na stronie konfigurowania reguł dostępu publicznego, aby skonfigurować Bazę danych czasu rzeczywistego Firebase tak, aby można było w niej zapisywać dane z dowolnego miejsca na świecie. Nie wykonuj jeszcze tych instrukcji. Ułatwia to testowanie w tym laboratorium:

W konsoli Firebase wybierz projekt, z którym połączono projekt Android Studio, a następnie kliknij BUILD > Realtime Database (KOMPILACJA > Baza danych czasu rzeczywistego).

Aby skonfigurować i ustawić bazę danych czasu rzeczywistego, kliknij Utwórz bazę danych:

Wybierz dowolną lokalizację bazy danych.

W następnym kroku wybierz reguły zabezpieczeń trybu testowego i kliknij Włącz:

Aplikacja jest teraz skonfigurowana do korzystania z bazy danych Firebase.

Korzystanie z klasy FirebaseManager

Teraz zastąp StorageManager znakiem FirebaseManager.

W Android Studio znajdź klasę CloudAnchorFragment w katalogu work. Zastąp znak StorageManager znakiem FirebaseManager:

// Find this line.
private final StorageManager storageManager = new StorageManager();

// And replace it with this line.
private FirebaseManager firebaseManager;

Zainicjuj firebaseManager w metodzie 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);
}

Zmodyfikuj metodę onShortCodeEntered w ten sposób:

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

Następnie zmodyfikuj metodę onHostComplete w ten sposób:

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

Skompiluj i uruchom aplikację. Powinien pojawić się ten sam interfejs co w poprzedniej sekcji, z tą różnicą, że do przechowywania identyfikatorów zakotwiczeń w chmurze i krótkich kodów będzie teraz używana internetowa baza danych Firebase, a nie lokalna pamięć urządzenia.

Testowanie z udziałem wielu użytkowników

Aby przetestować funkcję wielu użytkowników, użyj 2 różnych telefonów:

1. Zainstaluj aplikację na 2 urządzeniach.
2. Użyj jednego urządzenia, aby hostować kotwicę i wygenerować krótki kod.
3. Użyj drugiego urządzenia, aby rozwiązać problem z kotwicą za pomocą tego krótkiego kodu.

Powinno być możliwe hostowanie kotwic na jednym urządzeniu, uzyskanie krótkiego kodu i użycie go na drugim urządzeniu, aby zobaczyć kotwicę w tym samym miejscu.

6. Podsumowanie

Gratulacje! To już koniec tego ćwiczenia.

Omówione zagadnienia

• Jak hostować kotwice za pomocą pakietu ARCore SDK i uzyskać identyfikator kotwicy w chmurze.
• Jak używać identyfikatorów Cloud Anchor do rozwiązywania kotwic.
• Jak przechowywać i udostępniać identyfikatory zakotwiczeń w chmurze między różnymi sesjami AR na tym samym lub różnych urządzeniach.

Więcej informacji

• Zapoznaj się z omówieniem Cloud Anchors na Androida