ทำงานกับท่าทางเชิงพื้นที่โดยใช้ ARCore สำหรับ Jetpack XR

อุปกรณ์ XR ที่รองรับ
คำแนะนำนี้จะช่วยคุณสร้างประสบการณ์การใช้งานสำหรับอุปกรณ์ XR ประเภทนี้
ดูข้อมูลเกี่ยวกับประเภทอุปกรณ์ XR →
แว่นตา AI
ดูข้อมูลเกี่ยวกับประเภทอุปกรณ์ XR →

Geospatial API ใน ARCore สำหรับ Jetpack XR ช่วยให้แอปของคุณแนบเนื้อหาจากระยะไกลกับพื้นที่ใดก็ได้ที่ Google Street View ครอบคลุม และสร้างประสบการณ์ AR ในระดับโลกได้ Geospatial API ใช้ข้อมูลเซ็นเซอร์ของอุปกรณ์และ GPS เพื่อตรวจจับสภาพแวดล้อมของอุปกรณ์ จากนั้นจะจับคู่ส่วนที่จดจำได้ของ สภาพแวดล้อมนั้นกับโมเดลการแปลที่ Google Visual Positioning System (VPS) จัดเตรียมไว้ให้เพื่อระบุตำแหน่งที่แน่นอนของอุปกรณ์ของผู้ใช้ นอกจากนี้ API ยัง ผสานรวมพิกัดในเครื่องของผู้ใช้กับพิกัดทางภูมิศาสตร์ จาก VPS เพื่อให้คุณทำงานภายในระบบพิกัดเดียวได้

เปิดใช้ ARCore API

ก่อนใช้ระบบกำหนดตำแหน่งด้วยภาพ (VPS) ในแอป คุณต้อง เปิดใช้ ARCore API ในโปรเจ็กต์ Google Cloud ใหม่หรือที่มีอยู่ก่อน บริการนี้มีหน้าที่โฮสต์ จัดเก็บ และแก้ไข Geospatial Anchor

เพิ่มการอ้างอิงไลบรารีเพิ่มเติม

การใช้ Geospatial API ต้องมีทรัพยากร Dependency ของไลบรารีเพิ่มเติม เพิ่มโค้ดต่อไปนี้ลงในไฟล์ build.gradle.kts ของแอป

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

ขอสิทธิ์ที่จำเป็น

หากต้องการใช้ Geospatial API ใน ARCore กับ Jetpack XR แอปของคุณต้องขอสิทธิ์รันไทม์ต่อไปนี้

ประกาศสิทธิ์ของแอป

ก่อนที่จะขอสิทธิ์เหล่านี้ในรันไทม์ได้ คุณต้องประกาศ สิทธิ์เหล่านั้นในไฟล์ Manifest ของแอป ดังนี้

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

ขอสิทธิ์

หลังจากประกาศสิทธิ์ที่จำเป็นแล้ว แอปของคุณต้องขอสิทธิ์เหล่านั้นที่ รันไทม์ โปรดอธิบายเหตุผลที่แอปของคุณต้องการสิทธิ์

Geospatial API จะทำงานไม่ได้หากไม่สามารถระบุตำแหน่งที่แน่นอนของผู้ใช้ ด้วยเหตุนี้ โปรดทำตามคำแนะนำสำหรับการขอสิทธิ์เข้าถึงตำแหน่ง ขณะรันไทม์เพื่อให้แอปได้รับทั้งสิทธิ์ ACCESS_FINE_LOCATION และ ACCESS_COARSE_LOCATION

เข้าถึงเซสชัน

เข้าถึงข้อมูลเชิงพื้นที่ผ่านรันไทม์ Jetpack XR Session ซึ่งแอปต้องสร้าง

กำหนดค่าเซสชัน

ระบบไม่ได้เปิดใช้ข้อมูลท่าทางของอุปกรณ์ในเซสชัน XR โดยค่าเริ่มต้น หากต้องการเปิดใช้แอปเพื่อดึงข้อมูลท่าทางของอุปกรณ์ ให้กำหนดค่าเซสชันและตั้งค่าทั้งโหมด GeospatialMode.VPS_AND_GPS และ DeviceTrackingMode.LAST_KNOWN 

