অডিও গ্লাস ও ডিসপ্লে গ্লাসে হার্ডওয়্যার অ্যাক্সেস করতে প্রজেক্ট করা কন্টেক্সট ব্যবহার করা

প্রযোজ্য XR ডিভাইস
এই নির্দেশিকা আপনাকে এই ধরনের XR ডিভাইসের জন্য অভিজ্ঞতা তৈরি করতে সাহায্য করে।
অডিও ও
ডিসপ্লে গ্লাস

আপনি প্রয়োজনীয় অনুমতির জন্য অনুরোধ করার এবং তা পাওয়ার পরে, আপনার অ্যাপ অডিও গ্লাস বা ডিসপ্লে গ্লাসের হার্ডওয়্যার অ্যাক্সেস করতে পারবে। চশমার হার্ডওয়্যার (ফোনের হার্ডওয়্যারের পরিবর্তে) অ্যাক্সেস করার মূল উপায় হল, প্রোজেক্টেড কনটেক্সট ব্যবহার করা।

আপনার কোড কোথায় এক্সিকিউট হচ্ছে তার উপর নির্ভর করে, প্রোজেক্ট করা কনটেক্সট পাওয়ার দুটি প্রাথমিক উপায় আছে:

আপনার কোড কোনও প্রোজেক্টেড অ্যাক্টিভিটিতে রান করলে প্রোজেক্টেড কনটেক্সট পান

আপনার অ্যাপের কোড যদি প্রোজেক্ট করা অ্যাক্টিভিটি থেকে রান করে, তাহলে এর নিজস্ব অ্যাক্টিভিটি কন্টেক্সট আগে থেকেই প্রোজেক্ট করা কন্টেক্সট হিসেবে থাকে। এই পরিস্থিতিতে, সেই অ্যাক্টিভিটির মধ্যে করা কল ইতিমধ্যেই চশমার হার্ডওয়্যার অ্যাক্সেস করতে পারে।

ফোন অ্যাপ কম্পোনেন্টে চলা কোডের জন্য একটি প্রোজেক্ট করা প্রসঙ্গ পান

আপনার প্রোজেক্ট করা অ্যাক্টিভিটির বাইরে আপনার অ্যাপের কোনও অংশ (যেমন ফোন অ্যাক্টিভিটি বা কোনও পরিষেবা) যদি চশমার হার্ডওয়্যার অ্যাক্সেস করতে চায়, তাহলে তাকে অবশ্যই স্পষ্টভাবে একটি প্রোজেক্ট করা কনটেক্সট পেতে হবে। এটি করতে, createProjectedDeviceContext পদ্ধতি ব্যবহার করুন:

@RequiresApi(Build.VERSION_CODES.BAKLAVA)
@OptIn(ExperimentalProjectedApi::class, ExperimentalCoroutinesApi::class)
fun monitorProjectedDeviceConnectivity(
    context: Context,
    onConnected: suspend (projectedContext: Context) -> (() -> Unit)?
) {
    val lifecycleScope = (context as? LifecycleOwner)?.lifecycleScope
        ?: CoroutineScope(Dispatchers.Main + SupervisorJob())

    lifecycleScope.launch {
        var cleanupAction: (() -> Unit)? = null

        try {
            // Before creating a projected context, verify that the projected device
            // is connected to the host device (phone).
            // While this flow collects true, the active projected context remains valid.
            ProjectedContext.isProjectedDeviceConnected(context, coroutineContext)
                .distinctUntilChanged()
                .collectLatest { isConnected ->
                    // Clean up any previous session resources prior to state transitions.
                    cleanupAction?.invoke()
                    cleanupAction = null

                    if (!isConnected) {
                        Log.i(TAG, "Projected device disconnected. Cleaning up hardware resources...")
                        return@collectLatest
                    }

                    // Inside a phone Activity or Service, create a projected context.
                    // Note: If you are already inside a projected Activity, the default context
                    // is already a projected context.
                    val projectedContext = runCatching {
                        ProjectedContext.createProjectedDeviceContext(context)
                    }.onFailure { e ->
                        Log.e(TAG, "Failed to create projected context", e)
                    }.getOrNull() ?: return@collectLatest

                    // Use the new, valid `projectedContext` to initialize system services (e.g., CameraManager).
                    Log.i(TAG, "Projected device connected. Initializing hardware...")
                    cleanupAction = onConnected(projectedContext)
                }
        } finally {
            // Guarantee final resource cleanup on Activity destruction or scope cancellation.
            cleanupAction?.invoke()
            cleanupAction = null
        }
    }
}

