Google CameraX，看这篇文章就够了_camerax版本

Camera、Camera2、CameraX？3者之间啥关系？

CameraX、CamX分不清？

今天我们就一起来学习、了解下这些内容，为大家解开迷惑。

这篇文章分下面几点展开：

1） CameraX初认识？

2） Google为啥要推出CameraX？

3）  CameraX基本框架介绍；

4） CameraX的基本使用示例；

5） CameraX、Camx要分清；

一、CameraX初认识？

1） CameraX 是一个 Jetpack 库，最低版本是兼容到Android5.0。好学的同学们，肯定又会问，那Jetpack库又是啥呢？

好了，那我们先来扯下Android Jetpack又是个啥。

在 Jetpack 的官方文档中是这样对它定义的：

Jetpack 是一套组件库，可帮助开发人员遵循最佳实践，减少样板代码并编写可在 Android 版本和设备上一致工作的代码，以便开发人员可以专注于他们关心的代码。

 

上面其实就是2个核心点，第一：Jetpack是一套组件库，注意，是一套，一套那就表示包含很多不同的组件。第二：使用Jetpack,方便我们在不同的android设备和不同的android版本上的适配，简单说，就是适配性强。

下面列表，就是热门和常用的Jetpack库，我们可以看到Camera也在其中，这个Camera*就是我们今天要重点介绍的CameraX。

上面介绍了这么多，大家应该对cameraX应该有个最基础的了解了。CameraX是一个 Jetpack 库。

这个CameraX库呢，然后呢，这个库是针对相机领域的。

二、 Google为啥要推出CameraX？

关于这点，从前面Android Jetpack库的介绍里面，其实我们也基本可以知道原因了。这个库是为了方便我们在各个Android版本和Android设备直接的适配和兼容。

官方的介绍是这样的：

CameraX 是 Jetpack 的新增库。利用该库，可以更轻松地向应用添加相机功能。该库提供了很多兼容性修复程序和解决方法，有助于在众多设备上打造一致的开发者体验。

主要优势表现为以下几点：

1）广泛的设备兼容性

CameraX 支持搭载 Android 5.0（API 级别 21）或更高版本的设备，覆盖现有 Android 设备的 98% 以上。

2）易用性

CameraX 着重于用例，使您可以专注于需要完成的任务，而无需花时间处理不同设备之间的细微差别。CameraX 支持大多数常见的相机用例：

• 预览：在屏幕上查看图片。

• 图片分析：无缝访问缓冲区中的图片以便在算法中使用，例如将其传递到机器学习套件。

• 图片拍摄：保存图片。

• 视频拍摄：保存视频和音频。

3）确保各设备间的一致性

要维持一致的相机行为并非易事。您必须考虑宽高比、屏幕方向、旋转角度、预览大小和图像大小。有了 CameraX，这些基本行为都不用您再费心。

我们设立了一个自动化 CameraX 测试实验室，用于测试搭载了 Android 5.0 及更高版本的一系列设备和这些操作系统版本中的各种相机行为。我们将持续运行这些测试，以找出各种各样的问题并进行修复。

4）新体验

CameraX 有一个可选的 Extensions API，您只需两行代码，便可借助该 API 实现与设备的原生相机应用相同的特性和功能。

扩展程序包含焦外成像（人像）、高动态范围 (HDR)、夜间模式和脸部照片修复功能，所有这些都需要设备支持。

三、 CameraX基本框架介绍

从下图我们可以看到，CameraX是基于Camera2的API进行的封装。

Camera API1，Google已经声明在Android5.0之后的设备上废弃了。所以，CameraX所能支持的功能，也就是Camera2所支持的功能。

目前CameraX为我们提供下下面几个最主要的功能，分别是预览、图片分析、图片拍摄、视频拍摄等。这些都是相机开发里面常用的功能。

四、 CameraX的基本使用示例

1）实现预览