// Define the configuration object to enable Geospatial features.
val newConfig = Config(
    // Set the GeospatialMode to VPS_AND_GPS.
    geospatial = GeospatialMode.VPS_AND_GPS,
    // Set the DeviceTrackingMode to LAST_KNOWN.
    deviceTracking = DeviceTrackingMode.LAST_KNOWN
)
// Apply the configuration to the session.
try {
    when (val configResult = session.configure(newConfig)) {
        is SessionConfigureSuccess -> {
            // The session is now configured to use the Geospatial API.
        }
        else -> {
            // Handle other configuration errors (e.g., missing library dependencies).
        }
    }
} catch (e: UnsupportedOperationException) {
    // Handle configuration failure if the mode is not supported.
}
Geospatial.kt

โหมด GeospatialMode.VPS_AND_GPS ใช้ทั้งข้อมูลระบบกำหนดตำแหน่งด้วยภาพ (VPS) และข้อมูลระบบกำหนดตำแหน่งบนโลก (GPS) เพื่อกำหนดตำแหน่งเชิงพื้นที่ของอุปกรณ์ได้อย่างแม่นยำ

อุปกรณ์ XR บางรุ่นไม่รองรับโหมด GeospatialMode.VPS_AND_GPS และ DeviceTrackingMode.LAST_KNOWN หาก Session.configure() สำเร็จ แสดงว่าอุปกรณ์รองรับโหมดเหล่านี้

แจ้งให้ผู้ใช้อนุญาตการใช้ข้อมูลอุปกรณ์

แอปที่ใช้ Geospatial API กับ ARCore สำหรับ Jetpack XR ต้องแสดงข้อความแจ้งให้ผู้ใช้รับทราบและอนุญาตให้ใช้ข้อมูลจากอุปกรณ์ของผู้ใช้ ดูข้อมูลเพิ่มเติมได้ที่ข้อกำหนดด้านความเป็นส่วนตัวของผู้ใช้

รับออบเจ็กต์เชิงพื้นที่

เมื่อกำหนดค่าเซสชันแล้ว ให้รับออบเจ็กต์ Geospatial โดยใช้ Geospatial.getInstance(session)

// Get the Geospatial instance for the current session.
val geospatial = Geospatial.getInstance(session)
Geospatial.kt

ควรถือว่าออบเจ็กต์ Geospatial ใช้ได้เฉพาะเมื่อสถานะเป็น State.RUNNING คุณตรวจสอบสถานะได้โดยใช้ Geospatial.state StateFlow<Geospatial.State>

ตรวจสอบความพร้อมใช้งานของ VPS

เนื่องจาก Geospatial API ใช้ทั้ง VPS และ GPS ในการกำหนดท่าทางเชิงพื้นที่ API จึงพร้อมใช้งานทุกครั้งที่อุปกรณ์ระบุตำแหน่งได้ ในพื้นที่ที่มีความแม่นยำของ GPS ต่ำ เช่น พื้นที่ในอาคาร และสภาพแวดล้อมในเมืองที่มีประชากรหนาแน่น API จะอาศัยความครอบคลุมของ VPS เพื่อสร้าง ท่าทางที่มีความแม่นยำสูง

ภายใต้สภาวะปกติ คุณคาดหวังได้ว่า VPS จะให้ความแม่นยำของตำแหน่งประมาณ 5 เมตรและความแม่นยำของการหมุน 5 องศา คุณตรวจสอบได้ว่าสถานที่ตั้งมีพื้นที่ครอบคลุม VPS หรือไม่โดยใช้ฟังก์ชันระงับ Geospatial.checkVpsAvailability(latitude, longitude) การเรียกนี้เป็นการ ดำเนินการแบบไม่พร้อมกันและไม่จำเป็นต้องกำหนดค่าเซสชันด้วยโหมด GeospatialMode.VPS_AND_GPS

โค้ดต่อไปนี้แสดงวิธีตรวจสอบความพร้อมใช้งานของ VPS จากละติจูดและลองจิจูดที่ระบุ 

// You can query the GPS to get the current device's location.
val latitude = 37.422
val longitude = -122.084

// Use the geospatial instance to check VPS availability for a specific location.
val result = geospatial.checkVpsAvailability(latitude, longitude)
when (result) {
    is VpsAvailabilityAvailable -> {
        // VPS is available at this location.
    }
    is VpsAvailabilityErrorInternal -> {
        // VPS availability check failed with an internal error.
    }
    is VpsAvailabilityNetworkError -> {
        // VPS availability check failed due to a network error.
    }
    is VpsAvailabilityNotAuthorized -> {
        // VPS availability check failed due to an authorization error.
    }
    is VpsAvailabilityResourceExhausted -> {
        // VPS availability check failed due to resource exhaustion.
    }
    is VpsAvailabilityUnavailable -> {
        // VPS is not available at this location.
    }
}
Geospatial.kt

