עוגןי ARCore בענן עם עוגןים מתמידים בענן

1. סקירה כללית

‫ARCore היא פלטפורמה ליצירת אפליקציות של מציאות רבודה במכשירים ניידים. Cloud Anchors API מאפשר לכם ליצור אפליקציות AR שמשתפות מסגרת הפניה משותפת, וכך מאפשרות למספר משתמשים להציב תוכן וירטואלי באותו מיקום בעולם האמיתי.

בשיעור הזה תלמדו איך להשתמש ב-Cloud Anchors API. תקחו אפליקציית ARCore קיימת, תשנו אותה כך שתשתמש בנקודות עיגון בענן ותיצרו חוויית AR משותפת.

עוגנים של ARCore ועוגנים קבועים בענן

מושג בסיסי ב-ARCore הוא עוגן, שמתאר מיקום קבוע בעולם האמיתי. ‫ARCore משנה באופן אוטומטי את הערך של מיקום העוגן ככל שמעקב התנועה משתפר עם הזמן.

עוגנים בענן הם עוגנים שמתארחים בענן. משתמשים רבים יכולים לפתור אותם כדי ליצור מסגרת התייחסות משותפת בין המשתמשים והמכשירים שלהם.

אירוח של עוגן

כשמארחים עוגן, קורים הדברים הבאים:

המיקום של העוגן ביחס לעולם מועלה לענן, ומתקבל מזהה של עוגן בענן.
מזהה העוגן בענן הוא מחרוזת שצריך לשלוח לכל מי שרוצה לפתור את העוגן הזה.
מערך נתונים שמכיל נתונים חזותיים של העוגן מועלה לשרתים של Google.
מערך הנתונים הזה מכיל נתונים חזותיים שהמכשיר ראה לאחרונה. כדי לשפר את הלוקליזציה, כדאי להזיז קצת את המכשיר כדי לצלם את האזור מסביב לעוגן מנקודות מבט שונות לפני שמארחים את הסשן.

העברת מזהים של עוגנים בענן

ב-codelab הזה תעבירו מזהי עוגנים בענן באמצעות Firebase. אתם יכולים לשתף מזהים של עוגנים ב-Cloud באמצעים אחרים.

התחלת פגישות באמצעות כינוי

אפשר להשתמש ב-Cloud Anchor API כדי לפתור עוגן באמצעות מזהה העוגן בענן. הפעולה הזו יוצרת עוגן חדש באותו מיקום פיזי שבו נמצא העוגן המארח המקורי. במהלך הפתרון, המכשיר צריך להתבסס על אותה סביבה פיזית כמו העוגן המארח המקורי.

עוגנים מתמידים בענן

לפני גרסה 1.20, אפשר היה לפתור את הבעיה של עוגנים בענן רק למשך 24 שעות אחרי שהם מתארחים. באמצעות Persistent Cloud Anchors API (ממשק API של עוגנים קבועים בענן), אפשר ליצור עוגן בענן שאפשר לפתור אותו למשך יום אחד עד 365 ימים אחרי היצירה.

מה תפַתחו

ב-Codelab הזה תבנו על בסיס אפליקציית ARCore קיימת. בסוף ה-Codelab, האפליקציה שלכם:

היכולת לארח עוגנים קבועים בענן ולקבל מזהי עוגנים בענן.
שמירת מזהים של עוגנים בענן במכשיר כדי לאחזר אותם בקלות באמצעות Android SharedPreferences.
שימוש במזהי עוגנים בענן שנשמרו כדי לפתור עוגנים שאוחסנו בעבר. כך קל לנו לדמות חוויית שימוש של כמה משתמשים במכשיר אחד לצורך ה-codelab הזה.
לשתף מזהי עוגן בענן עם מכשיר אחר שמופעלת בו אותה אפליקציה, כדי שכמה משתמשים יוכלו לראות את פסל האנדרואיד באותו מיקום.

פסל Android מוצג במיקום של עוגן הענן:

מה תלמדו

איך מארחים עוגנים באמצעות ARCore SDK ומקבלים מזהה עוגן בענן.
איך משתמשים במזהי עוגנים ב-Cloud כדי לפתור עוגנים.
איך לאחסן ולשתף מזהים של עוגנים ב-Cloud בין סשנים שונים של AR באותו מכשיר או במכשירים שונים.

הדרישות

מכשיר נתמך של ARCore שמחובר למחשב הפיתוח באמצעות כבל USB.
‫Google Play Services למציאות רבודה גרסה 1.22 ואילך.
מחשב פיתוח עם Android Studio (גרסה 3.0 ואילך).