বৈধতা চেক করুন

createProjectedDeviceContext কলটি ProjectedContext.isProjectedDeviceConnected-এর মধ্যে র‍্যাপ করুন। এই পদ্ধতি true ফিরিয়ে দিলেও, কানেক্ট করা ডিভাইসের ক্ষেত্রে প্রোজেক্ট করা প্রসঙ্গ বৈধ থাকে এবং আপনার ফোন অ্যাপ অ্যাক্টিভিটি বা পরিষেবা (যেমন, CameraManager) চশমার হার্ডওয়্যার অ্যাক্সেস করতে পারে।

ডিসকানেক্ট করার সময় ক্লিন-আপ করুন

প্রোজেক্ট করা কনটেক্সট কানেক্ট করা ডিভাইসের লাইফসাইকেলের সাথে যুক্ত থাকে, তাই ডিভাইস ডিসকানেক্ট হয়ে গেলে এটি নষ্ট হয়ে যায়। ডিভাইস ডিসকানেক্ট হয়ে গেলে, ProjectedContext.isProjectedDeviceConnected false রিটার্ন করে। আপনার অ্যাপের এই পরিবর্তন লক্ষ্য করা উচিত এবং যেকোনও সিস্টেম পরিষেবা (যেমন, CameraManager) বা রিসোর্স ক্লিন-আপ করা উচিত যা আপনার অ্যাপ সেই প্রোজেক্ট করা কন্টেক্সট ব্যবহার করে তৈরি করেছে।

আবার কানেক্ট করার সময় আবার চালু করুন

চশমা আবার কানেক্ট হলে, আপনার অ্যাপ createProjectedDeviceContext ব্যবহার করে অন্য একটি প্রোজেক্ট করা কনটেক্সট ইনস্ট্যান্স পেতে পারে এবং তারপর নতুন প্রোজেক্ট করা কনটেক্সট ব্যবহার করে যেকোনও সিস্টেম পরিষেবা বা রিসোর্স আবার শুরু করতে পারে।

স্মার্ট গ্লাসের মাইক্রোফোন দিয়ে অডিও রেকর্ড করুন

আপনি ব্লুটুথ হ্যান্ডস-ফ্রি প্রোফাইল (HFP) ব্যবহার করে চশমা থেকে অডিও রেকর্ড করতে পারবেন। এই মোডে, চশমা স্ট্যান্ডার্ড হেডসেট এবং উন্নত অডিও ডিস্ট্রিবিউশন প্রোফাইল (A2DP) প্রোফাইল ব্যবহার করে ফোনের সাথে কানেক্ট করে, যা সাধারণ ব্লুটুথ পেরিফেরালের মতো কাজ করে। আপনার অ্যাপ যদি আগে থেকেই স্ট্যান্ডার্ড ব্লুটুথ রেকর্ডিংয়ের জন্য ডিজাইন করা থাকে, তাহলে আপনি অতিরিক্ত কোনও ডেভেলপমেন্ট ছাড়াই চশমা থেকে অডিও রেকর্ড করতে এই পদ্ধতি ব্যবহার করতে পারেন।

ব্লুটুথ HFP ব্যবহার করে অডিও রেকর্ড করুন

ব্লুটুথ HFP ব্যবহার করে অডিও রেকর্ড করতে, প্রথমে প্রয়োজনীয় রানটাইম অনুমতির জন্য অনুরোধ করুন এবং তারপরে নিম্নলিখিত বিভাগে যেভাবে বর্ণনা করা হয়েছে, সেইভাবে AudioManager API ব্যবহার করে অডিও রেকর্ড করুন।

অনুমতির জন্য অনুরোধ করুন

যেকোনও স্ট্যান্ডার্ড ব্লুটুথ অডিও ডিভাইসের মতো, RECORD_AUDIO, BLUETOOTH_CONNECT এবং অন্যান্য সম্পর্কিত অনুমতি ফোন দ্বারা নিয়ন্ত্রিত হয়, কানেক্ট করা ডিভাইস (যেমন অডিও গ্লাস বা ডিসপ্লে গ্লাস) দ্বারা নয়।

অনুমতির অনুরোধ করতে এই ধাপগুলি অনুসরণ করুন:

  1. আপনার অ্যাপের ম্যানিফেস্ট ফাইলে নিম্নলিখিত অনুমতি ঘোষণা করুন:

  2. স্ট্যান্ডার্ড Android অনুমতি ফ্লো ব্যবহার করে রানটাইমে RECORD_AUDIO এবং BLUETOOTH_CONNECT, উভয় অনুমতির জন্য অনুরোধ করুন।