在向应用添加预览时，请使用 PreviewView，这是一种可以剪裁、缩放和旋转以确保正确显示的 View。

当相机处于活动状态时，图片预览会流式传输到 PreviewView 中的 Surface。

使用 PreviewView

如需使用 PreviewView 实现 CameraX 预览，请按以下步骤操作（稍后将对这些步骤进行说明）：

1. （可选）配置 CameraXConfig.Provider。

2. 将 PreviewView 添加到布局。

3. 请求 ProcessCameraProvider。

4. 在创建 View 时，请检查 ProcessCameraProvider。

5. 选择相机并绑定生命周期和用例。

使用 PreviewView 存在一些限制。使用 PreviewView 时，您无法执行以下任何操作：

• 创建 SurfaceTexture，以在 TextureView 和 Preview.SurfaceProvider 上进行设置。

• 从 TextureView 检索 SurfaceTexture，并在 Preview.SurfaceProvider 上对其进行设置。

• 从 SurfaceView 获取 Surface，并在 Preview.SurfaceProvider 上对其进行设置。

如果出现上述任何一种情况，Preview 就会停止将帧流式传输到 PreviewView。

将 PreviewView 添加到布局

以下示例显示了布局中的 PreviewView：

<FrameLayout
    android:id="@+id/container">
        <androidx.camera.view.PreviewView
            android:id="@+id/previewView" />
</FrameLayout>

请求 CameraProvider

以下代码展示了如何请求 CameraProvider：

import androidx.camera.lifecycle.ProcessCameraProvider
import com.google.common.util.concurrent.ListenableFuture
 
public class MainActivity extends AppCompatActivity {
    private ListenableFuture<ProcessCameraProvider> cameraProviderFuture;
 
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        cameraProviderFuture = ProcessCameraProvider.getInstance(this);
    }
}

检查 CameraProvider 可用性

请求 CameraProvider 后，请验证它能否在视图创建后成功初始化。以下代码展示了如何执行此操作：

cameraProviderFuture.addListener(() -> {
    try {
        ProcessCameraProvider cameraProvider = cameraProviderFuture.get();
        bindPreview(cameraProvider);
    } catch (ExecutionException | InterruptedException e) {
        // No errors need to be handled for this Future.
        // This should never be reached.
    }
}, ContextCompat.getMainExecutor(this));

如需查看此示例中使用的 bindPreview 函数的示例，请参阅下一部分中提供的代码。

选择相机并绑定生命周期和用例

创建并确认 CameraProvider 后，请执行以下操作：

1. 创建 Preview。

2. 指定所需的相机 LensFacing 选项。

3. 将所选相机和任意用例绑定到生命周期。

4. 将 Preview 连接到 PreviewView。

以下代码展示了一个示例：

void bindPreview(@NonNull ProcessCameraProvider cameraProvider) {
    Preview preview = new Preview.Builder()
            .build();
 
    CameraSelector cameraSelector = new CameraSelector.Builder()
            .requireLensFacing(CameraSelector.LENS_FACING_BACK)
            .build();
 
    preview.setSurfaceProvider(previewView.getSurfaceProvider());
 
    Camera camera = cameraProvider.bindToLifecycle((LifecycleOwner)this, cameraSelector, preview);
}

请注意，bindToLifecycle() 会返回一个 Camera 对象。如需详细了解如何控制相机输出（如变焦和曝光），请参阅此指南。

现在，您已完成实现相机预览的操作。请构建您的应用，然后确认预览是否出现在您的应用中并能按预期工作。

2） 图像分析

图像分析用例为您的应用提供可供 CPU 访问的图像，您可以对这些图像执行图像处理、计算机视觉或机器学习推断。应用会实现对每个帧运行的 analyze() 方法。

如需在您的应用中使用图像分析，请按以下步骤操作：

• 构建 ImageAnalysis 用例。

• 创建 ImageAnalysis.Analyzer。

