Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Activer la RA dans votre application NDK Android

Activez la RA pour utiliser les fonctionnalités de réalité augmentée dans votre application nouvelle ou existante.

Configurez votre application pour qu'elle soit obligatoire ou facultative pour la RA

Pour économiser de l'espace sur les appareils individuels, toutes les fonctionnalités de RA sont stockées dans une application appelée Services Google Play pour la RA, qui est mise à jour séparément par le Play Store. Les applications Android qui utilisent des fonctionnalités de RA communiquent avec les Services Google Play pour la RA à l'aide du SDK ARCore. Une application compatible avec les fonctionnalités de RA peut être configurée de deux manières : Obligatoire pour la RA et Facultative pour la RA. Cette désignation détermine comment l'application interagit avec l'application Services Google Play pour la RA.

Une application Obligatoire pour la RA ne peut pas fonctionner sans ARCore. Elle nécessite un appareil compatible avec ARCore sur lequel les Services Google Play pour la RA sont installés.

Le Google Play Store ne mettra à disposition les applications Obligatoires pour la RA que sur les appareils compatibles avec ARCore.
Lorsque les utilisateurs installent une application Obligatoire pour la RA, le Google Play Store installe automatiquement les Services Google Play pour la RA sur leur appareil. Toutefois, votre application doit toujours effectuer des vérifications d'exécution supplémentaires au cas où les Services Google Play pour la RA ne seraient pas à jour ou auraient été désinstallés manuellement.

Une application Facultative pour la RA utilise ARCore pour améliorer les fonctionnalités existantes. Elle dispose de fonctionnalités de RA facultatives qui ne sont activées que sur les appareils compatibles avec ARCore sur lesquels les Services Google Play pour la RA sont installés.

Les applications Facultatives pour la RA peuvent être installées et exécutées sur des appareils non compatibles avec ARCore.
Lorsque les utilisateurs installent une application Facultative pour la RA, le Google Play Store n'installe pas automatiquement les Services Google Play pour la RA sur l'appareil.

	Obligatoire pour la RA	Facultative pour la RA