แอปต้องตั้งค่าอย่างถูกต้องเพื่อสื่อสารกับ ARCore API ใน Google Cloud มิฉะนั้นแอปจะได้รับผลลัพธ์ VpsAvailabilityNotAuthorized

แปลงท่าทางของอุปกรณ์เป็นท่าทางเชิงพื้นที่

คุณสามารถแปลงท่าทางของอุปกรณ์เป็นท่าทางเชิงพื้นที่เพื่อช่วยให้แว่นตา AI โต้ตอบและสร้างข้อมูลที่รับรู้ตำแหน่งได้ ไปป์ไลน์นี้จะแปลตำแหน่งและการวางแนวปัจจุบันของอุปกรณ์ในระบบพิกัดท้องถิ่น (ท่าทางของอุปกรณ์) เป็นพิกัดที่ได้รับการยอมรับทั่วโลก

ซึ่งจะช่วยให้คุณทำสิ่งต่อไปนี้ได้

  • สร้างเนื้อหา AR แบบถาวร ซึ่งจะติดแท็ก Anchor วัตถุเสมือนที่ผู้ใช้วางไว้กับตำแหน่งทั่วโลกอย่างแม่นยำเพื่อให้เรียกดูได้ในภายหลัง
  • กระตุ้นประสบการณ์ตามตำแหน่งโดยการอัปเดตตำแหน่งของผู้ใช้บนแผนที่อย่างต่อเนื่องเพื่อเปิดใช้การนำทางแบบเรียลไทม์หรือการเล่นเกมที่กำหนดขอบเขตทางภูมิศาสตร์
  • พิจารณาบริบทในโลกแห่งความเป็นจริงที่แน่นอนของผู้ใช้เพื่อทริกเกอร์ ตรรกะของแอปพลิเคชันที่เกี่ยวข้องกับตำแหน่ง

วิธีแปลงท่าทางของอุปกรณ์เป็นท่าทางเชิงพื้นที่โดยใช้ Geospatial.createGeospatialPoseFromPose()

// Get the current device Pose from the AR Session's state.
val devicePose = ArDevice.getInstance(session).state.value.devicePose

// Convert the device Pose into a GeospatialPose.
when (val result = geospatial.createGeospatialPoseFromPose(devicePose)) {
    is CreateGeospatialPoseFromPoseSuccess -> {
        val geoPose = result.pose
        val lat = geoPose.latitude
        val lon = geoPose.longitude
        val alt = geoPose.altitude
        // Orientation is in the EUS (East-Up-South) coordinate system.
        val orientation = geoPose.eastUpSouthQuaternion
    }
    is CreateGeospatialPoseFromPoseNotTracking -> {
        // Geospatial is not currently tracking.
    }
}
Geospatial.kt

แปลงท่าทางเชิงพื้นที่เป็นท่าทางของอุปกรณ์

คุณสามารถแปลงท่าทางเชิงพื้นที่เป็นท่าทางของอุปกรณ์เพื่อช่วยมอบประสบการณ์การใช้งานตามบริบทและรับรู้ตำแหน่งในแว่นตา AI การแปลงนี้ จะใช้ข้อมูลที่กำหนดโดยพิกัดในโลกแห่งความเป็นจริง เช่น ตำแหน่งของ สถานที่สำคัญ เส้นทางการนำทาง หรือเนื้อหา AR แบบถาวร แล้วแปลงเป็น พื้นที่ภาพที่แม่นยำของแว่นตาของผู้ใช้

วิธีแปลงท่าทางเชิงพื้นที่เป็นท่าทางของอุปกรณ์โดยใช้ Geospatial.createPoseFromGeospatialPose()

// Convert a GeospatialPose (lat/long/alt) back to a device-space Pose.
when (val result = geospatial.createPoseFromGeospatialPose(geoPose)) {
    is CreatePoseFromGeospatialPoseSuccess -> {
        val devicePose: Pose = result.pose
        // devicePose is now ready to be used relative to the tracking origin.
    }
    is CreatePoseFromGeospatialPoseNotTracking -> {
        // Geospatial is not currently tracking.
    }
}
Geospatial.kt