Com a API Geospatial no ARCore para Jetpack XR, seu app pode anexar conteúdo remotamente a qualquer área coberta pelo Street View do Google e criar experiências de RA em escala global. A API Geospatial usa dados de sensores do dispositivo e de GPS para detectar o ambiente do dispositivo e, em seguida, corresponde as partes reconhecíveis desse ambiente a um modelo de localização fornecido pelo sistema de posicionamento visual (VPS) do Google para determinar a localização exata do dispositivo de um usuário. A API também mescla as coordenadas locais do usuário com as coordenadas geográficas do VPS para que você possa trabalhar em um único sistema de coordenadas.
Ativar a API ARCore
Antes de usar o sistema de posicionamento visual (VPS) no seu app, é necessário ativar a API ARCore em um projeto novo ou atual do Google Cloud. Esse serviço é responsável por hospedar, armazenar e resolver âncoras geoespaciais.
Adicionar outras dependências de biblioteca
O uso da API Geospatial exige algumas dependências de biblioteca adicionais. Adicione estes
ao arquivo build.gradle.kts do app:
Groovy
dependencies { // ... Other required dependencies for the Jetpack XR SDK implementation "com.google.android.gms:play-services-location:21.3.0" }
Kotlin
dependencies { // ... Other required dependencies for the Jetpack XR SDK implementation("com.google.android.gms:play-services-location:21.3.0") }
Solicitar as permissões necessárias
Para usar a API Geospatial no ARCore com o Jetpack XR, seu app precisa solicitar as seguintes permissões de execução:
ACCESS_INTERNET: necessário para entrar em contato com o serviço de nuvem da API ARCore Geospatial.ACCESS_COARSE_LOCATION: necessário para determinar a localização aproximada de um usuário.ACCESS_FINE_LOCATION: necessário para determinar a localização precisa de um usuário.
Declarar permissões do app
Antes de solicitar essas permissões durante a execução, declare elas no manifesto do app:
<manifest ... >
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
</manifest>
Solicitar permissões
Depois de declarar as permissões necessárias, o app precisa solicitá-las em tempo de execução. Explique por que o app precisa das permissões.
A API Geospatial não funciona a menos que possa determinar a localização precisa do usuário. Por isso, siga as orientações para solicitar permissões de localização
durante a execução para que o app possa receber as permissões
ACCESS_FINE_LOCATION e ACCESS_COARSE_LOCATION.
Acessar uma sessão
Acesse informações geoespaciais por um Session do Jetpack XR Runtime,
que seu app precisa criar.
Configurar a sessão
As informações de postura do dispositivo não são ativadas por padrão nas sessões de RV/RA. Para permitir que seu
app recupere informações de postura do dispositivo, configure a sessão e defina os modos
GeospatialMode.VPS_AND_GPS e DeviceTrackingMode.LAST_KNOWN:
// Define the configuration object to enable Geospatial features.
val newConfig = session.config.copy(
// Set the GeospatialMode to VPS_AND_GPS.
geospatial = Config.GeospatialMode.VPS_AND_GPS
// Set the DeviceTrackingMode to LAST_KNOWN.
deviceTracking = Config.DeviceTrackingMode.LAST_KNOWN
)
// Apply the configuration to the session.
try {
when (val configResult = session.configure(newConfig)) {
is SessionConfigureGooglePlayServicesLocationLibraryNotLinked -> {
// This case generally indicates a missing library dependency.
}
is SessionConfigureSuccess -> {
// The session is now configured to use the Geospatial API.
}
else -> {
// Catch-all for other configuration errors returned using the result class.
}
}
} catch (e: UnsupportedOperationException) {
// Handle configuration failure. For example, if the specific mode is not supported on the current device or API version.
}
O modo GeospatialMode.VPS_AND_GPS usa dados do Sistema de Posicionamento Visual (VPS) e do Sistema de Posicionamento Global (GPS) para determinar com precisão a posição geoespacial do dispositivo.
Nem todos os dispositivos de RV/RA são compatíveis com os modos GeospatialMode.VPS_AND_GPS e DeviceTrackingMode.LAST_KNOWN. Se Session.configure() for bem-sucedido, o dispositivo vai ser compatível com esses modos.
Perguntar ao usuário para permitir o uso de dados do dispositivo
Os apps que usam a API Geospatial com o ARCore para Jetpack XR precisam apresentar ao usuário uma solicitação para confirmar e permitir o uso de dados do dispositivo. Consulte os requisitos de privacidade do usuário para mais informações.
Extrair o objeto geoespacial
Depois que a sessão for configurada, receba o objeto Geospatial usando
Geospatial.getInstance(session):
// Get the Geospatial instance
var geospatial = Geospatial.getInstance(session)
O objeto Geospatial só pode ser usado quando o estado dele é
State.RUNNING. É possível monitorar o estado usando o
Geospatial.state StateFlow<Geospatial.State>.
Verificar a disponibilidade da VPS
Como a API Geospatial usa uma combinação de VPS e GPS para determinar uma postura geoespacial, ela pode ser usada desde que o dispositivo consiga determinar a localização. Em áreas com baixa precisão de GPS, como espaços internos e ambientes urbanos densos, a API depende da cobertura do VPS para gerar poses de alta precisão.
Em condições típicas, o VPS oferece uma precisão posicional de aproximadamente 5 metros e uma precisão rotacional de 5 graus. É possível verificar se um local tem cobertura do VPS usando a função de suspensão Geospatial.checkVpsAvailability(latitude, longitude). Essa chamada é uma operação assíncrona e não exige que a sessão seja configurada com o modo GeospatialMode.VPS_AND_GPS.
O código a seguir demonstra como verificar a disponibilidade do VPS em uma latitude e longitude especificadas:
// You can query the GPS to get the current device's location and check if it has VPS
val latitude = getLatitudeFromGPS()
val longitude = getLongitudeFromGPS()
// Must be called from a coroutine.
val result = geospatial.checkVpsAvailability(latitude, longitude)
if (result is VpsAvailabilityAvailable) {
// VPS is available
} else if (result is VpsAvailabilityUnavailable) {
// VPS is not available
}
Seu app precisa estar configurado corretamente para se comunicar com a API ARCore no Google Cloud. Caso contrário, ele vai receber um resultado VpsAvailabilityNotAuthorized.
Converter uma pose de dispositivo em uma pose geoespacial
É possível converter a postura de um dispositivo em uma postura geoespacial para permitir que os óculos de IA interajam e gerem dados com reconhecimento de local. Esse pipeline traduz a posição e a orientação atuais do dispositivo no sistema de coordenadas local (posição do dispositivo) em coordenadas reconhecidas globalmente.
Isso pode ajudar você a:
- Crie conteúdo de RA persistente, em que um objeto virtual colocado por um usuário é ancorado com precisão em um local global para recuperação posterior.
- Ative experiências baseadas em localização atualizando continuamente a posição do usuário em um mapa para permitir a navegação em tempo real ou jogos com restrição geográfica.
- Determinar o contexto preciso do usuário no mundo real para acionar a lógica de aplicativo relevante para a localização.
Para converter uma pose do dispositivo em uma pose geoespacial usando
Geospatial.createGeospatialPoseFromPose():
// Get the current device Pose from the AR Session's state
// This is the device's position and orientation relative to the AR tracking origin.
val devicePose = ArDevice.getInstance(session).state.value.devicePose
// Convert the device Pose into a GeospatialPose
when (val geospatialPoseResult = geospatial.createGeospatialPoseFromPose(devicePose)) {
is CreateGeospatialPoseFromPoseSuccess -> {
val currentGeospatialPose = geospatialPoseResult.pose
val horizontalAccuracy = geospatialPoseResult.horizontalAccuracy
// ... use pose and accuracy
val latitude = currentGeospatialPose.latitude
val longitude = currentGeospatialPose.longitude
// The orientation is stored as a Quaternion in the EUS (East-Up-South) system. The EUS coordinate system has X+ pointing east, Y+ pointing up, and Z+ pointing south. True North is aligned with the -Z axis.
val eusQuaternion = currentGeospatialPose.eastUpSouthQuaternion
}
is CreateGeospatialPoseFromPoseNotTracking -> {
// Geospatial is not currently tracking
}
}
Converter uma pose geoespacial em uma pose de dispositivo
É possível converter uma postura geoespacial em uma postura do dispositivo para ajudar a oferecer experiências contextuais e com reconhecimento de localização em óculos de IA. Essa transformação usa informações definidas por coordenadas do mundo real, como a localização de um ponto de referência, um trajeto de navegação ou conteúdo de RA persistente, e as converte no espaço visual preciso dos óculos do usuário.
Para converter uma pose geoespacial em uma pose de dispositivo usando
Geospatial.createPoseFromGeospatialPose():
when (val poseResult = geospatial.createPoseFromGeospatialPose(geospatialPose)) {
is CreatePoseFromGeospatialPoseSuccess -> {
val devicePose = poseResult.pose
// devicePose is now ready to be used
}
is CreatePoseFromGeospatialPoseNotTracking -> {
// Geospatial is not currently tracking
}
}