অডিও রুট করতে AudioManager ব্যবহার করুন

ব্যবহারকারী আপনার অ্যাপকে প্রয়োজনীয় রানটাইম অনুমতি দেওয়ার পরে, AudioManager API ব্যবহার করে কমিউনিকেশন ডিভাইসকে TYPE_BLUETOOTH_SCO-এ সেট করুন যাতে ব্লুটুথ HFP-এর মাধ্যমে অডিও রুট করা যায়। এটি সিস্টেমকে ব্লুটুথ পেরিফেরাল থেকে অডিও ফিরিয়ে আনার নির্দেশ দেয়।

val audioManager = context.getSystemService(AudioManager::class.java) ?: return
val hfpDevice = audioManager.availableCommunicationDevices
    .firstOrNull { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO } ?: return

// HFP input is limited to 16 kHz, with mono or stereo channel configurations.
val sampleRate = 16_000
val channelMask = AudioFormat.CHANNEL_IN_MONO
val encoding = AudioFormat.ENCODING_PCM_16BIT

// Use a small multiple of the minimum buffer size to keep chunks short for low latency.
val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelMask, encoding)
if (minBufferSize <= 0) return

val audioRecord = AudioRecord.Builder()
    .setAudioSource(MediaRecorder.AudioSource.VOICE_COMMUNICATION)
    .setAudioFormat(
        AudioFormat.Builder()
            .setSampleRate(sampleRate)
            .setChannelMask(channelMask)
            .setEncoding(encoding)
            .build()
    )
    .setBufferSizeInBytes(minBufferSize * 2)
    .build()

try {
    // Route voice communication audio through the Bluetooth device.
    if (!audioManager.setCommunicationDevice(hfpDevice)) return
    audioRecord.startRecording()
    // Read audio with audioRecord.read() on a background thread.
} finally {
    // Stop and release when done.
    if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) audioRecord.stop()
    audioRecord.release()
    audioManager.clearCommunicationDevice()
}

স্মার্টগ্লাসের ক্যামেরা দিয়ে ছবি তুলুন

চশমার ক্যামেরা দিয়ে ছবি তুলতে, প্রোজেক্ট করা ডিভাইসের প্রসঙ্গ পেতে monitorProjectedDeviceConnectivity-এর সাথে কানেক্টিভিটি মনিটর করুন, সেই প্রসঙ্গের সাথে বাউন্ড করা একটি আইসোলেটেড LifecycleCameraProvider তৈরি করুন, ক্যামেরা আছে কিনা তা শুনুন এবং CameraX-এর ImageCapture ব্যবহারের কেস বাউন্ড করুন।

প্রথমে, ডিভাইস কানেক্টিভিটি মনিটর করুন এবং সিঙ্গেল-স্ট্রিম CameraXConfig.Builder সহ LifecycleCameraProvider.createInstance ইনিশিয়ালাইজ করুন:

@OptIn(ExperimentalCameraProviderConfiguration::class)
@RequiresApi(Build.VERSION_CODES.BAKLAVA)
@SuppressLint("RestrictedApi")
fun setUpGlassesCamera(activity: ComponentActivity) {
    monitorProjectedDeviceConnectivity(activity) { projectedContext ->
        val cameraManager = projectedContext.getSystemService(CameraManager::class.java)
            ?: run {
                Log.e(TAG, "CameraManager not available on projected context")
                return@monitorProjectedDeviceConnectivity null
            }

        // `setRepeatingStreamForced()` is currently internal but will be public soon.
        val cameraConfig = CameraXConfig.Builder
            .fromConfig(Camera2Config.defaultConfig())
            .setRepeatingStreamForced(false)
            .build()

        val cameraProvider = try {
            // Acquire CameraX provider specifically bound to the projected context.
            // If the device disconnects while suspending, collectLatest cancels this coroutine.
            LifecycleCameraProvider.createInstance(projectedContext, cameraConfig)
        } catch (e: IllegalStateException) {
            Log.e(TAG, "Failed to initialize projected camera services", e)
            return@monitorProjectedDeviceConnectivity null
        }

        // Set up the listener to react to camera availability changes asynchronously.
        val availabilityCallback = registerAvailabilityListener(
            cameraManager = cameraManager,
            cameraProvider = cameraProvider,
            executor = ContextCompat.getMainExecutor(activity),
            onCameraAvailable = { cameraId ->
                // Delegate camera selection, resolution querying, and use-case binding.
                bindGlassesImageCapture(cameraProvider, cameraId, activity)
            }
        )

        // Return a clean-up closure invoked automatically by monitorProjectedDeviceConnectivity
        // on disconnect, coroutine cancellation, or Activity destruction.
        return@monitorProjectedDeviceConnectivity {
            Log.i(TAG, "Projected camera setup scope ended. Tearing down resources...")
            try {
                cameraManager.unregisterAvailabilityCallback(availabilityCallback)
            } finally {
                cameraProvider.unbindAll()
            }
        }
    }
}

