CameraController

IMAGE_ANALYSIS

public static final int IMAGE_ANALYSIS

Bitmask option to enable ImageAnalysis. In setEnabledUseCases(int), if (enabledUseCases & IMAGE_ANALYSIS) != 0, then controller will enable image analysis features.

Constant Value: 2 (0x00000002)

IMAGE_CAPTURE

public static final int IMAGE_CAPTURE

Bitmask option to enable ImageCapture. In setEnabledUseCases(int), if (enabledUseCases & IMAGE_CAPTURE) != 0, then controller will enable image capture features.

Constant Value: 1 (0x00000001)

VIDEO_CAPTURE

public static final int VIDEO_CAPTURE

Bitmask option to enable video capture use case. In setEnabledUseCases(int), if (enabledUseCases & VIDEO_CAPTURE) != 0, then controller will enable video capture features.

Constant Value: 4 (0x00000004)

clearImageAnalysisAnalyzer

public void clearImageAnalysisAnalyzer ()

Removes a previously set analyzer.

This will stop data from streaming to the ImageAnalysis.

enableTorch

public ListenableFuture<Void> enableTorch (boolean torchEnabled)

Enable the torch or disable the torch.

No-ops if the camera is not ready. The ListenableFuture completes successfully in this case.

getCameraInfo

public CameraInfo getCameraInfo ()

Gets the CameraInfo of the currently attached camera.

getCameraSelector

public CameraSelector getCameraSelector ()

Gets the CameraSelector.

The default value isCameraSelector.DEFAULT_BACK_CAMERA.

getImageAnalysisBackpressureStrategy

public int getImageAnalysisBackpressureStrategy ()

Returns the mode with which images are acquired.

If not set, it defaults to ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST.

getImageAnalysisImageQueueDepth

public int getImageAnalysisImageQueueDepth ()

Gets the image queue depth of ImageAnalysis.

getImageCaptureFlashMode

public int getImageCaptureFlashMode ()

Gets the flash mode for ImageCapture.

getInitializationFuture

public ListenableFuture<Void> getInitializationFuture ()

Gets a ListenableFuture that completes when camera initialization completes.