Utilisation de la fonctionnalité de RA	Votre application a besoin d'ARCore pour ses fonctionnalités de base.	ARCore augmente les fonctionnalités de votre application. Votre application peut s'exécuter sans la compatibilité avec ARCore.
Visibilité sur le Play Store	Votre application n'est listée dans le Play Store que sur les appareils compatibles avec ARCore.	Votre application suit les procédures de fiche Play Store normales.
Méthode d'installation des Services Google Play pour la RA	Le Play Store installe les Services Google Play pour la RA en même temps que votre application.	Votre application utilise `ArCoreApk.requestInstall()` pour télécharger et installer ARCore.
Exigences `minSdkVersion` d'Android	Android 7.0 (niveau d'API 24)	Android 4.4 (niveau d'API 19), bien que l'exécution de toute fonctionnalité de RA nécessite au moins Android 7.0 (niveau d'API 24)
Doit utiliser `ArCoreApk_checkAvailability()` ou `ArCoreApk_checkAvailabilityAsync()` pour vérifier la compatibilité avec ARCore et l'état de l'installation
Doit utiliser `ArCoreApk.requestInstall()` pour installer les Services Google Play pour la RA

Pour rendre votre application Obligatoire ou Facultative pour la RA, mettez à jour votre fichier AndroidManifest.xml pour inclure les entrées suivantes :

Obligatoire pour la RA

<uses-permission android:name="android.permission.CAMERA" />

<!-- Limits app visibility in the Google Play Store to ARCore supported devices
     (https://developers.google.com/ar/devices). -->
<uses-feature android:name="android.hardware.camera.ar" />

<application …>
    …

    <!-- "AR Required" app, requires "Google Play Services for AR" (ARCore)
         to be installed, as the app does not include any non-AR features. -->
    <meta-data android:name="com.google.ar.core" android:value="required" />
</application>

Facultative pour la RA

<uses-permission android:name="android.permission.CAMERA" />

<!-- If your app was previously AR Required, don't forget to remove the
     `<uses-feature android:name="android.hardware.camera.ar" />` entry, as
     this would limit app visibility in the Google Play Store to only
     ARCore supported devices. -->

<application …>
    …

    <!-- "AR Optional" app, contains non-AR features that can be used when
         "Google Play Services for AR" (ARCore) is not available. -->
    <meta-data android:name="com.google.ar.core" android:value="optional" />
</application>

Modifiez ensuite le fichier build.gradle de votre application pour spécifier un minSdkVersion d'au moins 24 :

 android {
     defaultConfig {
         …
         minSdkVersion 24
     }
 }

Ajouter des dépendances de build

Assurez-vous que le fichier build.gradle de votre projet inclut le dépôt Maven de Google.
```
allprojects {
    repositories {
        google()
        …
    }
}
```
Ajoutez une tâche personnalisée au fichier build.gradle de votre module pour extraire les bibliothèques natives incluses du fichier AAR ARCore. Vous pourrez ainsi les référencer directement dans un projet C ou C++.
Dans le répertoire app/build, définissez une variable pour le répertoire dans lequel les bibliothèques natives seront extraites.

Créez une configuration Gradle pour contenir les données et les tâches d'extraction.

/*
The ARCore AAR library contains native shared libraries that are
extracted before building to a temporary directory.
*/
def arcore_libpath = "${buildDir}/arcore-native"

// Create a configuration to mark which aars to extract .so files from
configurations { natives }

Créez une tâche pour copier les bibliothèques natives à partir du fichier AAR et ajoutez-la aux dépendances de build.

// Extracts the shared libraries from AARs in the native configuration
// so that NDK builds can access these libraries.
task extractNativeLibraries() {
   // Extract every time.
   outputs.upToDateWhen { false }

   doFirst {
        configurations.natives.files.each { f ->
            copy {
                from zipTree(f)
                into arcore_libpath
                include "jni/**/*"
            }
        }
    }
}

tasks.whenTaskAdded {
    task-> if (task.name.contains("external") && !task.name.contains("Clean")) {
        task.dependsOn(extractNativeLibraries)
    }
}

Configurez les indicateurs de build natifs pour transmettre les emplacements aux outils de build externes.

// From the sample app.
externalNativeBuild {
    cmake {
        cppFlags "-std=c++11", "-Wall"
        arguments "-DANDROID_STL=c++_static",
                "-DARCORE_LIBPATH=${arcore_libpath}/jni",
                "-DARCORE_INCLUDE=${project.rootDir}/../../libraries/include"
    }
}

Ajoutez les dépendances pour les bibliothèques Java et natives.

dependencies {
     ...
     // Add Java and native dependencies to the ARCore library.
     implementation 'com.google.ar:core:1.33.0'
     natives 'com.google.ar:core:1.33.0'
     ...
}

Référencez les bibliothèques natives dans CMakeLists.txt.

# Import the ARCore library.
add_library(arcore SHARED IMPORTED)
set_target_properties(arcore PROPERTIES IMPORTED_LOCATION
              ${ARCORE_LIBPATH}/${ANDROID_ABI}/libarcore_sdk_c.so
              INTERFACE_INCLUDE_DIRECTORIES ${ARCORE_INCLUDE}
)

Effectuer des vérifications à l'exécution

Lors de l'exécution, procédez comme suit pour vous assurer que les fonctionnalités de RA de votre application fonctionnent correctement.

Vérifier si ARCore est compatible

Les applications Obligatoires et Facultatives pour la RA doivent utiliser ArCoreApk_checkAvailability() ou ArCoreApk_checkAvailabilityAsync() pour déterminer si l'appareil actuel est compatible avec ARCore. Sur les appareils non compatibles avec ARCore, les applications doivent désactiver les fonctionnalités liées à la RA et masquer les éléments d'interface utilisateur associés.

Une application NDK Android peut utiliser la classe ArCoreApk Java pour vérifier la compatibilité et gérer l'installation dans l'API de session ARCore C native. Selon la structure de votre application, cela peut être plus facile que d'utiliser les ArCoreApk_ fonctions en raison du grand nombre de gestion des exceptions et d'interaction avec l'interface utilisateur impliqués.

void maybeEnableArButton(JNIEnv env, jobject context) {
  // Likely called from Activity.onCreate() of an activity with AR buttons.
  ArAvailability availability
  ArCoreApk_checkAvailability(env, context, &availability);
  if (availability == AR_AVAILABILITY_UNKNOWN_CHECKING) {
    // Set a timer to call maybeEnableArButton() again after about 200ms.
  }
  if (availability == AR_AVAILABILITY_SUPPORTED_NOT_INSTALLED ||
      availability == AR_AVAILABILITY_SUPPORTED_APK_TOO_OLD ||
      availability == AR_AVAILABILITY_SUPPORTED_INSTALLED) {
    // Show or enable the AR button.
  } else {
    // Hide or disable the AR button.
  }
}

Même si les Services Google Play pour la RA sont installés en même temps que votre application Obligatoire pour la RA, les utilisateurs disposant d'appareils non compatibles peuvent les installer à partir d'une source externe. L'utilisation de ArCoreApk_checkAvailability() ou ArCoreApk_checkAvailabilityAsync() pour vérifier la compatibilité avec ARCore garantit une expérience cohérente.

ArCoreApk_checkAvailability() peut avoir besoin d'interroger des ressources réseau pour déterminer si l'appareil est compatible avec ARCore. Pendant ce temps, il renvoie AR_AVAILABILITY_UNKNOWN_CHECKING. Pour réduire la latence perçue et le pop-in, les applications doivent appeler ArCoreApk_checkAvailability() une fois au début de leur cycle de vie pour lancer la requête, en ignorant la valeur renvoyée. Ainsi, un résultat mis en cache sera disponible immédiatement lorsqu'un élément d'interface utilisateur entrant dans la RA pourra s'afficher.

Vérifier si les Services Google Play pour la RA sont installés

Les applications Obligatoires et Facultatives pour la RA doivent utiliser ArCoreApk.requestInstall() avant de créer une session ARCore pour vérifier si une version compatible des Services Google Play pour la RA est (toujours) installée et pour s'assurer que toutes les données de profil d'appareil ARCore requises ont été téléchargées.

// Tracks if an installation request has already been triggered.
bool install_requested_;

void nativeOnCreate() {
  // Do other setup here.

  install_requested_ = false;
}

void nativeOnResume(JNIEnv env, jobject activity) {
  if (ar_session_ == null) {
    bool user_requested_install = !install_requested_;

    ArInstallStatus install_status;
    // Ensure that Google Play Services for AR and ARCore device profile data are
    // installed and up to date.
    ArStatus error = ArCoreApk_requestInstall(
        env, activity, user_requested_install, &install_status);
    if (error != AR_SUCCESS) {
      // Inform user of error.
      return;
    }

    switch (install_status) {
      case AR_INSTALL_STATUS_INSTALLED:
        break;
      case AR_INSTALL_STATUS_INSTALL_REQUESTED:
        // When this method returns AR_INSTALL_STATUS_INSTALL_REQUESTED:
        // 1. This activity will be paused.
        // 2. The user is prompted to install or update Google Play
        //    Services for AR (market://details?id=com.google.ar.core).
        // 3. ARCore downloads the latest device profile data.
        // 4. This activity is resumed. The next invocation of
        //    ArCoreApk_requestInstall() will either return
        //    AR_INSTALL_STATUS_INSTALLED or throw an exception if the
        //    installation or update did not succeed.
        install_requested_ = true;
        return;
    }

    // Request camera permissions.

    error = ArSession_create(env, context, &ar_session_);
    if (error != AR_SUCCESS) {
      // Inform user of error.
      return;
    }

    // Configure the ARCore session.
  }

  // Normal onResume behavior.
}

Respecter les exigences en matière de confidentialité des utilisateurs

Pour publier votre application sur le Play Store, assurez-vous qu'elle respecte les exigences en matière de confidentialité des utilisateurs d'ARCore .

Étapes suivantes

Découvrez comment configurer une session ARCore.

Activer la RA dans votre application NDK Android Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.