CameraX 1.6.0 ও তার পরবর্তী যেকোনও ভার্সনে, চশমার ক্যামেরা যোগ করা বা সরানো হলে প্রতিক্রিয়া জানাতে addCameraPresenceListener ব্যবহার করে CameraPresenceListener রেজিস্টার করুন:

@OptIn(ExperimentalCameraProviderConfiguration::class)
fun registerAvailabilityListener(
    cameraManager: CameraManager,
    cameraProvider: LifecycleCameraProvider,
    executor: Executor,
    onCameraAvailable: (cameraId: String) -> Unit
): CameraManager.AvailabilityCallback {
    val callback = object : CameraManager.AvailabilityCallback() {
        override fun onCameraAvailable(cameraId: String) {
            super.onCameraAvailable(cameraId)
            Log.i(TAG, "Glasses camera available (ID: $cameraId). Binding use case...")
            // Fires only after the OS finishes re-registering the glasses' camera.
            // Pass the fresh cameraId directly—never cache it, as it may change when recreated.
            onCameraAvailable(cameraId)
        }

        override fun onCameraUnavailable(cameraId: String) {
            super.onCameraUnavailable(cameraId)
            Log.i(TAG, "Glasses camera unavailable (ID: $cameraId). Releasing resources...")
            // Gracefully release the pipeline when the projected camera becomes unavailable.
            cameraProvider.unbindAll()
        }
    }

    cameraManager.registerAvailabilityCallback(executor, callback)
    return callback
}

এরপর, শ্রোতার দেওয়া CameraIdentifier ব্যবহার করে availableCameraInfos থেকে স্মার্ট গ্লাসের ক্যামেরা বেছে নিন এবং ImageCapture বাইন্ড করুন:

/**
 * Selects the projected camera matching dynamic [cameraId] from
 * [LifecycleCameraProvider.availableCameraInfos], verifies availability, and binds an
 * [ImageCapture] use case targeting a 16:9 resolution to [lifecycleOwner].
 *
 * Note: Depending on your application's needs, [ImageCapture] can be swapped out for other
 * standard CameraX use cases:
 * - Use [ImageAnalysis] for real-time streaming workloads (e.g., OCR, AI vision, or VPS).
 * - Use [VideoCapture] for video recording pipelines.
 */
