از بافت پیش‌بینی‌شده برای دسترسی به سخت‌افزار عینک‌های صوتی و عینک‌های نمایشگر استفاده کنید

دستگاه‌های 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) به تلفن متصل می‌شود و مانند یک دستگاه جانبی بلوتوث معمولی عمل می‌کند. اگر برنامه‌تان ازقبل برای ضبط استاندارد بلوتوث طراحی شده است، می‌توانید از این روش برای ضبط صدا از عینک بدون هیچ‌گونه توسعه اضافی استفاده کنید.

ضبط صدا بااستفاده از Bluetooth HFP

برای ضبط صدا بااستفاده از Bluetooth HFP، ابتدا اجازه‌های زمان اجرای لازم را درخواست کنید، سپس صدا را بااستفاده از میانای برنامه‌سازی کاربردی AudioManager ضبط کنید، همان‌طور که در بخش‌های زیر توضیح داده شده است.

درخواست اجازه

مانند هر دستگاه صوتی بلوتوث استاندارد، RECORD_AUDIO، BLUETOOTH_CONNECT، و سایر اجازه‌های مرتبط توسط تلفن کنترل می‌شوند و نه دستگاه متصل‌شده (مانند عینک صوتی یا عینک نمایشگردار).

برای درخواست اجازه‌ها، این مراحل را دنبال کنید:

  1. اجازه‌های زیر را در فایل مانیفست برنامه‌تان اعلام کنید:

  2. هر دو اجازه RECORD_AUDIO و BLUETOOTH_CONNECT را در زمان اجرا بااستفاده از جریان اجازه استاندارد Android درخواست کنید.

استفاده از AudioManager برای مسیریابی صدا

پس‌از اینکه کاربر اجازه‌های زمان اجرای لازم را به برنامه شما اعطا کرد، از AudioManager API برای تنظیم دستگاه ارتباطی روی TYPE_BLUETOOTH_SCO استفاده کنید تا صدا ازطریق Bluetooth 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 مجزایی ایجاد کنید که به آن زمینه محدود شده باشد، منتظر حضور دوربین بمانید، و ImageCapture مورد استفاده CameraX را محدود کنید.

ابتدا اتصال‌پذیری دستگاه را پایش کنید و LifecycleCameraProvider.createInstance را با یک تک‌جاری CameraXConfig.Builder مقداردهی اولیه کنید:

@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 نسخه ۱.۶.۰ و بالاتر، یک CameraPresenceListener را بااستفاده از addCameraPresenceListener ثبت کنید تا وقتی دوربین عینک اضافه یا برداشته می‌شود واکنش نشان دهد:

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

