ProcessCameraProvider


public final class ProcessCameraProvider implements CameraProvider


A singleton which can be used to bind the lifecycle of cameras to any LifecycleOwner within an application's process.

Only a single process camera provider can exist within a process, and it can be retrieved with getInstance.

Heavyweight resources, such as open and running camera devices, will be scoped to the lifecycle provided to bindToLifecycle. Other lightweight resources, such as static camera characteristics, may be retrieved and cached upon first retrieval of this provider with getInstance, and will persist for the lifetime of the process.

This is the standard provider for applications to use.

Summary

Nested types

Public methods

final @NonNull ConcurrentCamera

Binds list of SingleCameraConfigs to LifecycleOwner.

final @NonNull Camera
@ExperimentalSessionConfig
bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    @NonNull SessionConfig sessionConfig
)

Binds a SessionConfig to a LifecycleOwner.

final @NonNull Camera
@MainThread
bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    @NonNull UseCaseGroup useCaseGroup
)

Binds a UseCaseGroup to a LifecycleOwner.

final @NonNull Camera
@MainThread
bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    UseCase... useCases
)

Binds the collection of UseCase to a LifecycleOwner.

static final void

Perform one-time configuration of the ProcessCameraProvider singleton with the given CameraXConfig.

@NonNull List<@NonNull CameraInfo>

The CameraInfo instances of the available cameras.

@NonNull List<@NonNull List<@NonNull CameraInfo>>

Returns list of CameraInfo instances of the available concurrent cameras.

@NonNull CameraInfo

Returns the CameraInfo instance of the camera resulted from the specified CameraSelector.

static final @NonNull ListenableFuture<@NonNull ProcessCameraProvider>

Retrieves the ProcessCameraProvider associated with the current process.

boolean
hasCamera(@NonNull CameraSelector cameraSelector)

Checks whether this provider supports at least one camera that meets the requirements from a CameraSelector.

final boolean

Returns true if the SessionConfig is bound to a lifecycle.

final boolean

Returns true if this UseCase is bound to a lifecycle or included in a bound SessionConfig.

boolean

Returns whether there is a ConcurrentCamera bound.

final @NonNull ListenableFuture<@NonNull Void>

Allows shutting down this ProcessCameraProvider instance so a new instance can be retrieved by getInstance.

final void

Unbinds the SessionConfig from the lifecycle provider.

final void
@MainThread
unbind(UseCase... useCases)

Unbinds all specified use cases from the lifecycle provider.

final void

Unbinds all use cases from the lifecycle provider and removes them from CameraX.

Public methods

bindToLifecycle

Added in 1.3.0
@MainThread
public final @NonNull ConcurrentCamera bindToLifecycle(
    @NonNull List<ConcurrentCamera.SingleCameraConfig> singleCameraConfigs
)

Binds list of SingleCameraConfigs to LifecycleOwner.

The concurrent camera is only supporting two cameras currently. If the input list of SingleCameraConfigs have less or more than two SingleCameraConfigs, IllegalArgumentException will be thrown. If cameras are already used by other UseCases, UnsupportedOperationException will be thrown.

A logical camera is a grouping of two or more of those physical cameras. See Multi-camera API

If we want to open concurrent logical cameras, which are one front camera and one back camera, the device needs to support PackageManager.FEATURE_CAMERA_CONCURRENT. To set up concurrent logical camera, call availableConcurrentCameraInfos to get the list of available combinations of concurrent cameras. Each sub-list contains the CameraInfos for a combination of cameras that can be operated concurrently. Each logical camera can have its own UseCases and LifecycleOwner. See {@docRoot}training/camerax/architecture#lifecycles

If the concurrent logical cameras are binding the same preview and video capture use cases, the concurrent cameras video recording will be supported. The concurrent camera preview stream will be shared with video capture and record the concurrent cameras streams as a composited stream. The CompositionSettings can be used to configure the position of each camera stream and different layouts can be built. See CompositionSettings for more details.

If we want to open concurrent physical cameras, which are two front cameras or two back cameras, the device needs to support physical cameras and the capability could be checked via CameraInfo.isLogicalMultiCameraSupported. Each physical cameras can have its own UseCases but needs to have the same LifecycleOwner, otherwise IllegalArgumentException will be thrown.

