Jetpack XR के लिए ARCore का इस्तेमाल करना

Jetpack XR के लिए ARCore की मदद से, ऐप्लिकेशन बेहतर वर्चुअल रिएलिटी (एआर) के बुनियादी कॉन्सेप्ट के साथ काम कर सकते हैं. इसके लिए, वे कम लेवल के सीन समझने वाले प्राइमिटिव और मोशन ट्रैकिंग का इस्तेमाल करते हैं. AR अनुभव बनाते समय, ARCore for Jetpack XR का इस्तेमाल करें. साथ ही, आपको प्लैनर डेटा का इस्तेमाल करना हो या कॉन्टेंट को स्पेस में किसी तय जगह पर ऐंकर करना हो.

सेशन की लाइफ़साइकल के बारे में जानकारी

Jetpack XR के लिए ARCore की मदद से ट्रैक किए गए सभी ऑब्जेक्ट को सेशन के ज़रिए ऐक्सेस किया जाना चाहिए. ऐक्टिविटी के लाइफ़साइकल की तरह ही, सेशन ऑब्जेक्ट का भी एक लाइफ़साइकल होता है. इसे आपके ऐप्लिकेशन के सेशन ऑब्जेक्ट की सुविधाओं के इस्तेमाल के हिसाब से बनाए रखा जाना चाहिए. अगर आपके ऐप्लिकेशन में XR की सुविधा वाली एक ही गतिविधि है, तो लाइफ़साइकल के बारे में जानकारी देने वाले कॉम्पोनेंट का इस्तेमाल करके, सेशन के लाइफ़साइकल को मैनेज करें.

सेशन बनाना

किसी सेशन का इस्तेमाल करने से पहले, उसे बनाना ज़रूरी है. सेशन बनाने के लिए, उपयोगकर्ता को आपके ऐप्लिकेशन को android.permission.SCENE_UNDERSTANDING और android.permission.HAND_TRACKING अनुमतियां दी होंगी.

सेशन बनाने के लिए:

