IssueTracker

CAMERAX VERSION "1.3.0-beta02" DEVICE NAME: Pixel 7A, Android 13

DESCRIPTION:

I understand that the new CameraX (1.3.0-beta02) has the ability for having concurrent camera access on Supported devices but the code samples provided does not show how to record and save from both Cameras at the same time but rather just the preview) I am able to get both previews work but how does one record a video and save with both cameras. I have two PreviewViews, one for the back Camera and one for the front Camera. LogCat ERROR:

FATAL EXCEPTION: main
                                                                                                    Process: com.ngengeapps.cameraxnew, PID: 5171
                                                                                                    java.lang.IllegalStateException: Use case ImageCapture:androidx.camera.core.ImageCapture-21f20c62-ff99-4273-a9cc-26ecd922d092 already bound to a different lifecycle.
                                                                                                    	at androidx.camera.lifecycle.ProcessCameraProvider.bindToLifecycle(ProcessCameraProvider.java:601)
                                                                                                    	at androidx.camera.lifecycle.ProcessCameraProvider.bindToLifecycle(ProcessCameraProvider.java:486)
                                                                                                    	at com.ngengeapps.cameraxnew.MainActivity.startDualCameras(MainActivity.kt:114)
                                                                                                    	at com.ngengeapps.cameraxnew.MainActivity.access$startDualCameras(MainActivity.kt:24)
                                                                                                    	at com.ngengeapps.cameraxnew.MainActivity$startDualCameras$1.invokeSuspend(Unknown Source:14)
                                                                                                    	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
                                                                                                    	at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
                                                                                                    	at android.os.Handler.handleCallback(Handler.java:942)
                                                                                                    	at android.os.Handler.dispatchMessage(Handler.java:99)
                                                                                                    	at android.os.Looper.loopOnce(Looper.java:201)
                                                                                                    	at android.os.Looper.loop(Looper.java:288)
                                                                                                    	at android.app.ActivityThread.main(ActivityThread.java:7918)
                                                                                                    	at java.lang.reflect.Method.invoke(Native Method)
                                                                                                    	at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:548)
                                                                                                    	at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
                                                                                                    	Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [StandaloneCoroutine{Cancelling}@8c12443, Dispatchers.Main.immediate]

CODE FRAGMENTS:

package com.ngengeapps.cameraxnew

import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.provider.MediaStore
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.camera.core.CameraSelector
import androidx.camera.core.ConcurrentCamera.SingleCameraConfig
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageCapture.OutputFileOptions
import androidx.camera.core.ImageCaptureException
import androidx.camera.core.Preview
import androidx.camera.core.UseCaseGroup
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.concurrent.futures.await
import androidx.core.content.ContextCompat
import androidx.lifecycle.lifecycleScope
import com.ngengeapps.cameraxnew.databinding.ActivityMainBinding
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    var primaryCameraSelector: CameraSelector? = null
    var secondaryCameraSelector: CameraSelector? = null

    private val imageCapture: ImageCapture by lazy {
        ImageCapture.Builder()
            .build()
    }


    private val mainBinding: ActivityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }

    private val supportsConcurrentCamera: Boolean by lazy {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_CONCURRENT)
        } else {
            false
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(mainBinding.root)
        if (supportsConcurrentCamera) {
            lifecycleScope.launch {
                startDualCameras()
            }
        } else {
            //Toast.makeText(this, "This phone does not support concurrent cameras", Toast.LENGTH_SHORT).show()
            Log.e("MainActivity", "onCreate: Phone does not support dual camera")
            mainBinding.buttonCapture.isEnabled = false
        }

        mainBinding.buttonCapture.setOnClickListener {
            takePhoto()
        }
    }


    private suspend fun startDualCameras() {
        val cameraProvider = ProcessCameraProvider.getInstance(this).await()

        for (cameraInfos in cameraProvider.availableConcurrentCameraInfos) {
            Log.d("MainActivity", "startDualCameras: ${cameraInfos.first()}")
            primaryCameraSelector = cameraInfos.firstOrNull {
                it.lensFacing == CameraSelector.LENS_FACING_BACK
            }?.cameraSelector

            secondaryCameraSelector = cameraInfos.firstOrNull {
                it.lensFacing == CameraSelector.LENS_FACING_FRONT
            }?.cameraSelector

            if (primaryCameraSelector == null || secondaryCameraSelector == null) {
                // If either a primary or secondary selector wasn't found, reset both
                // to move on to the next list of CameraInfos.
                primaryCameraSelector = null
                secondaryCameraSelector = null
            } else {
                //Conclude the search both primary and secondary cameras are found
                break
            }
        }

        if (primaryCameraSelector == null || secondaryCameraSelector == null) {
            return
        }
        val frontPreview = Preview.Builder()
            .build()
        val backPreview = Preview
            .Builder()
            .build()

        val primary = SingleCameraConfig(
            primaryCameraSelector!!,
            UseCaseGroup.Builder()
                .addUseCase(backPreview)
                .addUseCase(imageCapture)
                .build(),
            this
        )
        backPreview.setSurfaceProvider(mainBinding.backPreviewView.surfaceProvider)
        val secondary = SingleCameraConfig(
            secondaryCameraSelector!!,
            UseCaseGroup.Builder().addUseCase(frontPreview)
                .addUseCase(imageCapture)
                .build(), this
        )
        frontPreview.setSurfaceProvider(mainBinding.frontPreviewView.surfaceProvider)
        val concurrentCamera = cameraProvider.bindToLifecycle(listOf(primary, secondary))
    }

    private fun takePhoto() {
        val outputFileOptions = OutputFileOptions.Builder(
            contentResolver,
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
            Utils.createContentValues()
        ).build()
        imageCapture.takePicture(outputFileOptions, ContextCompat.getMainExecutor(this),
            object : ImageCapture.OnImageSavedCallback {
                override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                    runOnUiThread {
                        Toast.makeText(
                            this@MainActivity,
                            "Captured image successfully with Uri ${outputFileResults.savedUri}",
                            Toast.LENGTH_SHORT
                        ).show()
                    }
                }

                override fun onError(exception: ImageCaptureException) {
                    runOnUiThread {
                        Toast.makeText(
                            this@MainActivity,
                            "Error capturing photo",
                            Toast.LENGTH_SHORT
                        ).show()
                    }
                }

            })

    }
}