If we want to open one physical camera, for example ultra wide, we just need to set physical camera id in CameraSelector and bind to lifecycle. All CameraX features will work normally when only a single physical camera is used.

If we want to open multiple physical cameras, we need to have multiple CameraSelectors, each in one SingleCameraConfig and set physical camera id, then bind to lifecycle with the SingleCameraConfigs. Internally each physical camera id will be set on UseCase, for example, Preview and call android.hardware.camera2.params.OutputConfiguration.setPhysicalCameraId.

Currently only two physical cameras for the same logical camera id are allowed and the device needs to support physical cameras by checking CameraInfo.isLogicalMultiCameraSupported. In addition, there is no guarantee or API to query whether the device supports multiple physical camera opening or not. Internally the library checks android.hardware.camera2.CameraDevice.isSessionConfigurationSupported, if the device does not support the multiple physical camera configuration, IllegalArgumentException will be thrown.

Parameters
@NonNull List<ConcurrentCamera.SingleCameraConfig> singleCameraConfigs

Input list of SingleCameraConfigs.

Returns
@NonNull ConcurrentCamera

Output ConcurrentCamera instance.

Throws
kotlin.IllegalArgumentException

If less or more than two camera configs are provided.

kotlin.UnsupportedOperationException

If device is not supporting concurrent camera or cameras are already used by other UseCases.

bindToLifecycle

Added in 1.5.0-beta02
@ExperimentalSessionConfig
public final @NonNull Camera bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    @NonNull SessionConfig sessionConfig
)

Binds a SessionConfig to a LifecycleOwner.

A SessionConfig encapsulates the configuration required for a camera session. This includes:

The state of the lifecycle will determine when the cameras are open, started, stopped and closed. When started, the use cases contained in the given SessionConfig receive camera data and the parameters of SessionConfig are used for configuring the camera including common field of view, effects and the session parameters.

Binding to a lifecycleOwner in state currently in Lifecycle.State.STARTED or greater will also initialize and start data capture. If the camera was already running this may cause a new initialization to occur temporarily stopping data from the camera before restarting it.

Updates the SessionConfig for a given LifecycleOwner by invoking bindToLifecycle again with the new SessionConfig. There is no need to call unbind or unbindAll; the previous SessionConfig and its associated UseCases will be implicitly unbound. This behavior also applies when rebinding to the same LifecycleOwner with a different CameraSelector, such as when switching the camera's lens facing.

Important Restrictions:

Violating these restrictions will result in an IllegalStateException.

The Camera returned is determined by the given camera selector, plus other internal requirements, possibly from use case configurations. The camera returned from bindToLifecycle may differ from the camera determined solely by a camera selector. If the camera selector can't resolve a valid camera under the requirements, an IllegalArgumentException will be thrown.

The following code example shows various aspects of binding a session config.

import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageCapture
import androidx.camera.core.Preview
import androidx.camera.core.SessionConfig

val preview =
    Preview.Builder().build().also { it.surfaceProvider = previewView.surfaceProvider }
val imageCapture = ImageCapture.Builder().build()
val sessionConfig =
    SessionConfig(
        useCases = listOf(preview, imageCapture),
        viewPort = previewView.getViewPort(preview.getTargetRotation()),
        effects = listOf(effect1),
    )
// Starts the camera with the given effect and viewPort when the lifecycleOwner is started.
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    sessionConfig,
)

// To apply a different effect, unbind the previous SessionConfig and bind the new SessionConfig
// with the new effect.
val sessionConfigNewEffect =
    SessionConfig(
        useCases = listOf(preview, imageCapture),
        viewPort = previewView.getViewPort(preview.getTargetRotation()),
        effects = listOf(effect2),
    )
// Make sures to unbind the previous sessionConfig before binding the new one
cameraProvider.unbind(sessionConfig)
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    sessionConfigNewEffect,
)

The following code snippet demonstrates binding a session config with feature groups.

import androidx.camera.core.CameraSelector
import androidx.camera.core.SessionConfig
import androidx.camera.core.featuregroup.GroupableFeature.Companion.FPS_60
import androidx.camera.core.featuregroup.GroupableFeature.Companion.HDR_HLG10
import androidx.camera.core.featuregroup.GroupableFeature.Companion.PREVIEW_STABILIZATION

