androidx.camera.core

Denotes that the annotated method uses the experimental getImage method.

Denotes that the annotated API is designed to be used with a lens facing that its behavior hasn't been verified thoroughly.

Denotes that the annotated API is designed to be experimental for MirrorMode

Indicates that the annotated API uses the experimental RetryPolicy feature for CameraX initialization.

Denotes that the methods on use cases and use case builders are experimental and may change in a future release

Denotes that the annotated API uses the experimental zero-shutter lag capture mode in ImageCapture and related querying function in CameraInfo.

The camera interface is used to control the flow of data to use cases, control the camera via the CameraControl, and publish the state of the camera via CameraInfo.

The CameraControl provides various asynchronous operations like zoom, focus and metering which affects output of all UseCases currently bound to that camera.

An interface for filtering cameras.

An interface for retrieving camera information.

A CameraProvider provides basic access to a set of cameras such as querying for camera existence or information.

An interface which can be implemented to provide the configuration for CameraX.

An interface which contains the camera exposure related information.

Extendable builders are used to add externally defined options that can be passed to the implementation being built.

Interface for analyzing images.

Listener containing callbacks for image file I/O events.

Interface to do the application changes required for screen flash operations.

Callback listener for discovering when the application has completed its changes for a screen flash image capture.

ImageCaptureCapabilities is used to query ImageCapture use case capabilities on the device.

Metadata for an image.

Post-processing effect for images.

A request for processing one or multiple ImageProxy.

A response for returning a processed ImageProxy to CameraX.

An image proxy which has a similar interface as android.media.Image.

A plane proxy which has an analogous interface as android.media.Image.Plane.

A interface implemented by the application to provide a Surface for Preview.

PreviewCapabilities is used to query Preview use case capabilities on the device.

Defines a strategy for retrying upon initialization failures of the CameraProvider.

Provides insights into the current execution state of the camera initialization process.

A Surface for drawing processed camera frames.

Interface to implement a GPU-based post-processing effect.

Listener that receives updates of the TransformationInfo associated with the SurfaceRequest.

An interface which contains the zoom related information from a camera.

The aspect ratio of the use case.

An effect for one or multiple camera outputs.

A set of requirements and priorities used to select a camera or return a filtered set of cameras.

Builder for a CameraSelector.

Represents the different states the camera can be in.

Error that the camera has encountered.

A configuration for adding implementation and user-specific behavior to CameraX.

A builder for generating CameraXConfig objects.

Composition settings for dual concurrent camera.

A builder for CompositionSettings instances.

Concurrent camera is a new feature introduced from Android 11, which supports simultaneous streaming of camera devices, for example, it allows a device to have both the front and back cameras operating at the same time.

Configuration for a single camera in concurrent camera mode, including CameraSelector, LifecycleOwner and UseCaseGroup.

A MeteringPointFactory that can convert a View (x, y) into a MeteringPoint which can then be used to construct a FocusMeteringAction to start a focus and metering action.

A representation of the dynamic range of an image.

A configuration used to trigger a focus and/or metering action.

The builder used to create the FocusMeteringAction.

Result of the startFocusAndMetering.

A use case providing CPU accessible images for an app to perform image analysis on.

Builder for a ImageAnalysis.

A use case for taking a picture.

Builder for an ImageCapture.

Holder class for metadata that will be saved with captured images.

Callback for image capture events.

Options for saving newly captured image.

Builder class for OutputFileOptions.

Info about the saved image file.

An immutable representation of the estimated duration an image capture will take capturing and processing the current scene according to the scene's lighting condition and/or camera configuration.

Defines the valid states for Low Light Boost, as returned by getLowLightBoostState.

A MeteringPoint is used to specify a region which can then be converted to sensor coordinate system for focus and metering purpose.

A factory to create a MeteringPoint.

The mirror mode.

A use case that provides a camera preview stream for displaying on-screen.

Builder for a Preview.

A ResolutionInfo allows the application to know the resolution information of a specific use case.

A builder class for customizing RetryPolicy behavior.

Represents the outcome of a RetryPolicy decision.

A builder class for creating and customizing RetryConfig objects.

A MeteringPointFactory that can create MeteringPoint by surface oriented x, y on an area defined by (0, 0) - (width, height).

Events of the Surface retrieved from getSurface.

A completable, single-use request of a Surface.

Result of providing a surface to a SurfaceRequest via provideSurface.

Transformation associated the preview output.

The camera flash torch state.

The use case which all other use cases are built on top of.

Represents a collection of UseCase.

A builder for generating UseCaseGroup.

The field of view of one or many UseCases.

Builder for ViewPort.

The camera flash state values represent the state of the physical flash unit of a camera.

Types of errors the camera can encounter.

States the camera can be in.

An exception representing a failure that the operation is canceled which might be caused by a new value is set or camera is closed.

An exception thrown when unable to retrieve information about a camera.

CameraUnavailableException is thrown when a camera device could not be queried or opened or if the connection to an opened camera device is no longer valid.

An exception thrown to indicate an error has occurred during image capture or while saving the captured image.

InitializationException is thrown when a failure occurs during an initialization process.

Exception throw when effects post-processing fails.