• 将分析器设为 ImageAnalysis。

• 将生命周期所有者、相机选择器和 ImageAnalysis 用例绑定到生命周期。

绑定后，CameraX 会立即将图像发送到已注册的分析器。完成分析后，调用 ImageAnalysis.clearAnalyzer() 或解除绑定 ImageAnalysis 用例以停止分析。

构建 ImageAnalysis 用例

ImageAnalysis 可将分析器（图像使用方）连接到 CameraX（图像生成方）。应用可以使用 ImageAnalysis.Builder 来构建 ImageAnalysis 对象。借助 ImageAnalysis.Builder，应用可以进行以下配置：

• 图像输出参数：

• 格式：CameraX 可通过 setOutputImageFormat(int) 支持 YUV_420_888 和 RGBA_8888。默认格式为 YUV_420_888。

• Resolution 和 AspectRatio：您可以设置其中一个参数，但请注意，您不能同时设置这两个值。

• 旋转角度。

• 目标名称：使用该参数进行调试。* 图像流控制：

• 后台执行器

• 图像队列深度（分析器和 CamaraX 之间）

• 背压策略

应用可以设置分辨率或宽高比，但不能同时设置这两个值。确切的输出分辨率取决于应用请求的大小（或宽高比）和硬件功能，并可能与请求的大小或宽高比不同。如需了解分辨率匹配算法，请参阅有关 setTargetResolution() 的文档

应用可以将输出图像像素配置为采用 YUV（默认）或 RGBA 颜色空间。设置 RGBA 输出格式时，CameraX 会在内部将图像从 YUV 颜色空间转换为 RGBA 颜色空间，并将图像位打包到 ImageProxy 第一个平面（其他两个平面未使用）的 ByteBuffer 中，序列如下：

ImageProxy.getPlanes()[0].buffer[0]: alpha
ImageProxy.getPlanes()[0].buffer[1]: red
ImageProxy.getPlanes()[0].buffer[2]: green
ImageProxy.getPlanes()[0].buffer[3]: blue
...

在执行设备无法满足帧速率要求的复杂图像分析时，您可以使用本主题的操作模式部分所述的策略将 CameraX 配置为丢帧。

创建分析器

应用可以通过实现 ImageAnalysis.Analyzer 接口并替换 analyze(ImageProxy image) 来创建分析器。在每个分析器中，应用都会收到一个 ImageProxy，它是 Media.Image 的封装容器。可以使用 ImageProxy.getFormat() 来查询图像格式。该格式使用应用通过 ImageAnalysis.Builder 提供的以下值之一表示：

• 如果应用请求了 OUTPUT_IMAGE_FORMAT_RGBA_8888，则为 ImageFormat.RGBA_8888。

• 如果应用请求了 OUTPUT_IMAGE_FORMAT_YUV_420_888，则为 ImageFormat.YUV_420_888。

如需了解颜色空间配置以及可检索像素字节的位置，请参阅构建 ImageAnalysis 用例。

在分析器中，应用应执行以下操作：

1. 尽快分析给定的帧，最好在给定的帧速率时间限制内进行分析（例如，如果帧速率为 30 fps，则用时应低于 32 毫秒）。如果应用无法足够快地分析帧，请考虑采用一种受支持的丢帧机制。

2. 通过调用 ImageProxy.close() 将 ImageProxy 发布到 CameraX。请注意，您不应调用已封装 Media.Image 的 close 函数 (Media.Image.close())。

应用可以直接使用 ImageProxy 中的已封装 Media.Image。请不要对已封装的图像调用 Media.Image.close()，因为这会破坏 CameraX 中的图像分享机制；请改为使用 ImageProxy.close() 将底层 Media.Image 发布到 CameraX。

针对 ImageAnalysis 配置分析器

创建分析器后，使用 ImageAnalysis.setAnalyzer() 注册该分析器以开始分析。完成分析后，使用 ImageAnalysis.clearAnalyer() 移除已注册的分析器。