@OptIn(ExperimentalCamera2Interop::class, ExperimentalCameraProviderConfiguration::class)
fun bindGlassesImageCapture(
    cameraProvider: LifecycleCameraProvider,
    cameraId: String,
    lifecycleOwner: LifecycleOwner,
    preferredResolution: Size = Size(1920, 1080)
): ImageCapture? {
    return try {
        // Discover available cameras dynamically via `availableCameraInfos`
        // Narrow it down by the dynamic `cameraId` because the projected camera's ID may
        // change when recreated
        val cameraInfo = cameraProvider.availableCameraInfos.firstOrNull { info ->
            Camera2CameraInfo.from(info).cameraId == cameraId
        }

        // Pre-binding check: Verify the selected camera is registered and available on the device.
        // The projected camera may be unavailable (for example, if the user took off the glasses).
        if (cameraInfo == null) {
            Log.w(TAG, "Glasses camera (ID: $cameraId) is not currently available.")
            return null
        }
        val cameraSelector = cameraInfo.cameraSelector

        val resolutionSelector = ResolutionSelector.Builder()
            .setAspectRatioStrategy(AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY)
            .setResolutionStrategy(
                ResolutionStrategy(
                    preferredResolution,
                    ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER
                )
            )
            .build()

        // Initialize the ImageCapture use case.
        val imageCapture = ImageCapture.Builder()
            .setResolutionSelector(resolutionSelector)
            .build()

        // Unbind any previously bound use cases before rebinding to the lifecycle owner.
        cameraProvider.unbindAll()

        // Bind the configured use case. You can swap `imageCapture` out for an `ImageAnalysis`
        // (e.g., from `setupCameraStreamingFps`) or `VideoCapture` instance here to match your use case.
        // `bindToLifecycle()` can throw IllegalArgumentException if use cases
        // are incompatible, or IllegalStateException if the LifecycleOwner is destroyed.
        cameraProvider.bindToLifecycle(
            lifecycleOwner,
            cameraSelector,
            imageCapture
        )
        Log.i(TAG, "ImageCapture successfully bound for camera ID $cameraId")
        imageCapture
    } catch (exc: CameraInfoUnavailableException) {
        Log.e(TAG, "Unable to access camera info for ID $cameraId", exc)
        null
    } catch (exc: IllegalArgumentException) {
        Log.e(TAG, "Invalid camera configuration or use case combination for ID $cameraId", exc)
        null
    } catch (exc: IllegalStateException) {
        Log.e(TAG, "Camera is already bound to another lifecycle or closed", exc)
        null
    }
}

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • প্রতি-ডিভাইস LifecycleCameraProvider: অ্যাক্টিভ প্রোজেক্টেড কনটেক্সটে স্কোপ করা একটি আইসোলেটেড ক্যামেরা প্রোভাইডার তৈরি করতে LifecycleCameraProvider.createInstance ব্যবহার করুন। কারণ আপনার অ্যাপ প্রসেস চালু থাকার সময় চশমা ডিসকানেক্ট ও আবার কানেক্ট হলে প্রজেক্ট করা কন্টেক্সটের deviceId পরিবর্তন হতে পারে, প্রতিটি ডিভাইসের জন্য প্রোভাইডার তৈরি করলে CameraX অ্যাক্টিভ কানেক্ট করা ডিভাইসের সাথে বাইন্ড করে।
  • ক্যামেরা আছে কিনা তা চেক করুন: CameraX 1.6.0 এবং তার পরবর্তী ভার্সনে, চশমা কানেক্ট করার সাথে সাথে ক্যামেরা খোলার পরিবর্তে cameraProvider.addCameraPresenceListener ব্যবহার করে CameraPresenceListener রেজিস্টার করুন। OS, স্মার্ট গ্লাসের ক্যামেরা আবার তৈরি করার আগে, স্মার্ট গ্লাস ও হোস্টের মধ্যে অ্যাসিঙ্ক্রোনাস সেট-আপ সম্পূর্ণ করতে হবে এবং কানেক্ট থাকা অবস্থাতেও স্মার্ট গ্লাসের ক্যামেরা ডায়নামিকভাবে অদৃশ্য হয়ে যেতে পারে (যেমন, থার্মাল মিটিগেশনের সময়)।
    • ক্যামেরা যোগ করা (onCamerasAdded): যোগ করা ক্যামেরার সাথে availableCameraInfos আপডেট হওয়ার পরে ফায়ার করে, সেট-আপের সময় টাইমিং রেস এড়িয়ে যায়।
    • ক্যামেরা সরিয়ে দেওয়া (onCamerasRemoved): ক্যামেরা ব্যবহার করা হচ্ছে কিনা তা ট্র্যাক করার পরিবর্তে ক্যামেরা আছে কিনা তা ট্র্যাক করে, তাই সেখানে আনবাইন্ড করলে রিসোর্স তখনই রিলিজ হয় যখন চশমার ক্যামেরা সরিয়ে দেওয়া হয়, আপনার নিজের অ্যাপ ক্যামেরা খুললে কোনও প্রতিক্রিয়া হয় না।
  • ডিসকানেক্ট করার সময় ক্লিন-আপ: চশমা ডিসকানেক্ট হয়ে গেলে বা অ্যাক্টিভিটি বন্ধ হয়ে গেলে ক্লিন-আপ ক্লোজার monitorProjectedDeviceConnectivity কল removeCameraPresenceListener এবং unbindAll()-এ ফিরে যায়।
  • ডায়নামিক ক্যামেরা বেছে নেওয়া: onCamerasAdded-এ পাস করা CameraIdentifier-এর সাথে availableCameraInfos-এর বিপরীতে isOf ব্যবহার করে স্মার্টগ্লাসের ক্যামেরা ডায়নামিকভাবে বেছে নেয়।
  • কাস্টম রেজোলিউশন: ImageCapture-এর জন্য উদাহরণস্বরূপ ১৬:৯ অ্যাস্পেক্ট রেশিও এবং আপনার পছন্দের রেজোলিউশন (সবচেয়ে কাছাকাছি কম সমর্থিত সাইজে ফিরে যাওয়া) টার্গেট করে একটি ResolutionSelector তৈরি করে। কাজ করে এমন অ্যাস্পেক্ট রেশিও এবং রেজোলিউশন বিভিন্ন চশমা ডিভাইস এবং মোড (যেমন ৪:৩ এবং ১৬:৯) জুড়ে পরিবর্তিত হয়, তাই আপনাকে সঠিক কাজ করে এমন সাইজ চেক করতে হলে StreamConfigurationMap কোয়েরি করুন।
  • লাইফসাইকেল বাইন্ডিং: LifecycleOwner-এর সাথে ImageCapture বাইন্ড করে, অ্যাক্টিভিটির লাইফসাইকেলের সাথে ক্যামেরা খোলা ও বন্ধ করার ট্রানজিশন অটোমেটিক ম্যানেজ করে।
  • সিঙ্গেল-স্ট্রিম হার্ডওয়্যারের জন্য কনফিগার করা: চশমার ক্যামেরা পাইপলাইন একবারে একটি অ্যাক্টিভ স্ট্রিমে সীমাবদ্ধ। ImageCapture একা বাউন্ড করা থাকলে, CameraX ফোকাস ও মিটারিংয়ের জন্য ডিফল্ট হিসেবে একটি ইন্টার্নাল রিপিটিং স্ট্রিম (MeteringRepeating) অ্যাটাচ করে, যার ফলে সিঙ্গেল-স্ট্রিম পাইপলাইন স্টল হয়ে যায়। LifecycleCameraProvider.createInstance-এ পাস করা CameraXConfig-এ setRepeatingStreamForced(false) পাস করুন যাতে প্রিভিউ স্ট্রিম ছাড়াই ImageCapture বাইন্ড করতে পারে।

