एआई चश्मे के लिए अपनी पहली गतिविधि बनाना

एक्सआर के ऐसे डिवाइस जिन पर यह सुविधा काम करती है
इस गाइड की मदद से, एक्सआर के इन डिवाइसों के लिए अनुभव बनाए जा सकते हैं.
एक्सआर डिवाइसों के टाइप के बारे में जानें →
एआई ग्लास
एक्सआर डिवाइसों के टाइप के बारे में जानें →

एआई ग्लास के लिए अनुभव, Android के मौजूदा Activity फ़्रेमवर्क एपीआई पर बनाया गया है. इसमें एआई ग्लास की खास सुविधाओं के लिए, अतिरिक्त कॉन्सेप्ट शामिल हैं. एक्सआर हेडसेट में, डिवाइस पर पूरा APK चलता है. वहीं, एआई ग्लास में एक खास ऐक्टिविटी का इस्तेमाल किया जाता है. यह ऐक्टिविटी, आपके फ़ोन के मौजूदा ऐप्लिकेशन में चलती है. इस ऐक्टिविटी को, होस्ट डिवाइस से एआई ग्लास पर प्रोजेक्ट किया जाता है.

अपने ऐप्लिकेशन के लिए एआई ग्लास का अनुभव बनाने के लिए, आपको अपने मौजूदा फ़ोन ऐप्लिकेशन को बढ़ाना होगा . इसके लिए, एआई ग्लास के लिए प्रोजेक्ट की गई नई Activity बनानी होगी. यह ऐक्टिविटी, एआई ग्लास पर आपके ऐप्लिकेशन को लॉन्च करने का मुख्य एंट्री पॉइंट होती है. इस तरीके से डेवलपमेंट आसान हो जाता है, क्योंकि फ़ोन और एआई ग्लास के अनुभवों के बीच, कारोबार की लॉजिक को शेयर और दोबारा इस्तेमाल किया जा सकता है.

वर्शन के साथ काम करने वाली सुविधाएं

Jetpack XR SDK के लिए, Android SDK की ज़रूरी शर्तों के बारे में जानें.

डिपेंडेंसी

एआई ग्लास के लिए, लाइब्रेरी की ये डिपेंडेंसी जोड़ें:

शानदार

dependencies {
    implementation "androidx.xr.runtime:runtime:1.0.0-alpha12"
    implementation "androidx.xr.glimmer:glimmer:1.0.0-alpha11"
    implementation "androidx.xr.glimmer:glimmer-google-fonts:1.0.0-alpha11"
    implementation "androidx.xr.projected:projected:1.0.0-alpha06"
    implementation "androidx.xr.arcore:arcore:1.0.0-alpha12"
}

Kotlin

dependencies {
    implementation("androidx.xr.runtime:runtime:1.0.0-alpha12")
    implementation("androidx.xr.glimmer:glimmer:1.0.0-alpha11")
    implementation("androidx.xr.glimmer:glimmer-google-fonts:1.0.0-alpha11")
    implementation("androidx.xr.projected:projected:1.0.0-alpha06")
    implementation("androidx.xr.arcore:arcore:1.0.0-alpha12")
}

अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, अपनी ऐक्टिविटी का एलान करना

अन्य तरह की ऐक्टिविटी की तरह, आपको अपने ऐप्लिकेशन के मेनिफ़ेस्ट फ़ाइल में अपनी ऐक्टिविटी का एलान करना होगा. इससे सिस्टम को यह पता चलेगा कि यह ऐक्टिविटी कहां है और इसे कैसे चलाया जा सकता है.

<application>
  <activity
      android:name="com.example.xr.projected.GlassesMainActivity"
      android:exported="true"
      android:requiredDisplayCategory="xr_projected"
      android:label="Example AI Glasses activity">
      <intent-filter>
          <action android:name="android.intent.action.MAIN" />
      </intent-filter>
  </activity>
</application>

कोड के बारे में अहम बातें

  • android:requiredDisplayCategory एट्रिब्यूट के लिए xr_projected तय करता है. इससे सिस्टम को यह पता चलता है कि इस ऐक्टिविटी को, कनेक्ट किए गए डिवाइस से हार्डवेयर को ऐक्सेस करने के लिए, प्रोजेक्ट किए गए कॉन्टेक्स्ट का इस्तेमाल करना चाहिए.

अपनी ऐक्टिविटी बनाना

इसके बाद, आपको एक छोटी ऐक्टिविटी बनानी होगी. इससे, डिसप्ले चालू होने पर एआई ग्लास पर कुछ दिखाया जा सकेगा.

@OptIn(ExperimentalProjectedApi::class)
class GlassesMainActivity : ComponentActivity() {

    private var displayController: ProjectedDisplayController? = null
    private var isVisualUiSupported by mutableStateOf(false)
    private var areVisualsOn by mutableStateOf(true)
    private var isPermissionDenied by mutableStateOf(false)

    // Register the permissions launcher using the ProjectedPermissionsResultContract.
    private val requestPermissionLauncher: ActivityResultLauncher<List<ProjectedPermissionsRequestParams>> =
        registerForActivityResult(ProjectedPermissionsResultContract()) { results ->
            if (results[Manifest.permission.CAMERA] == true) {
                isPermissionDenied = false
                initializeGlassesFeatures()
            } else {
                // Handle permission denial.
                isPermissionDenied = true
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onDestroy(owner: LifecycleOwner) {
                displayController?.close()
                displayController = null
            }
        })