// Starts the camera with feature groups configured.
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    // HDR is mandatory in this camera configuration and an exception will be thrown if it's not
    // supported. 60 FPS and preview stabilization are optional and used if they are also
    // supported, with the 60 FPS having higher priority over preview stabilization.
    SessionConfig(
            useCases = useCases,
            requiredFeatureGroup = setOf(HDR_HLG10),
            preferredFeatureGroup = listOf(FPS_60, PREVIEW_STABILIZATION),
        )
        .apply {
            setFeatureSelectionListener { features ->
                Log.d(
                    "TAG",
                    "Features selected as per priority and device capabilities: $features",
                )

                // Update app UI based on the selected features if required
            }
        },
)
Throws
kotlin.UnsupportedOperationException

If the camera is configured in concurrent mode. For example, if a list of SingleCameraConfigs was bound to the lifecycle already.

kotlin.IllegalStateException

if either of the following conditions is met:

bindToLifecycle

Added in 1.0.0
@MainThread
public final @NonNull Camera bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    @NonNull UseCaseGroup useCaseGroup
)

Binds a UseCaseGroup to a LifecycleOwner.

Similar to bindToLifecycle, with the addition that the bound collection of UseCase share parameters defined by UseCaseGroup such as consistent camera sensor rect across all UseCases.

If one UseCase is in multiple UseCaseGroups, it will be linked to the UseCaseGroup in the latest bindToLifecycle call.

Throws
kotlin.UnsupportedOperationException

If the camera is configured in concurrent mode.

bindToLifecycle

Added in 1.0.0
@MainThread
public final @NonNull Camera bindToLifecycle(
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull CameraSelector cameraSelector,
    UseCase... useCases
)

Binds the collection of UseCase to a LifecycleOwner.

The state of the lifecycle will determine when the cameras are open, started, stopped and closed. When started, the use cases receive camera data.

Binding to a lifecycleOwner in state currently in Lifecycle.State.STARTED or greater will also initialize and start data capture. If the camera was already running this may cause a new initialization to occur temporarily stopping data from the camera before restarting it.

Multiple use cases can be bound via adding them all to a single bindToLifecycle call, or by using multiple bindToLifecycle calls. Using a single call that includes all the use cases helps to set up a camera session correctly for all uses cases, such as by allowing determination of resolutions depending on all the use cases bound being bound. If the use cases are bound separately, it will find the supported resolution with the priority depending on the binding sequence. If the use cases are bound with a single call, it will find the supported resolution with the priority in sequence of ImageCapture, Preview and then ImageAnalysis. The resolutions that can be supported depends on the camera device hardware level that there are some default guaranteed resolutions listed in android.hardware.camera2.CameraDevice.createCaptureSession.

Currently up to 3 use cases may be bound to a Lifecycle at any time. Exceeding capability of target camera device will throw an IllegalArgumentException.

A UseCase should only be bound to a single lifecycle and camera selector a time. Attempting to bind a use case to a lifecycle when it is already bound to another lifecycle is an error, and the use case binding will not change. Attempting to bind the same use case to multiple camera selectors is also an error and will not change the binding.

Binding different use cases to the same lifecycle with different camera selectors that resolve to distinct cameras is an error, resulting in an exception.

The Camera returned is determined by the given camera selector, plus other internal requirements, possibly from use case configurations. The camera returned from bindToLifecycle may differ from the camera determined solely by a camera selector. If the camera selector can't resolve a valid camera under the requirements, an IllegalArgumentException will be thrown.

Only UseCase bound to latest active Lifecycle can keep alive. UseCase bound to other Lifecycle will be stopped.

Parameters
@NonNull LifecycleOwner lifecycleOwner

The lifecycleOwner which controls the lifecycle transitions of the use cases.

@NonNull CameraSelector cameraSelector

The camera selector which determines the camera to use for set of use cases.

UseCase... useCases

The use cases to bind to a lifecycle.

Returns
@NonNull Camera

The Camera instance which is determined by the camera selector and internal requirements.

Throws
kotlin.IllegalStateException

If the use case has already been bound to another lifecycle or method is not called on main thread.

kotlin.IllegalArgumentException

If the provided camera selector is unable to resolve a camera to be used for the given use cases.

kotlin.UnsupportedOperationException

If the camera is configured in concurrent mode.

configureInstance