স্মার্ট গ্লাসের ক্যামেরা সেট-আপ করার পরে, আপনি CameraX-এর ImageCapture ক্লাস ব্যবহার করে ছবি ক্যাপচার করতে পারবেন। takePicture ব্যবহার করে ছবি ক্যাপচার করা সম্পর্কে জানতে CameraX-এর ডকুমেন্টেশন দেখুন।

স্মার্টগ্লাসের ক্যামেরা দিয়ে স্ট্রিম ক্যাপচার করুন

ছবির পরিবর্তে স্ট্রিম ক্যাপচার করতে, ক্যাপচার করা ছবির উদাহরণ থেকে ImageCapture কম্পোনেন্ট VideoCapture অথবা ImageAnalysis কম্পোনেন্ট দিয়ে পরিবর্তন করুন এবং ক্যাপচার লজিক পরিবর্তন করুন।

এইসব API সম্পর্কে আরও তথ্য এবং কীভাবে সেগুলি ব্যবহার করতে হয় তা জানতে, CameraX ভিডিও ক্যাপচার এবং CameraX ছবি বিশ্লেষণ সংক্রান্ত ডকুমেন্টেশন দেখুন।

রেজোলিউশন ও ফ্রেম রেট বেছে নিন

ডিভাইসটি কোন কোন রেজোলিউশন এবং সেগুলির সাথে সম্পর্কিত সর্বাধিক ফ্রেম রেট সমর্থন করে তা জানতে আপনাকে ডিভাইসটি কোয়েরি করতে হবে। আপনার অ্যাপের ব্যবহারের উপর নির্ভর করে আপনি দেখতে পেতে পারেন এমন ভ্যালুর উদাহরণ নিচের সারণীতে তালিকাভুক্ত করা হয়েছে। ব্যাটারির চার্জ বাঁচাতে এবং স্মার্ট গ্লাসের তাপমাত্রা কমাতে, আপনার ব্যবহারের ক্ষেত্রে কাজ করে এমন সর্বনিম্ন রেজোলিউশন এবং ফ্রেম রেট বেছে নিন।

ব্যবহারের উদাহরণ রেজোলিউশন ফ্রেম রেট
টেক্সট শনাক্তকরণ (OCR) বা ওয়ার্ল্ড সেন্সিং ১৯২০ x ১০৮০ ১ FPS
AI ভিডিও স্ট্রিমিং (মাল্টিমোডাল অ্যাসিস্ট্যান্ট) ১০২৪ x ৭৬৮ ১ FPS
লোকালাইজেশন ও ভিজ্যুয়াল পজিশনিং (VPS) ৬৪০ x ৩৬০ অথবা ৬৪০ x ৪৮০ ১০ FPS
ভিডিও কলিং ৬৪০ x ৩৬০ অথবা ৬৪০ x ৪৮০ ২৪ FPS