2. הגדרת סביבת הפיתוח

הגדרת מחשב הפיתוח

מחברים את מכשיר ARCore למחשב באמצעות כבל USB. מוודאים שהמכשיר מאפשר ניפוי באגים ב-USB.

פותחים טרמינל ומריצים את הפקודה adb devices, כמו שמוצג בהמשך:

adb devices

List of devices attached
<DEVICE_SERIAL_NUMBER>    device

הערך של <DEVICE_SERIAL_NUMBER> יהיה מחרוזת ייחודית למכשיר שלכם. לפני שממשיכים, חשוב לוודא שמופיע מכשיר אחד בלבד.

הורדה והתקנה של הקוד

אפשר לשכפל את המאגר:

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

אפשר גם להוריד קובץ ZIP ולחלץ אותו:

מפעילים את Android Studio. לוחצים על Open an existing Android Studio project (פתיחת פרויקט קיים ב-Android Studio). לאחר מכן, עוברים לספרייה שבה חילצתם את קובץ ה-ZIP שהורדתם למעלה, ולוחצים לחיצה כפולה על הספרייה arcore-cloud-anchors.

זהו פרויקט Gradle יחיד עם כמה מודולים. אם החלונית Project בפינה הימנית העליונה של Android Studio לא מוצגת כבר בחלונית Project, לוחצים על Projects בתפריט הנפתח. התוצאה צריכה להיראות כך:

העבודה מתבצעת בעיקר במודול work. מודולים אחרים כוללים מודול helpers שמכיל קבוצה של מחלקות wrapper שימושיות שתשתמשו בהן. יש גם פתרונות מלאים לכל חלק ב-Codelab. כל מודול הוא אפליקציה שאפשר לבנות, למעט המודול helpers.

אם מוצג לכם תיבת דו-שיח עם המלצה לשדרג את הפלאגין של Android Gradle, לוחצים על Don't remind me again for this project (אל תציג לי שוב תזכורת לגבי הפרויקט הזה):

לוחצים על הפעלה > הפעלה... > 'עבודה'. בתיבת הדו-שיח Select Deployment Target שמופיעה, המכשיר שלכם אמור להופיע בקטע Connected Devices. בוחרים את המכשיר ולוחצים על אישור. ‫Android Studio ייצור את האפליקציה הראשונית ויפעיל אותה במכשיר.

כשמפעילים את האפליקציה בפעם הראשונה, היא מבקשת את ההרשאה CAMERA. מקישים על אישור כדי להמשיך.

איך להשתמש באפליקציה

מזיזים את המכשיר כדי לעזור לאפליקציה למצוא מטוס. כשמישור מזוהה, הוא מוצג כמשטח מנוקד.
מקישים במקום כלשהו על המישור כדי להציב עוגן. דמות של Android תצויר במקום שבו הוצב העוגן. האפליקציה הזו מאפשרת להציב רק עוגן אחד בכל פעם.
מזיזים את המכשיר. הדמות אמורה להישאר באותו מקום גם אם המכשיר זז.
לוחצים על הלחצן CLEAR כדי להסיר את העוגן. כך תוכלו להציב עוגן אחר.

בשלב הזה, האפליקציה הזו משתמשת רק במעקב התנועה שמסופק על ידי ARCore כדי לעקוב אחרי עוגן בהפעלה יחידה של האפליקציה. אם תחליטו לצאת מהאפליקציה, להפסיק אותה ולהפעיל אותה מחדש, העוגן שהוצב קודם וכל המידע שקשור אליו, כולל המיקום שלו, יימחקו.

בקטעים הבאים נשתמש באפליקציה הזו כדי להסביר איך אפשר לשתף עוגנים בין סשנים של AR.

3. איך מארחים מודעת עוגן

בקטע הזה תשנו את הפרויקט work כדי לארח עוגן. לפני שכותבים קוד, צריך לבצע כמה שינויים בהגדרות של האפליקציה.

הצהרה על הרשאות INTERNET

מכיוון ש-Cloud Anchors דורש תקשורת עם שירות Cloud Anchor API של ARCore, לאפליקציה שלכם צריכה להיות הרשאה לגשת לאינטרנט.

בקובץ AndroidManifest.xml, מוסיפים את השורה הבאה מיד מתחת להצהרת ההרשאה 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"/>

הפעלת ARCore API

עוברים לדף השירות ARCore API.
ברשימת הפרויקטים, בוחרים פרויקט או יוצרים פרויקט חדש.
לוחצים על הפעלה.

הגדרת אימות ללא מפתח

כדי להשתמש בנקודות עיגון קבועות בענן, צריך להשתמש באימות ללא מפתח כדי לבצע אימות באמצעות ARCore API.

