How do you take a picture with camerax?

Question

I'm still practicing with Kotlin and Android Developing. As far as I understood, Camera class has been deprecated, and Android invites to use Camerax instead, because this high-level class is device-indipendent, and they've made simpler the process of implementing cameras on apps.

I've tried to read the documentation (https://developer.android.com/training/camerax) but it's written so bad I barely understood what they are trying to explain. So I went to read the entire sample code given in the documentation itself (https://github.com/android/camera-samples/tree/main/CameraXBasic). The CameraFragment code is about 500 lines long (ignoring imports and various comments).

Do I really need to write 500 lines of code to simply take a picture? How is this supposed to be considered "simpler than before"?

I mean, Android programming is at the point where I just need to write only 4 lines of code to ask the user to select an Image from his storage and retreive it and show it in an ImageView. Is there a TRUE simple way to take a picture, or do I really need to stop and lose a whole day of work to write all those lines of code?

EDIT: Take this page of the documentation: https://developer.android.com/training/camerax/architecture#kotlin It starts with this piece of code.

val preview = Preview.Builder().build()
val viewFinder: PreviewView = findViewById(R.id.previewView)

// The use case is bound to an Android Lifecycle with the following code
val camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

cameraProvider comes out of nowhere. What is this supposed to be? I've found out it's a ProcessCameraProvider, but how am I supposed to initialize it? Should it be a lateinit var or has it already been initialized somewhere else? Because if I try to write val cameraProvider = ProcessCameraProvider() I get an error, so what am I supposed to do? What is cameraSelector parameter? It's not defined before. I've found out it's the selector for the front or back camera, but how am I supposed to know it reading that page of the documentation? How could have this documentation been released with these kind of lackings? How is someone supposed to learn with ease?

Answer 1

Before you can interact with the device's cameras using CameraX, you need to initialize the library. The initialization process is asynchronous, and involves things like loading information about the device's cameras.

You interact with the device's cameras using a ProcessCameraProvider. It's a Singleton, so the first time you get an instance of if, CameraX performs its initialization.

val cameraProviderFuture: ListenableFuture<ProcessCameraProvider> = ProcessCameraProvider.getInstance(context)

Getting the ProcessCameraProvider singleton returns a Future because it might need to initialize the library asynchronously. The first time you get it, it might take some time (usually well under a second), subsequent calls though will return immediately, as the initialization will have already been performed.

With a ProcessCameraProvider in hand, you can start interacting with the device's cameras. You choose which camera to interact with using a CameraSelector, which wraps a set of filters for the camera you want to use. Typically, if you're just trying to use the main back or front camera, you'd use CameraSelector.DEFAULT_BACK_CAMERA or CameraSelector.DEFAULT_FRONT_CAMERA.

Now that you've defined which camera you'll use, you build the use cases you'll need. For example, you want to take a picture, so you'll use the ImageCapture use case. It allows taking a single capture frame (typically a high quality one) using the camera, and providing it either as a raw buffer, or storing it in a file. To use it, you can configure it if you'd wish, or you can just let CameraX use a default configuration.

val imageCapture = ImageCapture.Builder().build()

In CameraX, a camera's lifecycle is controlled by a LifecycleOwner, meaning that when the LifecycleOwner's lifecycle starts, the camera opens, and when it stops, the camera closes. So you'll need to choose a lifecycle that will control the camera. If you're using an Activity, you'd typically want the camera to start as the Activity starts, and stop when it stops, so you'd use the Activity instance itself as the LifecycleOwner, if you were using a Fragment, you might want to use its view lifecycle (Fragment.getViewLifecycleOwner()).

Lastly, you need to put the pieces of the puzzle together.

processCameraProvider.bindToLifecycle(
   lifecycleOwner,
   cameraSelector,
   imageCapture
)

An app typically includes a viewfinder that displays the camera's preview, so you can use a Preview use case, and bind it with the ImageCapture use case. The Preview use case allows streaming camera frames to a Surface. Since setting up the Surface and correctly drawing the preview on it can be complex, CameraX provides PreviewView, a View that can be used with the Preview use case to display the camera preview. You can check out how to use them here.

// Just like ImageCapture, you can configure the Preview use case if you'd wish.
val preview = Preview.Builder().build()

// Provide PreviewView's Surface to CameraX. The preview will be drawn on it.
val previewView: PreviewView = findViewById(...)
preview.setSurfaceProvider(previewView.surfaceProvider)

// Bind both the Preview and ImageCapture use cases
processCameraProvider.bindToLifecycle(
   lifecycleOwner,
   cameraSelector,
   imageCapture,
   preview
)

Now to actually take a picture, you use on of ImageCapture's takePicture methods. One provides a JPEG raw buffer of the captured image, the other saves it in a file that you provide (make sure you have the necessary storage permissions if you need any).

imageCapture.takePicture(
   ContextCompat.getMainExecutor(context), // Defines where the callbacks are run
   object : ImageCapture.OnImageCapturedCallback() {
      override fun onCaptureSuccess(imageProxy: ImageProxy) {
         val image: Image = imageProxy.image // Do what you want with the image
         imageProxy.close() // Make sure to close the image
      }

      override fun onError(exception: ImageCaptureException) {
         // Handle exception
      }
   }
)

val imageFile = File("somePath/someName.jpg") // You can store the image in the cache for example using `cacheDir.absolutePath` as a path.
val outputFileOptions = ImageCapture.OutputFileOptions
      .Builder(imageFile)
      .build()
takePicture(
   outputFileOptions,
   CameraXExecutors.mainThreadExecutor(),
   object : ImageCapture.OnImageSavedCallback {
      override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                }

      override fun onError(exception: ImageCaptureException) {
      }
   }
)

Do I really need to write 500 lines of code to simply take a picture? How is this supposed to be considered "simpler than before"?

CameraXBasic is not as "basic" as its name might suggest x) It's more of a complete example of CameraX's 3 use cases. Even though the CameraFragment is long, it explains things nicely so that it's more accessible to everyone.

CameraX is "simpler than before", before referring mainly to Camera2, which was a bit more challenging to get started with at least. CameraX provides a more developer-friendly API with its approach to using use cases. It also handles compatibility, which was a big issue before. Ensuring your camera app works reliably on most of the Android devices out there is very challenging.