您只能配置一个活跃分析器用于分析图像。调用 ImageAnalysis.setAnalyzer() 会替换已注册的分析器（如果已存在该分析器）。应用可以在绑定用例之前或之后随时设置新的分析器。

将 ImageAnalysis 绑定到生命周期

注意：该步骤适用于所有 CameraX 用例。如需详细了解绑定和生命周期自定义，请参阅 CameraX API 模型。

强烈建议您使用 ProcessCameraProvider.bindToLifecycle() 函数将 ImageAnalysis 绑定到现有的 AndroidX 生命周期。请注意，bindToLifecycle() 函数会返回选定的 Camera 设备，该函数可用于微调曝光等高级设置。如需详细了解如何控制相机输出，请参阅此指南。

以下示例结合了上述步骤中的所有操作，将 CameraX ImageAnalysis 和 Preview 用例绑定到了 lifeCycle 所有者：

ImageAnalysis imageAnalysis =
    new ImageAnalysis.Builder()
        // enable the following line if RGBA output is needed.
        //.setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
        .setTargetResolution(new Size(1280, 720))
        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
        .build();
 
imageAnalysis.setAnalyzer(executor, new ImageAnalysis.Analyzer() {
    @Override
    public void analyze(@NonNull ImageProxy imageProxy) {
        int rotationDegrees = imageProxy.getImageInfo().getRotationDegrees();
            // insert your code here.
            ...
            // after done, release the ImageProxy object
            imageProxy.close();
        }
    });
 
cameraProvider.bindToLifecycle((LifecycleOwner) this, cameraSelector, imageAnalysis, preview);

3）图片拍摄

图片拍摄用例旨在拍摄高分辨率的优质照片，不仅提供简单的相机手动控制功能，还提供自动白平衡、自动曝光和自动对焦 (3A) 功能。调用方负责决定如何使用拍摄的照片，具体包括以下选项：

• takePicture(Executor, OnImageCapturedCallback)：此方法为拍摄的图片提供内存缓冲区。

• takePicture(OutputFileOptions, Executor, OnImageSavedCallback)：此方法将拍摄的图片保存到提供的文件位置。

运行 ImageCapture 的可自定义执行程序有两种类型：回调执行程序和 IO 执行程序。

• 回调执行程序是 takePicture 方法的参数。它用于执行用户提供的 OnImageCapturedCallback()。

• 如果调用方选择将图片保存到文件位置，您可以指定执行程序以执行 IO。如需设置 IO 执行程序，请调用 ImageCapture.Builder.setIoExecutor(Executor)。如果执行程序不存在，则默认 CameraX 为任务的内部 IO 执行程序。

实现

提供了拍照所需的基本控制功能。照片是使用闪光灯选项和连续自动对焦拍摄的。

如需缩短照片拍摄的延迟时间，请将 ImageCapture.CaptureMode 设置为 CAPTURE_MODE_MINIMIZE_LATENCY。如需优化照片质量，请将其设置为 CAPTURE_MODE_MAXIMIZE_QUALITY。

以下代码示例展示了如何配置应用以拍摄照片：

ImageCapture imageCapture =
    new ImageCapture.Builder()
        .setTargetRotation(view.getDisplay().getRotation())
        .build();
 
cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, imageCapture, imageAnalysis, preview);

请注意，bindToLifecycle() 会返回一个 Camera 对象。如需详细了解如何控制相机输出（如变焦和曝光），请参阅此指南。

配置好相机后，以下代码会根据用户操作拍照：

public void onClick() {
    ImageCapture.OutputFileOptions outputFileOptions =
            new ImageCapture.OutputFileOptions.Builder(new File(...)).build();
    imageCapture.takePicture(outputFileOptions, cameraExecutor,
        new ImageCapture.OnImageSavedCallback() {
            @Override
            public void onImageSaved(ImageCapture.OutputFileResults outputFileResults) {
                // insert your code here.
            }
            @Override
            public void onError(ImageCaptureException error) {
                // insert your code here.
            }
       }
    );
}