প্রতিটি রেজোলিউশনের জন্য সর্বাধিক ফ্রেম রেট কোয়েরি করুন

CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES ডিভাইসের সামগ্রিক ফ্রেম রেটের সীমা রিপোর্ট করে, যা প্রদত্ত রেজোলিউশন দ্বারা সমর্থিত স্ট্রিমিং রেটের চেয়ে বেশি হতে পারে। অডিও ও ডিসপ্লে গ্লাসে প্রতিটি রেজোলিউশনের জন্য প্রকৃত সর্বাধিক FPS পেতে, এর ন্যূনতম ফ্রেমের সময়কাল পড়ুন এবং StreamConfigurationMap.getOutputMinFrameDuration(format, size)-এর মাধ্যমে এটিকে FPS-এ রূপান্তর করুন:

@androidx.annotation.OptIn(ExperimentalCamera2Interop::class)
fun getMaxFpsBySize(cameraInfo: CameraInfo, format: Int): Map<Size, Int> {
    val map = Camera2CameraInfo.from(cameraInfo).getCameraCharacteristic(
        CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
    ) ?: return emptyMap()

    return map.getOutputSizes(format).associateWith { size ->
        val minFrameDurationNs = map.getOutputMinFrameDuration(format, size)
        if (minFrameDurationNs > 0) (1_000_000_000L / minFrameDurationNs).toInt() else 0
    }
}

এরপর, আপনার টার্গেট ফ্রেম রেট রেঞ্জের জন্য minFps এবং maxFps বাউন্ড গণনা করতে সেই ভ্যালু ব্যবহার করুন। রেজোলিউশনের সর্বাধিক স্ট্রিমিং ফ্রেম রেট getOutputMinFrameDuration থেকে গণনা করে নিম্ন সীমা (minFps) ক্যাপ করুন এবং ক্যাচ-আপ উইন্ডো হিসেবে উচ্চতর সীমা (maxFps) সেট করুন:

val maxFpsBySize = getMaxFpsBySize(cameraInfo, ImageFormat.YUV_420_888)
val maxSupportedFps = maxFpsBySize[size] ?: return ImageAnalysis.Builder().build()

// minFps is the target streaming frame rate and should be at most maxSupportedFps.
val minFps = minOf(desiredFps, maxSupportedFps)
// Set the upper bound to 2x minFps so the stream can catch up if frames are delayed.
val maxFps = minFps * 2

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • আপনার ব্যবহারের ক্ষেত্রে মেলে এমন ফর্ম্যাট ব্যবহার করুন। ImageAnalysis-এর জন্য, সেটি হল YUV_420_888।
  • VideoCapture-এর জন্য, পরিবর্তে Class ওভারলোড ব্যবহার করুন: getOutputSizes(MediaRecorder::class.java) এবং getOutputMinFrameDuration(MediaRecorder::class.java, size).
  • Range(minFps, minFps)-এর মতো একই ভ্যালুতে দুটি বাউন্ড সেট করার পরিবর্তে এমন একটি রেঞ্জ উল্লেখ করুন যেখানে maxFps, minFps-এর চেয়ে বেশি (যেমন minFps*2)। নিম্ন সীমা (minFps) টার্গেট স্ট্রিমিং ফ্রেম রেট সেট করে এবং এটি সর্বাধিক getOutputMinFrameDuration থেকে গণনা করা মান হওয়া উচিত, যখন উচ্চ সীমা (maxFps) ক্রমাগত লেটেন্সি প্রতিরোধ করতে বিলম্বিত ফ্রেমের জন্য একটি ক্যাচ-আপ উইন্ডো হিসাবে কাজ করে। যেমন, ১ FPS স্ট্রিমের জন্য [১,২] বা [১,৩] এবং ২৪ FPS স্ট্রিমের জন্য [২৪,৩০] বা [২৪,৪৮]।

ফ্রেম রেট কনফিগার করুন

আপনার CameraX ব্যবহারের ক্ষেত্রের উপর ভিত্তি করে ফ্রেম রেট রেঞ্জ কনফিগার করতে:

// Create and return the ImageAnalysis builder with proper frame rate ranges
// ImageAnalysis: OCR, AI streaming, and VPS
val analysisBuilder = ImageAnalysis.Builder()
    .setResolutionSelector(resolutionSelector)