سپس، دوربین عینک را از availableCameraInfos بااستفاده از CameraIdentifier ارائه‌شده توسط شنونده انتخاب کنید و 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 نسخه ۱.۶.۰ و بالاتر، CameraPresenceListener را بااستفاده از cameraProvider.addCameraPresenceListener ثبت کنید، به‌جای اینکه بلافاصله پس‌از اتصال عینک، دوربین را باز کنید. راه‌اندازی ناهمگام بین عینک و میزبان باید قبل‌از اینکه سیستم‌عامل بازسازی دوربین عینک را تمام کند، تکمیل شود و دوربین عینک نیز می‌تواند به‌طور پویا درحین اتصال ناپدید شود (مثلاً درطول کاهش حرارت).
    • افزودن دوربین (onCamerasAdded): پس‌از به‌روزرسانی availableCameraInfos با دوربین اضافه‌شده فعال می‌شود و از رقابت زمانی درطول راه‌اندازی جلوگیری می‌کند.
    • برداشتن دوربین (onCamerasRemoved): حضور دوربین را ردیابی می‌کند نه وضعیت درحال استفاده را، بنابراین لغو اتصال در آنجا فقط زمانی منابع را آزاد می‌کند که دوربین عینک برداشته شود، نه اینکه وقتی برنامه خودتان دوربین را باز می‌کند واکنش نشان دهد.
  • پاک‌سازی هنگام قطع اتصال: پاک‌سازی بسته به monitorProjectedDeviceConnectivity تماس‌ها removeCameraPresenceListener و unbindAll() برمی‌گردد وقتی اتصال عینک قطع می‌شود یا فعالیت ازبین می‌رود.
  • انتخاب دوربین پویا: CameraIdentifier ارسال‌شده به onCamerasAdded را با availableCameraInfos بااستفاده از isOf مطابقت می‌دهد تا دوربین عینک را به‌صورت پویا انتخاب کند.
  • وضوح سفارشی: ResolutionSelector را با هدف قرار دادن نسبت ابعادی نمونه ۱۶:۹ و وضوح ترجیحی شما (با بازگشت به نزدیک‌ترین اندازه پشتیبانی‌شده پایین‌تر) برای ImageCapture می‌سازد. نسبت‌های ابعادی و وضوح‌های پشتیبانی‌شده در دستگاه‌های عینک و حالت‌های مختلف (مانند ۴:۳ و ۱۶:۹) متفاوت است، بنابراین اگر نیاز به بررسی اندازه‌های دقیق پشتیبانی‌شده دارید، StreamConfigurationMap را پرسمان کنید.
  • اتصال چرخه حیات: ImageCapture را به LifecycleOwner متصل می‌کند، و به‌طور خودکار انتقال‌های باز و بسته شدن دوربین را با چرخه حیات فعالیت مدیریت می‌کند.
  • پیکربندی برای سخت‌افزار تک‌جاری‌سازی: خط لوله دوربین عینک به یک جاری‌سازی فعال در هر زمان محدود است. وقتی ImageCapture به‌تنهایی محدود می‌شود، CameraX به‌طور پیش‌فرض یک جریان تکراری داخلی (MeteringRepeating) برای فوکوس و نورسنجی متصل می‌کند که باعث توقف خط لوله تک‌جریانی می‌شود. setRepeatingStreamForced(false) را در CameraXConfig به LifecycleCameraProvider.createInstance ارسال کنید تا ImageCapture بتواند بدون جاری‌سازی پیش‌نمایش متصل شود.

پس‌از راه‌اندازی دوربین عینک، می‌توانید با کلاس ImageCapture CameraX تصویر بگیرید. برای آشنایی با نحوه استفاده از takePicture برای ضبط تصویر، به اسناد CameraX مراجعه کنید.

ضبط کردن جاری‌سازی با دوربین عینک

برای ضبط کردن جاری‌سازی‌ها به‌جای تصویر، مؤلفه ImageCapture را از نمونه ضبط تصویر با مؤلفه‌های VideoCapture یا ImageAnalysis جایگزین کنید و منطق ضبط را تغییر دهید.

برای کسب اطلاعات بیشتر درباره این میاناهای برنامه‌سازی کاربردی و نحوه استفاده از آن‌ها، به مستندات ضبط ویدیو CameraX و تحلیل تصویر CameraX مراجعه کنید.

انتخاب وضوح و نرخ فریم

باید دستگاه را جستجو کنید تا وضوح‌های پشتیبانی‌شده آن و حداکثر نرخ فریم مربوطه را پیدا کنید. جدول زیر نمونه‌هایی از مقادیری را که ممکن است بسته به مورد استفاده برنامه‌تان ببینید فهرست می‌کند. برای صرفه‌جویی در مصرف باتری و کاهش گرمای عینک، کمترین وضوح و نرخ فریمی را که برای مورد استفاده شما مناسب است انتخاب کنید.