עוברים אל Google Cloud Platform Console.
בוחרים פרויקט מרשימת הפרויקטים.
אם הדף APIs & Services (ממשקי API ושירותים) לא פתוח, פותחים את תפריט הצד במסוף ובוחרים באפשרות APIs & Services (ממשקי API ושירותים).
בצד ימין, לוחצים על פרטי כניסה.
לוחצים על Create Credentials (יצירת פרטי כניסה) ואז על OAuth client ID (מזהה לקוח OAuth).
ממלאים את הערכים הבאים:
- סוג האפליקציה: Android
- Package name (שם החבילה): com.google.ar.core.codelab.cloudanchor
מאחזרים את טביעת האצבע לאישור החתימה לניפוי באגים:
1. בפרויקט Android Studio, פותחים את חלונית הכלים של Gradle.
2. בתיקייה cloud-anchors > work > Tasks > android, מריצים את המשימה signingReport.
3. מעתיקים את טביעת האצבע של SHA-1 לשדה טביעת אצבע לאישור SHA-1 ב-Google Cloud.

הגדרת ARCore

בשלב הבא, תשנו את האפליקציה כך שהיא תארח עוגן בלחיצה של משתמש במקום עוגן רגיל. כדי לעשות את זה, צריך להגדיר את סשן ARCore כך שיאפשר שימוש בעוגנים בענן.

מוסיפים את הקוד הבא לקובץ CloudAnchorFragment.java:

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

לפני שממשיכים, צריך ליצור את האפליקציה ולהפעיל אותה. חשוב ליצור רק את מודול work. האפליקציה אמורה להיבנות בהצלחה ולפעול כמו קודם.

אירוח של עוגן

הגיע הזמן לארח עוגן שיועלה ל-ARCore API.

מוסיפים את השדה החדש הבא למחלקה CloudAnchorFragment:

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

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

חשוב לזכור להוסיף ייבוא לcom.google.ar.core.Future.

משנים את השיטה onClearButtonPressed באופן הבא:

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

בשלב הבא, מוסיפים את ה-method הבא למחלקה 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());
  }
}

מחפשים את ה-method‏ handleTap במחלקה CloudAnchorFragment ומוסיפים את השורות הבאות:

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

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

מריצים את האפליקציה מ-Android Studio שוב. כשמציבים עוגן, אמורה להופיע ההודעה העוגן מתארח עכשיו.... אחרי שהאירוח יסתיים בהצלחה, תוצג הודעה נוספת. אם מופיעה השגיאה Error hosting anchor: ERROR_NOT_AUTHORIZED, צריך לוודא שלקוח ה-OAuth מוגדר בצורה תקינה.

כל מי שיודע את מזהה העוגן ונמצא באותו מרחב פיזי שבו נמצא העוגן יכול להשתמש במזהה העוגן כדי ליצור עוגן באותה תנוחה בדיוק (מיקום וכיוון) ביחס לסביבה שלו.

עם זאת, מזהה העוגן ארוך, ולא קל למשתמש אחר להזין אותו באופן ידני. בקטעים הבאים, תאחסנו מזהים של עוגנים בענן בצורה שמאפשרת שליפה קלה, כדי לאפשר זיהוי של עוגנים באותו מכשיר או במכשיר אחר.

4. אחסון מזהים ופתרון עוגנים

בחלק הזה, תקצו קודים קצרים למזהים הארוכים של עוגני הענן, כדי שמשתמש אחר יוכל להזין אותם בקלות באופן ידני. תשתמשו ב-API של Shared Preferences כדי לאחסן את מזהי העוגנים של Cloud כערכים בטבלת מפתח-ערך. הטבלה הזו תישמר גם אם האפליקציה תיסגר ותופעל מחדש.

כבר מסופקת לכם מחלקה מסייעת בשם StorageManager. זהו wrapper סביב SharedPreferences API שיש בו methods ליצירת קודים קצרים ייחודיים חדשים ולקריאה/כתיבה של מזהי Cloud Anchor.

שימוש ב-StorageManager

משנים את CloudAnchorFragment לשימוש ב-StorageManager כדי לאחסן מזהים של עוגנים ב-Cloud עם קודים קצרים, כך שאפשר יהיה לאחזר אותם בקלות.

יוצרים את השדה החדש הבא ב-CloudAnchorFragment:

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

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

לאחר מכן משנים את השיטה 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());
  }
}

עכשיו, מבצעים build ומריצים את האפליקציה מ-Android Studio. כשיוצרים ומארחים עוגן, אמורים לראות קודים קצרים במקום מזהי העוגן הארוכים ב-Cloud.