        if (hasCameraPermission()) {
            initializeGlassesFeatures()
        } else {
            requestHardwarePermissions()
        }

        setContent {
            GlimmerTheme {
                HomeScreen(
                    areVisualsOn = areVisualsOn,
                    isVisualUiSupported = isVisualUiSupported,
                    isPermissionDenied = isPermissionDenied,
                    onRetryPermission = { requestHardwarePermissions() },
                    onClose = { finish() }
                )
            }
        }
    }

    private fun initializeGlassesFeatures() {
        lifecycleScope.launch {
            // Check device capabilities
            val projectedDeviceController = ProjectedDeviceController.create(this@GlassesMainActivity)
            isVisualUiSupported = projectedDeviceController.capabilities.contains(CAPABILITY_VISUAL_UI)

            val controller = ProjectedDisplayController.create(this@GlassesMainActivity)
            displayController = controller
            val observer = GlassesLifecycleObserver(
                context = this@GlassesMainActivity,
                controller = controller,
                onVisualsChanged = { visualsOn -> areVisualsOn = visualsOn }
            )
            lifecycle.addObserver(observer)
        }
    }

    private fun hasCameraPermission(): Boolean {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) ==
                PackageManager.PERMISSION_GRANTED
    }

    private fun requestHardwarePermissions() {
        val params = ProjectedPermissionsRequestParams(
            permissions = listOf(Manifest.permission.CAMERA),
            rationale = "Camera access is required to overlay digital content on your physical environment."
        )
        requestPermissionLauncher.launch(listOf(params))
    }
}
GlassesMainActivity.kt

कोड के बारे में अहम बातें

कंपोज़ेबल को लागू करना

आपने जो ऐक्टिविटी बनाई है वह HomeScreen कंपोज़ेबल फ़ंक्शन को रेफ़र करती है. आपको इसे लागू करना होगा. यहां दिए गए कोड में, Jetpack Compose Glimmer का इस्तेमाल करके एक कंपोज़ेबल तय किया गया है. इससे एआई ग्लास के डिसप्ले पर कुछ टेक्स्ट दिखाया जा सकता है:

@Composable
fun HomeScreen(
    areVisualsOn: Boolean,
    isVisualUiSupported: Boolean,
    isPermissionDenied: Boolean,
    onRetryPermission: () -> Unit,
    onClose: () -> Unit,
    modifier: Modifier = Modifier
) {
    Box(
        modifier = modifier
            .surface(focusable = false)
            .fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        if (isPermissionDenied) {
            Card(
                title = { Text("Permission Required") },
                action = { Button(onClick = onClose) { Text("Exit") } }
            ) {
                Text("Camera access is needed to use AI glasses features.")
                Button(onClick = onRetryPermission) { Text("Retry") }
            }
        } else if (isVisualUiSupported) {
            Card(
                title = { Text("Android XR") },
                action = {
                    Button(onClick = onClose) {
                        Text("Close")
                    }
                }
            ) {
                if (areVisualsOn) {
                    Text("Hello, AI Glasses!")
                } else {
                    Text("Display is off. Audio guidance active.")
                }
            }
        } else {
            Text("Audio Guidance Mode Active")
        }
    }
}
GlassesMainActivity.kt

कोड के बारे में अहम बातें

  • जैसा कि आपने अपनी ऐक्टिविटी में पहले तय किया था, HomeScreen फ़ंक्शन में वह कंपोज़ेबल कॉन्टेंट शामिल होता है जो एआई ग्लास का डिसप्ले चालू होने पर उपयोगकर्ता को दिखता है.
  • Jetpack Compose Glimmer का Text कॉम्पोनेंट, ग्लास के डिसप्ले पर "Hello, AI Glasses!" टेक्स्ट दिखाता है.
  • Jetpack Compose Glimmer का Button, एआई ग्लास की ऐक्टिविटी में onClose के ज़रिए finish() को कॉल करके, ऐक्टिविटी को बंद कर देता है.

देखना कि एआई ग्लास कनेक्ट हैं या नहीं

यह पता करने के लिए कि आपकी ऐक्टिविटी लॉन्च करने से पहले, उपयोगकर्ता के एआई ग्लास उसके फ़ोन से कनेक्ट हैं या नहीं, तरीके का इस्तेमाल करें. ProjectedContext.isProjectedDeviceConnected यह तरीका , Flow<Boolean> दिखाता है. आपका ऐप्लिकेशन, कनेक्शन की स्थिति के बारे में रीयल-टाइम अपडेट पाने के लिए इसे देख सकता है .

अपनी ऐक्टिविटी शुरू करना

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

val options = ProjectedContext.createProjectedActivityOptions(context)
val intent = Intent(context, GlassesMainActivity::class.java)
context.startActivity(intent, options.toBundle())

PhoneMainActivity.kt

createProjectedActivityOptions तरीका, ProjectedContext में मौजूद प्रोजेक्ट किए गए कॉन्टेक्स्ट में आपकी ऐक्टिविटी शुरू करने के लिए ज़रूरी विकल्प जनरेट करता है. context पैरामीटर, फ़ोन या ग्लास डिवाइस का कॉन्टेक्स्ट हो सकता है.

अगले चरण

अब आपने एआई ग्लास के लिए अपनी पहली ऐक्टिविटी बना ली है. अब यह देखें कि इसकी सुविधाओं को किन अन्य तरीकों से बढ़ाया जा सकता है:

पीछे जाएं
खास जानकारी
आगे बढ़ें
अलग-अलग तरह के एआई चश्मों के साथ काम करने की योजना