مورد استفاده برطرف کردن مشکل نرخ فریم
تشخیص نوشتار (OCR) یا حس کردن جهان ۱۰۸۰ × ۱۹۲۰ ‫۱ فریم در ثانیه
جاری‌سازی ویدیویی هوش مصنوعی (دستیارهای چندحالتی) ۱۰۲۴ × ۷۶۸ ‫۱ فریم در ثانیه
بومی‌سازی و موقعیت‌یابی بصری (VPS) ‫۶۴۰ × ۳۶۰ یا ۶۴۰ × ۴۸۰ ‫۱۰ فریم در ثانیه
تماس تصویری ‫۶۴۰ × ۳۶۰ یا ۶۴۰ × ۴۸۰ ‫۲۴ فریم در ثانیه

پرس‌وجو کردن حداکثر نرخ فریم برای هر وضوح

CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES حدود نرخ فریم کلی دستگاه را گزارش می‌کند که می‌تواند بالاتر از نرخ جاری‌سازی‌ای باشد که وضوح معینی پشتیبانی می‌کند. برای دریافت حداکثر واقعی برای هر وضوح در عینک صوتی و نمایشگردار، حداقل مدت فریم آن را بخوانید و آن را با 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 برای محدوده نرخ فریم هدف استفاده کنید. کران پایین (minFps) را در حداکثر نرخ فریم جاری‌سازی وضوح محاسبه‌شده از getOutputMinFrameDuration محدود کنید و کران بالای بالاتری (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).
  • محدوده‌ای را مشخص کنید که در آن maxFps بزرگ‌تر از minFps باشد (مانند minFps*2) به‌جای اینکه هر دو حد را روی مقدار یکسانی مانند Range(minFps, minFps) تنظیم کنید. حد پایین (minFps) نرخ فریم جاری‌سازی هدف را تنظیم می‌کند و باید حداکثر مقدار محاسبه‌شده از getOutputMinFrameDuration باشد، درحالی‌که حد بالا (maxFps) به‌عنوان پنجره جبران برای فریم‌های تأخیری عمل می‌کند تا از تأخیر مداوم جلوگیری شود. برای مثال، [۱،۲] یا [۱،۳] برای جاری‌سازی ۱ فریم در ثانیه، و [۲۴،۳۰] یا [۲۴،۴۸] برای جاری‌سازی ۲۴ فریم در ثانیه.

پیکربندی نرخ فریم

برای پیکربندی محدوده نرخ فریم براساس مورد استفاده 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 پیکربندی را قبل‌از باز شدن جاری‌سازی رد می‌کند.
  • درخواست نرخ فریم بالاتر از حداکثر: اگر حداقل نرخ فریم را بالاتر از حداکثر نرخ فریم پشتیبانی‌شده برای وضوح خود درخواست کنید، جلسه همچنان باز می‌شود، اما نرخ فریم هدف از عینک به آن حداکثر پشتیبانی‌شده محدود می‌شود، درحالی‌که حد بالا همچنان به‌عنوان حد نرخ جبرانی عمل می‌کند. برای مثال، درخواست [۳۰،۶۰] در ۶۴۰ × ۴۸۰ نرخ فریم هدف را به ۲۴ فریم در ثانیه محدود می‌کند (مانند [۲۴،۶۰] رفتار می‌کند).
  • دریچه حرارتی: وقتی عینک گرم می‌شود، نرخ فریم کاهش می‌یابد اما وضوح ثابت می‌ماند. برنامه‌تان را طوری بسازید که بتواند نرخ فریم پایین‌تر یا نامنظم را مدیریت کند، مثلاً با بررسی مُهرهای زمان فریم به‌جای فرض کردن نرخ ثابت.

دسترسی به سخت‌افزار تلفن از فعالیت فرافکنی‌شده

فعالیت فرافکنی‌شده همچنین می‌تواند بااستفاده از 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 استفاده نکنید زیرا اگر فعالیت پیش‌بینی‌شده آخرین مؤلفه راه‌اندازی‌شده باشد، بافت برنامه می‌تواند بافت عینک را به‌اشتباه برگرداند.