מיד אחרי הצבת עוגן	אחרי שמחכים קצת

הערה: בשלב הזה, הקודים הקצרים שנוצרים על ידי StorageManager תמיד מוקצים בסדר עולה.

בשלב הבא, תוסיפו כמה רכיבי ממשק משתמש שיאפשרו לכם להזין קודים קצרים וליצור מחדש את העוגנים.

הוספת לחצן הפתרון

תוסיפו עוד לחצן ליד הלחצן CLEAR. זה יהיה לחצן הפתרון. לחיצה על הכפתור פתרון תפתח תיבת דו-שיח שבה המשתמש יתבקש להזין קוד קצר. הקוד הקצר משמש לאחזור מזהה העוגן ב-Cloud מ-StorageManager ולפתרון העוגן.

כדי להוסיף את הלחצן, צריך לשנות את הקובץ res/layout/cloud_anchor_fragment.xml. ב-Android Studio, לוחצים לחיצה כפולה על הקובץ ואז לוחצים על הכרטיסייה Text (טקסט) בחלק התחתון כדי להציג את ה-XML הגולמי. מבצעים את השינויים הבאים:

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

עכשיו מוסיפים שדה חדש ל-CloudAnchorFragment:

private Button resolveButton;

כדי להוסיף אמצעי תשלום חדש:

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

מאתחלים את resolveButton בשיטה onCreateView באופן הבא:

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

מאתרים את השיטה handleTap ומשנים אותה:

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

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

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

מוסיפים שורה בשיטה 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);
}

מבצעים build של האפליקציה ומריצים אותה מ-Android Studio. הלחצן פתרון אמור להופיע לצד הלחצן ניקוי. אחרי שלוחצים על הלחצן RESOLVE, אמורה להופיע תיבת דו-שיח כמו שמוצג למטה.

הלחצן פתרון מוצג עכשיו	לחיצה על הכפתור גורמת להצגת תיבת הדו-שיח הזו

הקשה על המטוס ואירוח עוגן אמורה להשבית את הלחצן RESOLVE, אבל הקשה על הלחצן CLEAR אמורה להפעיל אותו מחדש. זהו מצב שנוצר בכוונה, כדי שרק עוגן אחד יהיה בסצנה בכל פעם.

תיבת הדו-שיח Resolve Anchor (פתרון העוגן) לא עושה כלום, אבל עכשיו תשנו את זה.

פתרון של עוגנים

מוסיפים את ה-methods הבאים למחלקה 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);
  }
}

לאחר מכן, משנים את השיטה onResolveButtonPressed:

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

מבצעים build של האפליקציה ומריצים אותה מ-Android Studio, ופועלים לפי השלבים הבאים:

יוצרים עוגן במישור ומחכים שהעוגן יתארח.
זוכרים את המספר המקוצר.
לוחצים על הלחצן CLEAR כדי למחוק את העוגן.
לוחצים על הלחצן פתרון. מזינים את המספר המקוצר משלב 1.
נקודת העוגן אמורה להופיע באותו מיקום יחסי לסביבה שבו הצבתם אותה במקור.
יוצאים מהאפליקציה וסוגרים אותה, ואז פותחים אותה שוב.
חוזרים על שלבים (3) ו-(4). אמור להופיע עוגן חדש, שוב באותו מיקום.

הזנת קוד קצר	העוגן נפתר בהצלחה

5. שיתוף בין מכשירים

ראיתם איך אפשר לאחסן את מזהה העוגן של Cloud Anchor באחסון המקומי של המכשיר, ולאחזר אותו מאוחר יותר כדי ליצור מחדש את אותו עוגן. אבל כדי לממש את הפוטנציאל המלא של עוגנים בענן, צריך להיות אפשר לשתף את מזהי העוגנים בענן בין מכשירים שונים.

אתם קובעים איך האפליקציה שלכם משתפת מזהי עוגנים ב-Cloud. אפשר להשתמש בכל דבר כדי להעביר את המחרוזת ממכשיר אחד למכשיר אחר. בסדנת הקוד הזו תשתמשו במסד נתונים בזמן אמת ב-Firebase כדי להעביר מזהי עוגן בענן בין מופעים של האפליקציה.

הגדרת Firebase

כדי להשתמש באפליקציה הזו, צריך להגדיר מסד נתונים בזמן אמת ב-Firebase באמצעות חשבון Google. קל לעשות את זה באמצעות Firebase Assistant ב-Android Studio.