This future may fail with an InitializationException and associated cause that can be retrieved by {@link Throwable#getCause()). The cause will be a {@link CameraUnavailableException} if it fails to access any camera during initialization.

In the rare case that the future fails with {@link CameraUnavailableException}, the camera will become unusable. This could happen for various reasons, for example hardware failure or the camera being held by another process. If the failure is temporary, killing and restarting the app might fix the issue.

The initialization also try to bind use cases before completing the {@link ListenableFuture}. The {@link ListenableFuture} will complete successfully regardless of whether the use cases are ready to be bound, e.g. it will complete successfully even if the controller is not set on a {@link PreviewView}. However the {@link ListenableFuture} will fail if the enabled use cases are not supported by the current camera.

getTorchState

public LiveData<Integer> getTorchState ()

Returns a LiveData of current TorchState.

The torch can be turned on and off via enableTorch(boolean) which will trigger the change event to the returned LiveData.

getZoomState

public LiveData<ZoomState> getZoomState ()

Returns a LiveData of ZoomState.

The LiveData will be updated whenever the set zoom state has been changed. This can occur when the application updates the zoom via setZoomRatio(float) or setLinearZoom(float). The zoom state can also change anytime a camera starts up, for example when setCameraSelector(CameraSelector) is called.

hasCamera

public boolean hasCamera (CameraSelector cameraSelector)

Checks if the given CameraSelector can be resolved to a camera.

Use this method to check if the device has the given camera.

Only call this method after camera is initialized. e.g. after the ListenableFuture from getInitializationFuture() is finished. Calling it prematurely throws IllegalStateException. Example:

 controller.getInitializationFuture().addListener(() -> {
     if (controller.hasCamera(cameraSelector)) {
         controller.setCameraSelector(cameraSelector);
     } else {
         // Update UI if the camera is not available.
     }
     // Attach PreviewView after we know the camera is available.
     previewView.setController(controller);
 }, ContextCompat.getMainExecutor(requireContext()));
 

isImageAnalysisEnabled

public boolean isImageAnalysisEnabled ()

Checks if ImageAnalysis is enabled.

isImageCaptureEnabled

public boolean isImageCaptureEnabled ()

Checks if ImageCapture is enabled.

ImageCapture is enabled by default. It has to be enabled before takePicture(ImageCapture.OutputFileOptions, Executor, ImageCapture.OnImageSavedCallback) can be called.

isPinchToZoomEnabled

public boolean isPinchToZoomEnabled ()

Returns whether pinch-to-zoom is enabled.

By default pinch-to-zoom is enabled.

isRecording

public boolean isRecording ()

Returns whether there is a in progress video recording.

isTapToFocusEnabled

public boolean isTapToFocusEnabled ()

Returns whether tap-to-focus is enabled.

By default tap-to-focus is enabled.

isVideoCaptureEnabled

public boolean isVideoCaptureEnabled ()

Checks if video capture is enabled.

Video capture is disabled by default. It has to be enabled before startRecording(OutputFileOptions, Executor, OnVideoSavedCallback) can be called.

setCameraSelector

public void setCameraSelector (CameraSelector cameraSelector)

Sets the CameraSelector.

Calling this method with a CameraSelector that resolves to a different camera will change the camera being used by the controller. If camera initialization is complete, the controller will immediately rebind use cases with the new CameraSelector; otherwise, the new CameraSelector will be used when the camera becomes ready.

The default value is CameraSelector.DEFAULT_BACK_CAMERA.

setEnabledUseCases

public void setEnabledUseCases (int enabledUseCases)

Enables or disables use cases.

Use cases need to be enabled before they can be used. By default, IMAGE_CAPTURE and IMAGE_ANALYSIS are enabled, and VIDEO_CAPTURE is disabled. This is necessary because VIDEO_CAPTURE is an experimental feature that might not work with other use cases, especially on lower end devices. When that happens, this method will fail with an IllegalStateException.

To make sure VIDEO_CAPTURE works, IMAGE_CAPTURE and IMAGE_ANALYSIS needs to be disabled when enabling VIDEO_CAPTURE. For example:

 // By default, image capture is enabled. Taking picture works.
 controller.takePicture(...);

 // Switch to video capture to shoot video.
 controller.setEnabledUseCases(VIDEO_CAPTURE);
 controller.startRecording(...);
 controller.stopRecording(...);

 // Switch back to image capture and image analysis before taking another picture.
 controller.setEnabledUseCases(IMAGE_CAPTURE|IMAGE_ANALYSIS);
 controller.takePicture(...);

 

setImageAnalysisAnalyzer

public void setImageAnalysisAnalyzer (Executor executor, 
                ImageAnalysis.Analyzer analyzer)

Sets an analyzer to receive and analyze images.

Applications can process or copy the image by implementing the ImageAnalysis.Analyzer. The image needs to be closed by calling ImageProxy.close() when the analyzing is done.

Setting an analyzer function replaces any previous analyzer. Only one analyzer can be set at any time.

setImageAnalysisBackpressureStrategy

public void setImageAnalysisBackpressureStrategy (int strategy)

Sets the backpressure strategy to apply to the image producer to deal with scenarios where images may be produced faster than they can be analyzed.

The available values are ImageAnalysis.STRATEGY_BLOCK_PRODUCER and ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. If not set, the backpressure strategy will default to ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST.

setImageAnalysisImageQueueDepth

public void setImageAnalysisImageQueueDepth (int depth)

Sets the image queue depth of ImageAnalysis.

This sets the number of images available in parallel to ImageAnalysis.Analyzer . The value is only used if the backpressure strategy is ImageAnalysis.STRATEGY_BLOCK_PRODUCER.

setImageCaptureFlashMode

public void setImageCaptureFlashMode (int flashMode)

Sets the flash mode for ImageCapture.

If not set, the flash mode will default to ImageCapture.FLASH_MODE_OFF.

setLinearZoom

public ListenableFuture<Void> setLinearZoom (float linearZoom)

Sets current zoom by a linear zoom value ranging from 0f to 1.0f. LinearZoom 0f represents the minimum zoom while linearZoom 1.0f represents the maximum zoom. The advantage of linearZoom is that it ensures the field of view (FOV) varies linearly with the linearZoom value, for use with slider UI elements (while setZoomRatio(float) works well for pinch-zoom gestures).

No-ops if the camera is not ready. The ListenableFuture completes successfully in this case.

setPinchToZoomEnabled

public void setPinchToZoomEnabled (boolean enabled)

Enables/disables pinch-to-zoom.

Once enabled, end user can pinch on the PreviewView to zoom in/out if the bound camera supports zooming.

setTapToFocusEnabled

public void setTapToFocusEnabled (boolean enabled)

Enables/disables tap-to-focus.

Once enabled, end user can tap on the PreviewView to set focus point.

setZoomRatio

public ListenableFuture<Void> setZoomRatio (float zoomRatio)

Sets current zoom by ratio.

Valid zoom values range from ZoomState.getMinZoomRatio() to ZoomState.getMaxZoomRatio().

No-ops if the camera is not ready. The ListenableFuture completes successfully in this case.

startRecording

public void startRecording (OutputFileOptions outputFileOptions, 
                Executor executor, 
                OnVideoSavedCallback callback)

Takes a video and calls the OnVideoSavedCallback when done.

stopRecording

public void stopRecording ()

Stops a in progress video recording.

takePicture

public void takePicture (ImageCapture.OutputFileOptions outputFileOptions, 
                Executor executor, 
                ImageCapture.OnImageSavedCallback imageSavedCallback)

Captures a new still image and saves to a file along with application specified metadata.

The callback will be called only once for every invocation of this method.

By default, the saved image is mirrored to match the output of the preview if front camera is used. To override this behavior, the app needs to explicitly set the flag to false using ImageCapture.Metadata.setReversedHorizontal(boolean) and OutputFileOptions.Builder.setMetadata(Metadata).

takePicture

public void takePicture (Executor executor, 
                ImageCapture.OnImageCapturedCallback callback)

Captures a new still image for in memory access.

The listener is responsible for calling ImageProxy.close() on the returned image.