Camera2Interop.Extender(analysisBuilder)
    .setCaptureRequestOption(
        CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
        Range(minFps, maxFps)
    )
return analysisBuilder.build()

এই উদাহরণে VideoCapture ও ImageAnalysis, দুটির জন্যই কনফিগারেশন দেখানো হয়েছে, তবে আপনার অ্যাপে যে ধরনের ব্যবহারিক ক্ষেত্র কাজ করে, আপনি সেটিই প্রয়োগ করতে পারেন।

স্ট্রিম কীভাবে কাজ করে তা বুঝুন

ক্যাপচার স্ট্রিম নিয়ে কাজ করার সময় সিস্টেমের নিম্নলিখিত আচরণগুলি মনে রাখবেন:

  • যেসব রেজোলিউশন কাজ করে না সেগুলি বাতিল করা হয়: আপনি যদি এমন সাইজের অনুরোধ করেন যা তালিকায় নেই, তাহলে স্ট্রিম খোলার আগে Camera2 কনফিগারেশন বাতিল করে দেয়।
  • সর্বোচ্চের বেশি ফ্রেম রেটের অনুরোধ করা: আপনি যদি আপনার রেজোলিউশনের জন্য সমর্থিত সর্বোচ্চের বেশি ন্যূনতম ফ্রেম রেটের অনুরোধ করেন, তাহলেও সেশনটি খোলে, তবে চশমা থেকে টার্গেট ফ্রেম রেট সেই সমর্থিত সর্বোচ্চের সাথে ক্ল্যাম্প করা হয় এবং উপরের সীমাটি ক্যাচ-আপ রেট সীমা হিসাবে কাজ করতে থাকে। যেমন, ৬৪০ x ৪৮০-এ [৩০,৬০] অনুরোধ করলে টার্গেট ফ্রেম রেট ২৪ FPS-এ ক্ল্যাম্প করে (যা [২৪,৬০]-এর মতো কাজ করে)।
  • থার্মাল থ্রটলিং: চশমা গরম হয়ে গেলে, ফ্রেম রেট কমে যায় কিন্তু রেজোলিউশন একই থাকে। কম বা অসম ফ্রেম রেট ম্যানেজ করার জন্য আপনার অ্যাপ তৈরি করুন, যেমন, একটি নির্দিষ্ট রেট অনুমান করার পরিবর্তে ফ্রেম টাইমস্ট্যাম্প চেক করে।

প্রোজেক্ট করা অ্যাক্টিভিটি থেকে ফোনের হার্ডওয়্যার অ্যাক্সেস করা

প্রোজেক্ট করা অ্যাক্টিভিটি হোস্ট ডিভাইসের (ফোন) প্রসঙ্গ পেতে createHostDeviceContext(context) ব্যবহার করে ফোনের হার্ডওয়্যারও (যেমন ক্যামেরা বা মাইক্রোফোন) অ্যাক্সেস করতে পারে:

@OptIn(ExperimentalProjectedApi::class)
fun getHostDeviceContext(context: Context): Context {
    // Obtain the host device (phone) context.
    // The `context` argument passed in can be any context (projected, host, Service, or App).
    return ProjectedContext.createHostDeviceContext(context)
}

হাইব্রিড অ্যাপে (মোবাইল ও চশমা, দুটির অভিজ্ঞতা প্রদান করে এমন অ্যাপ) হোস্ট ডিভাইসের (ফোন) জন্য নির্দিষ্ট হার্ডওয়্যার বা রিসোর্স অ্যাক্সেস করার সময়, আপনার অ্যাপ যাতে সঠিক হার্ডওয়্যার অ্যাক্সেস করতে পারে তা নিশ্চিত করতে, আপনাকে স্পষ্টভাবে সঠিক প্রসঙ্গ বেছে নিতে হবে:

  • ফোনের প্রসঙ্গ পেতে, ফোন Activity থেকে Activity প্রসঙ্গ অথবা ProjectedContext.createHostDeviceContext ব্যবহার করুন।
  • getApplicationContext ব্যবহার করবেন না কারণ প্রোজেক্ট করা অ্যাক্টিভিটি সবচেয়ে সম্প্রতি লঞ্চ করা কম্পোনেন্ট হলে, অ্যাপ্লিকেশন কনটেক্সট ভুল করে চশমার কনটেক্সট ফিরিয়ে দিতে পারে।