ב-Android Studio, לוחצים על Tools > Firebase (כלים > Firebase). בחלונית העזרה שמופיעה, לוחצים על מסד נתונים בזמן אמת ואז על שמירה ואחזור של נתונים:

לוחצים על הלחצן Connect to Firebase (קישור ל-Firebase) כדי לקשר את הפרויקט ב-Android Studio לפרויקט חדש או קיים ב-Firebase.

תתבקשו לבחור מודול. בוחרים במודול work:

מוצגת תיבת הדו-שיח Starting Connect. יכול להיות שזה ייקח קצת זמן.

נכנסים לחשבון Google ועוברים את תהליך העבודה באינטרנט ליצירת פרויקט Firebase לאפליקציה עד שחוזרים ל-Android Studio.

בשלב הבא, בחלונית Assistant, לוחצים על add the Realtime Database to your app (הוספת מסד הנתונים בזמן אמת לאפליקציה):

בתיבת הדו-שיח שמופיעה, בוחרים באפשרות עבודה בתפריט הנפתח מודול היעד, ואז לוחצים על אישור השינויים.

כתוצאה מכך, יקרו הדברים הבאים:

הוספת קובץ google-services.json לספרייה work
מוסיפים כמה שורות לקובץ build.gradle באותה ספרייה.
מבצעים Build לאפליקציה ומריצים אותה (יכול להיות שתוצג שגיאת פתרון לגבי מספר הגרסה של מסד הנתונים ב-Firebase).

בקובץ work של המודול build.gradle, מוצאים ומסירים את השורה הבאה (התו xxxx הוא placeholder למספר הגרסה העדכני)

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

לאחר מכן, קוראים (אך לא מבצעים עדיין) את ההוראות שמקושרות מהדף הגדרת הכללים לגישה ציבורית כדי להגדיר את מסד נתונים בזמן אמת ב-Firebase כך שניתן יהיה לכתוב בו מכל מקום בעולם. כך קל יותר לבצע בדיקות ב-Codelab הזה:

במסוף Firebase, בוחרים את הפרויקט שאליו קישרתם את פרויקט Android Studio, ואז בוחרים באפשרות BUILD (פיתוח) > Realtime Database (מסד נתונים בזמן אמת).

המיקום של מסד נתונים בזמן אמת ב-Firebase

לוחצים על יצירת מסד נתונים כדי להגדיר ולהגדיר את מסד נתונים בזמן אמת:

יצירת מסד נתונים

בוחרים מיקום למסד הנתונים.

בשלב הבא, בוחרים את כללי האבטחה של מצב הבדיקה ולוחצים על הפעלה:

אבטחת מסד נתונים

האפליקציה מוגדרת עכשיו לשימוש במסד הנתונים של Firebase.

שימוש ב-FirebaseManager

עכשיו צריך להחליף את StorageManager ב-FirebaseManager.

ב-Android Studio, מאתרים את המחלקה CloudAnchorFragment בספרייה work. מחליפים את StorageManager ב-FirebaseManager:

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

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

מפעילים את firebaseManager בשיטה 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);
}

משנים את השיטה onShortCodeEntered באופן הבא:

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

לאחר מכן, משנים את השיטה onHostComplete באופן הבא:

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

בונים את האפליקציה ומריצים אותה. אמור להופיע אותו תהליך בממשק המשתמש כמו בקטע הקודם, רק שהפעם נעשה שימוש במסד הנתונים של Firebase באינטרנט כדי לאחסן את מזהי העוגנים בענן ואת הקודים הקצרים, במקום באחסון המקומי במכשיר.

בדיקת משתמשים מרובים

כדי לבדוק את חוויית השימוש של כמה משתמשים, משתמשים בשני טלפונים שונים:

מתקינים את האפליקציה בשני מכשירים.
משתמשים במכשיר אחד כדי לארח את העוגן וליצור קוד קצר.
משתמשים במכשיר השני כדי לפתור את העוגן באמצעות הקוד הקצר הזה.

אמורה להיות לכם אפשרות לארח עוגנים ממכשיר אחד, לקבל קוד קצר ולהשתמש בקוד הקצר במכשיר השני כדי לראות את העוגן באותו מקום.

6. סיכום

מעולה! הגעתם לסוף ה-Codelab.

מה נכלל

איך מארחים עוגנים באמצעות ARCore SDK ומקבלים מזהה עוגן בענן.
איך משתמשים במזהי עוגנים ב-Cloud כדי לפתור עוגנים.
איך לאחסן ולשתף מזהים של עוגנים בענן בין סשנים שונים של AR באותו מכשיר או במכשירים שונים.

מידע נוסף

סקירה כללית על Cloud Anchors ל-Android