ทำงานกับท่าทางเชิงพื้นที่โดยใช้ 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 = 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.
}

โหมด 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
var geospatial = Geospatial.getInstance(session)

ควรถือว่าออบเจ็กต์ 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 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
}

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

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

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

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

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

หากต้องการแปลงท่าทางของอุปกรณ์เป็นท่าทางเชิงพื้นที่โดยใช้ 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
    }
}

แปลงท่าทางภูมิสารสนเทศเป็นท่าทางของอุปกรณ์

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

วิธีแปลงท่าทางเชิงพื้นที่เป็นท่าทางของอุปกรณ์โดยใช้ 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
    }
}