图片拍摄方法完全支持 JPEG 格式。如需查看有关如何将 Media.Image 对象从 YUV_420_888 格式转换为 RGB Bitmap对象的示例代码，请参阅 YuvToRgbConverter.kt。

4）CameraX 视频捕获架构

捕获系统通常会录制视频流和音频流，对其进行压缩，对这两个流进行多路复用，然后将生成的流写入磁盘。

图 1. 视频和音频捕获系统概念图。

在 CameraX 中，用于视频捕获的解决方案是 VideoCapture 用例：

val qualitySelector = QualitySelector.fromOrderedList(
         listOf(Quality.UHD, Quality.FHD, Quality.HD, Quality.SD),
         FallbackStrategy.lowerQualityOrHigherThan(Quality.SD))

val cameraInfo = cameraProvider.availableCameraInfos.filter {
    Camera2CameraInfo
    .from(it)
    .getCameraCharacteristic(CameraCharacteristics.LENS\_FACING) == CameraMetadata.LENS_FACING_BACK
}
 
val supportedQualities = QualitySelector.getSupportedQualities(cameraInfo[0])
val filteredQualities = arrayListOf (Quality.UHD, Quality.FHD, Quality.HD, Quality.SD)
                       .filter { supportedQualities.contains(it) }
 
// Use a simple ListView with the id of simple_quality_list_view
viewBinding.simpleQualityListView.apply {
    adapter = ArrayAdapter(context,
                           android.R.layout.simple_list_item_1,
                           filteredQualities.map { it.qualityToString() })
 
    // Set up the user interaction to manually show or hide the system UI.
    setOnItemClickListener { _, _, position, _ ->
        // Inside View.OnClickListener,
        // convert Quality.* constant to QualitySelector
        val qualitySelector = QualitySelector.from(filteredQualities[position])
 
        // Create a new Recorder/VideoCapture for the new quality
        // and bind to lifecycle
        val recorder = Recorder.Builder()
            .setQualitySelector(qualitySelector).build()
 
         // ...
    }
}
 
// A helper function to translate Quality to a string
fun Quality.qualityToString() : String {
    return when (this) {
        Quality.UHD -> "UHD"
        Quality.FHD -> "FHD"
        Quality.HD -> "HD"
        Quality.SD -> "SD"
        else -> throw IllegalArgumentException()
    }
}

val recorder = Recorder.Builder()
    .setExecutor(cameraExecutor).setQualitySelector(qualitySelector)
    .build()
val videoCapture = VideoCapture.withOutput(recorder)
 
try {
    // Bind use cases to camera
    cameraProvider.bindToLifecycle(
            this, CameraSelector.DEFAULT_BACK_CAMERA, preview, videoCapture)
} catch(exc: Exception) {
    Log.e(TAG, "Use case binding failed", exc)
}

// Create MediaStoreOutputOptions for our recorder
val name = "CameraX-recording-" +
        SimpleDateFormat(FILENAME_FORMAT, Locale.US)
                .format(System.currentTimeMillis()) + ".mp4"
val contentValues = ContentValues().apply {
   put(MediaStore.Video.Media.DISPLAY_NAME, name)
}
val mediaStoreOutput = MediaStoreOutputOptions.Builder(this.contentResolver,
                              MediaStore.Video.Media.EXTERNAL_CONTENT_URI)
                              .setContentValues(contentValues)
                              .build()
 
// 2. Configure Recorder and Start recording to the mediaStoreOutput.
val recording = videoCapture.output
                .prepareRecording(context, mediaStoreOutput)
                .withAudioEnabled()
                .start(ContextCompat.getMainExecutor(this), captureListener)