when (val result = Session.create(owner)) {
  is SessionCreateSuccess -> {
    session = result.session
  }
  is SessionCreatePermissionsNotGranted -> {
   // Request permissions in `result.permissions`.
}

सेशन न बन पाने की वजहें जानने के लिए, SessionCreateResult देखें.

सेशन फिर से शुरू करना

किसी सेशन को फिर से शुरू करने का फ़ैसला तब लेना चाहिए, जब आपका ऐप्लिकेशन, Jetpack XR के लिए ARCore से होने वाले स्टेटस में बदलावों को मैनेज करने के लिए तैयार हो. ज़्यादातर मामलों में, यह आपकी गतिविधि के onResume() कॉलबैक में किया जाता है. हालांकि, हो सकता है कि आपका ऐप्लिकेशन, उपयोगकर्ता के इंटरैक्शन तक प्रोसेसिंग में देरी करना चाहे.

नीचे दिया गया कोड स्निपेट, सेशन को फिर से शुरू करने का उदाहरण दिखाता है.

when (val result = session.resume()) {
  is SessionResumeSuccess -> {
    // Session has been created successfully.
    // Attach any successful handlers here.
  }
  is SessionResumePermissionsNotGranted -> {
    // Request permissions in `result.permissions`.
}

सेशन फिर से शुरू न होने की वजहें जानने के लिए, SessionResumeResult देखें.

सेशन रोकना

जब आपकी गतिविधि बैकग्राउंड में चल रही हो, तो Session.pause() का इस्तेमाल करके सेशन रोकें. किसी सेशन को रोकने पर, ट्रैकिंग कुछ समय के लिए रुक जाती है. यह तब तक रुकी रहती है, जब तक सेशन फिर से शुरू नहीं हो जाता. इस दौरान, परसेप्शन सिस्टम की स्थिति में कोई बदलाव नहीं होता.

सेशन को मिटाना

किसी सेशन को हमेशा के लिए हटाने के लिए, Session.destroy() का इस्तेमाल करें. इससे, सेशन के इस्तेमाल में लगे संसाधन खाली हो जाते हैं और सेशन की सभी स्थितियां खत्म हो जाती हैं.

आस-पास मौजूद हवाई जहाज़ों की स्थिति देखना

Jetpack XR के लिए ARCore, प्लेन की स्थिति दिखाने वाले StateFlow के ज़रिए प्लेन की स्थिति दिखाता है. किसी सेशन में प्लेन की सदस्यता लेने पर, प्लेन जोड़े जाने, अपडेट होने या हटाए जाने पर, आपके ऐप्लिकेशन को सूचना दी जाती है.

Plane.subscribe(session).collect { planes ->
 // Planes have changed; update plane rendering
}

प्लेन में ये प्रॉपर्टी होती हैं:

  • label: किसी दिए गए Plane के बारे में सेमैटिक जानकारी. यह Wall, Floor, Ceiling या Table हो सकता है.
  • centerPose: पहचाने गए हवाई जहाज़ के बीच के हिस्से की पोज़िशन.
  • extents: मीटर में, पहचाने गए प्लेन के डाइमेंशन.
  • vertices: प्लेन के आस-पास के उत्तल पॉलीगॉन के वर्टिक्स की सूची.

हवाई जहाज़ों के लिए हिट-टेस्ट करना

हिट-टेस्ट, सेशन के ज़रिए ट्रैक किए गए ऑब्जेक्ट के साथ रे के इंटरसेक्शन का हिसाब लगाने का एक तरीका है. हिट-टेस्ट का एक सामान्य इस्तेमाल यह है कि किसी टेबल पर कर्सर ले जाकर, उस जगह पर कोई ऑब्जेक्ट डाला जाए. हिट-टेस्ट करने पर, हिट किए गए ऑब्जेक्ट की सूची मिलती है. दूसरे शब्दों में, हिट-टेस्ट पहले ऑब्जेक्ट पर हिट होने के बाद नहीं रुकता. हालांकि, अक्सर आपकी दिलचस्पी किसी खास टाइप के पहले ऑब्जेक्ट हिट में ही होती है.

हिट-टेस्ट करने के लिए, Interaction.hitTest() के साथ Ray का इस्तेमाल करें:

val results = Interaction.hitTest(session, ray)
// When interested in the first Table hit:
val tableHit = results.firstOrNull {
  val trackable = it.trackable
  trackable is Plane && trackable.state.value.label == Plane.Label.Table
}

स्पेस में किसी कॉन्टेंट को किसी तय जगह पर ऐंकर करना

वर्चुअल ऑब्जेक्ट को रीयल-वर्ल्ड में जगह देने के लिए, Anchor का इस्तेमाल करें. ऐंकर ऑब्जेक्ट की मदद से, आपके ऐप्लिकेशन को किसी जगह की जानकारी को ट्रैक करने में मदद मिलती है.

Pose का इस्तेमाल करके ऐंकर बनाया जाता है. इसे किसी मौजूदा Trackable के हिसाब से समझा जा सकता है या नहीं.

ट्रैक किए जा सकने वाले आइटम के हिसाब से ऐंकर बनाना

जब किसी Trackable के हिसाब से ऐंकर बनाया जाता है, जैसे कि Plane, तो ऐंकर, अटैच किए गए Trackable के साथ स्पेस में चलता है.

when (val result = trackable.createAnchor(pose)) {
  is AnchorCreateSuccess -> // `result.anchor` can be used.
  else -> // handle failure
}

ट्रैक किए जा सकने वाले एलिमेंट के बिना ऐंकर बनाना

ऐसा ऐंकर बनाने के लिए जो Trackable से अटैच न हो:

when (val result = Anchor.create(session, pose)) {
  is AnchorCreateSuccess -> // ...
  else -> // handle failure
}

किसी इकाई को एंकर से अटैच करना

इस जगह पर कोई मॉडल रेंडर करने के लिए, GltfModel बनाएं और उसका पोज़, ऐंकर के पोज़ पर सेट करें. पक्का करें कि जब ऐंकर का TrackingState Stopped हो, तब मॉडल छिपा हो.

// renderSession is androidx.xr.core.Session
anchor.state.collect { state ->
  if (state.trackingState == TrackingState.Tracking) {
    gltfEntity.setPose(
      renderSession.perceptionSpace.transformPoseTo(state.pose, renderSession.activitySpace)
    )
  } else if (state.trackingState == TrackingState.Stopped) {
    entity.setHidden(true)
  }
}

TrackingState को समझना

हर Trackable में एक TrackingState होता है. इसका इस्तेमाल करने से पहले, इसकी जांच करनी चाहिए. Trackable के TrackableState की वैल्यू Tracking होने पर, सिस्टम Pose को लगातार अपडेट करता है. Paused वाला Trackable, आने वाले समय में Tracking हो सकता है, जबकि Stopped वाला कभी Tracking नहीं हो सकता.

सभी सेशन में ऐंकर को बनाए रखना

सेशन खत्म होने के बाद, सेव नहीं किया गया ऐंकर दिखना बंद हो जाता है. किसी ऐंकर को सेव करने पर, आपका ऐप्लिकेशन अपने निजी ऐप्लिकेशन डेटा में उस ऐंकर की पोज़िशन को याद रखता है. इस ऐंकर को अगले सेशन में वापस लाया जा सकता है और यह दुनिया में उसी जगह पर ऐंकर किया जाता है.

किसी ऐंकर को बनाए रखने के लिए, यहां दिखाए गए तरीके के मुताबिक anchor.persist() का इस्तेमाल करें:

val uuid = anchor.persist()

आपका ऐप्लिकेशन, आने वाले समय में किसी सेशन में UUID का इस्तेमाल करके, ऐंकर को वापस ला सकता है:

when (val result = Anchor.load(session, uuid)) {
  is AnchorCreateSuccess -> // Loading was successful. The anchor is stored in result.anchor.
  else -> // handle failure
}

जब आपको ऐंकर की ज़रूरत न हो, तो unpersist() को कॉल करें. इससे ऐप्लिकेशन के स्टोरेज से ऐंकर हट जाता है और Anchor.load() को कॉल करने पर, दिए गए यूयूआईडी को वापस नहीं पाया जा सकता.

Anchor.unpersist(session, uuid)

आपका ऐप्लिकेशन, सेव किए गए उन सभी ऐंकर की सूची का अनुरोध भी कर सकता है जो अब भी आपके ऐप्लिकेशन के स्टोरेज में मौजूद हैं:

val uuids = Anchor.getPersistedAnchorUuids(session)

यह भी देखें: