Vérifier la disponibilité du service VPS à l'emplacement actuel de l'appareil

L'API Geospatial utilise une combinaison de données VPS et GPS pour générer des poses géospatiales de haute précision. L'API peut être utilisée partout où l'appareil peut déterminer sa position :

  • Dans les zones où la précision du GPS est faible, comme les espaces intérieurs et les environnements urbains denses, l'API s'appuie sur la couverture du VPS pour générer des poses de haute précision.
  • Dans les environnements extérieurs où il y a peu ou pas d'obstacles au-dessus de l'utilisateur, l'API Geospatial peut être en mesure d'utiliser les données de localisation GPS disponibles pour générer des poses géospatiales avec une grande précision.

Vous pouvez déterminer la disponibilité des VPS à une position horizontale donnée avant le début de la session de RA et l'utiliser pour créer des expériences plus spécifiques (par exemple, pour présenter un "Enter AR") bouton uniquement lorsque VPS est disponible.

Activer l'API ARCore

Votre application doit activer l'API ARCore pour vérifier la disponibilité du VPS.

Une fois l'API ARCore activée, vous pouvez vérifier la disponibilité du VPS sans :

Vérifier la disponibilité du VPS dans votre application

L'API Geospatial peut être utilisée partout où l'appareil est en mesure de déterminer sa position. Si votre expérience de RA dépend de la couverture VPS, vous pouvez utiliser ArSession_checkVpsAvailabilityAsync() pour obtenir un ArVpsAvailabilityFuture, une tâche asynchrone qui vérifie la disponibilité des VPS à une position horizontale donnée. Une fois que vous disposez de ArVpsAvailabilityFuture, vous pouvez obtenir son résultat par le biais d'une interrogation ou d'un rappel.

Sondage

Utilisez ArFuture_getState() pour obtenir l'état de ArFuture. Il existe trois états différents:

Vous pouvez continuer à vérifier ArFuture_getState() jusqu'à ce que la tâche soit terminée.

// Obtain a ArVpsAvailabilityFuture and store it somewhere.
ArVpsAvailabilityFuture* future = NULL;
CHECK(ArSession_checkVpsAvailabilityAsync(ar_session, latitude, longitude,
                                          NULL, NULL, &future) == AR_SUCCESS);

// Poll ArVpsAvailabilityFuture later, for example, in a render loop.
ArFutureState future_state = AR_FUTURE_STATE_PENDING;
ArFuture_getState(ar_session, (ArFuture*)future, &future_state);
if (future_state == AR_FUTURE_STATE_DONE) {
  ArVpsAvailability vps_availability = AR_VPS_AVAILABILITY_UNKNOWN;
  ArVpsAvailabilityFuture_getResult(ar_session, future, &vps_availability);
  switch (vps_availability) {
    case AR_VPS_AVAILABILITY_AVAILABLE:
      // VPS is available at this location.
      break;
    case AR_VPS_AVAILABILITY_UNAVAILABLE:
      // VPS is unavailable at this location.
      break;
    case AR_VPS_AVAILABILITY_ERROR_NETWORK_CONNECTION:
      // The external service could not be reached due to a network connection
      // error.
      break;

      // Handle other error states, e.g.
      // AR_VPS_AVAILABILITY_ERROR_RESOURCE_EXHAUSTED,
      // AR_VPS_AVAILABILITY_ERROR_INTERNAL, ...
  }
  ArFuture_release((ArFuture*)future);
}

Obtenir le résultat via un rappel

Vous pouvez également obtenir le résultat d'une ArFuture via un rappel. Utilisez ArSession_checkVpsAvailabilityAsync() et fournissez un callback. Ce callback sera appelé sur le thread principal peu de temps après que ArFuture ait l'état AR_FUTURE_STATE_DONE.

void vps_availability_callback(void* context, ArVpsAvailability availability) {
  // Callback is called on the Main thread.

  // Handle the ArVpsAvailability result as shown above.
  // For example, show UI that enables your AR view.

  // It is a best practice to free `context` memory at the end of the callback.
  free(context);
}

void check_availability_with_callback(ArSession* ar_session, double latitude,
                                      double longitude) {
  ArVpsAvailabilityFuture* future = NULL;
  void* context = NULL;
  CHECK(ArSession_checkVpsAvailabilityAsync(
      ar_session, latitude, longitude, context, vps_availability_callback,
      &future) == AR_SUCCESS);
}

Annuler la ArFuture

Utilisez ArFuture_cancel() pour tenter d'annuler ArFuture. En raison du parallélisme de threads, il est possible que votre tentative d'annulation ne soit pas couronnée de succès. ArFuture_cancel() renvoie 1 si la tentative a abouti, et 0 dans le cas contraire.

Utiliser l'API Geospatial sans couverture VPS

L'API Geospatial peut également être utilisée dans les zones qui ne disposent pas de couverture VPS. Dans les environnements extérieurs avec peu ou pas d'obstacles au-dessus, le GPS peut suffire à générer une pose avec une grande précision.

Étape suivante