Android Camera1-Camera2-CameraView和CameraX使用基础知识Camera1使用Camera2使用设计框架开发流程CameraViewCameraX

59 阅读 0 评论 39 点赞

我是靠谱客的博主风中毛衣，最近开发中收集的这篇文章主要介绍Android Camera1-Camera2-CameraView和CameraX使用基础知识Camera1使用Camera2使用设计框架开发流程CameraViewCameraX，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

基础知识

Android Framework提供Camera API来实现拍照与录制视频的功能，目前Android有三类API，

Camera
此类是用于控制设备相机的旧版 API，现已弃用，在Android5.0以下使用
Camera2
此软件包是用于控制设备相机的主要 API，Android5.0以上使用
CameraX
基于Camera 2 API封装，简化了开发流程，并增加生命周期控制

术语

ISO(感光度)
CMOS（或胶卷）对光线的敏感程度，用ISO100的胶卷，相机2秒可以正确曝光的话，同样光线条件下用ISO200的胶卷只需要1秒即可，用ISO400则只要0.5秒。
常见的标准：ISO100，ISO200，ISO400
曝光时间
曝光时间是为了将光投射到相机感光片上，相机快门所要打开至关闭的时间
光圈
用来控制光线透过镜头，进入相机内感光面光量的装置
焦距
指的是平行的光线穿过镜片后，所汇集的焦点至镜片间之距离。
数值越小，代表可以拍摄的角度越广，数值越大，代表可以拍摄的角度越小
景深
拍摄时，当镜头聚集于某个被摄体时，这个被摄体就能在相机上结成清晰影像。使被摄体产生较为清晰影像的纵深的范围叫景深
测光
测光模式：中央平均测光(average metering)、中央局部测光、点测光(spot metering)、多点测光、评价测光
自动曝光(Auto Exposure)
相机根据光线条件自动来调整曝光时间等来确定曝光量
对焦
对焦模式：自动对焦 AE(Auto Focus)、手动对焦 MF(Manual Focus)
自动对焦分为对比度对焦(contrast)、相位对焦(PDAF: Phase Detection Auto Focus)和混合对焦(hybrid)
闪光灯(Flashlight)
通过闪光灯打闪照亮物体来达到拍出清晰图片的目的
ScreenFlash
通过屏幕打闪，照亮周围物体，拍出高清图片
高动态范围图像(HDR)
HDR全称是High-Dynamic Range，即高动态范围图像技术。在拍照过程中开启HDR，可以让原先的暗场景变得更明亮更通透。
零延时拍照(ZSD)
为了减少拍照延时,让拍照&回显瞬间完成的一种技术
连拍(ContinuousShot)
通过节约数据传输时间来捕捉摄影时机
预览大小(PreviewSize)
相机预览图片的大小
拍照大小(PictureSize)
拍照生成图片的大小
自动白平衡(Auto white balance)
AWB(Auto white balance)，自动白平衡是相机的默认设置，相机中有一结构复杂的矩形图，它可决定画面中的白平衡基准点，以此来达到白平衡调校
对比度
图像最亮和最暗之间的区域之间的比率，比值越大，从黑到白的渐变层次就越多，从而色彩表现越丰富
饱和度
指色彩的鲜艳程度
锐度
是反映图像平面清晰度和图像边缘锐利程度的一个指标

相机功能

Android 支持多种相机功能，您可使用相机应用控制这些功能，如图片格式、闪光模式、对焦设置等等。
通过Camera.Parameters可以设置大部分的功能，下面介绍几个重要功能：

区域测光和对焦
人脸检测
延时视频

区域测光和对焦

从 Android 4.0（API 级别 14）开始，通过Camera.Parameters来确定对焦或亮度设置的区域，然后进行拍照或者录像

人脸检测

这个和真正的人脸识别是不一样的，这里仅仅是检测人脸。
通过照片分析，检测照片中是否包含人脸，使用人脸识别技术来识别人脸并计算照片设置

延时视频

延时视频功能允许用户将间隔几秒钟或几分钟拍摄的图片串联起来，创建视频剪辑。使用MediaRecorder录制时间流逝片段的图像。

其他重要功能API：

功能API

Camera1使用

流程：

检测设备摄像头，打开相机
创建预览画面，显示实时预览画面
设置相机参数，进行拍照监听
监听中，保存图片资源或者直接操作原始数据
释放相机资源

权限声明

<uses-feature
        android:name="android.hardware.camera"
        android:required="true" />

<uses-permission android:name="android.permission.CAMERA" />

相机必须声明CAMERA权限，在Android6.0上，你还需要在代码中动态申请权限

ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
                    REQUEST_CAMERA_PERMISSION);

开发流程

下图是一个开发流程的导览：

打开相机

Camera.open()

该方法的系统源码实现

public static Camera open() {
    int numberOfCameras = getNumberOfCameras();
    CameraInfo cameraInfo = new CameraInfo();
    for (int i = 0; i < numberOfCameras; i++) {
        getCameraInfo(i, cameraInfo);
        if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
            return new Camera(i);
        }
    }
    return null;
}

这里会检查可用的摄像头，默认使用的CameraInfo.CAMERA_FACING_BACK后置摄像头

创建预览画面

这里使用的是SurfaceView

private SurfaceView mSurfaceView;
private SurfaceHolder mSurfaceHolder;
...
mSurfaceHolder = mSurfaceView.getHolder();
mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        ...
        startPreview();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        releaseCamera();
    }
});
...
private void startPreview() {
    try {
        //设置实时预览
        mCamera.setPreviewDisplay(mSurfaceHolder);
        //Orientation
        setCameraDisplayOrientation();
        //开始预览
        mCamera.startPreview();

        startFaceDetect();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

设置预览的时候，可以设置setPreviewCallback监听预览数据的回调

void onPreviewFrame(byte[] data, Camera camera);

设置相机参数

设置相机参数后，需要重新启动预览，这边在初始化的时候，已经设置好了。

private void initParameters(final Camera camera) {
    mParameters = camera.getParameters();
    mParameters.setPreviewFormat(ImageFormat.NV21); //default

    if (isSupportFocus(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
        mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    } else if (isSupportFocus(Camera.Parameters.FOCUS_MODE_AUTO)) {
        mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
    }

    //设置预览图片大小
    setPreviewSize();
    //设置图片大小
    setPictureSize();

    camera.setParameters(mParameters);
}

Camera.Parameters可以设置的参数非常多，这里就介绍几个比较常用的

Camera.Parameters

1.setFocusMode

设置对焦模式

FOCUS_MODE_AUTO：自动对焦
FOCUS_MODE_INFINITY：无穷远
FOCUS_MODE_MACRO：微距
FOCUS_MODE_FIXED：固定焦距
FOCUS_MODE_EDOF：景深扩展
FOCUS_MODE_CONTINUOUS_PICTURE：持续对焦(针对照片)
FOCUS_MODE_CONTINUOUS_VIDEO：(针对视频)

2.setPreviewSize

设置预览图片大小

3.setPreviewFormat

支持的格式：

ImageFormat.NV16
ImageFormat.NV21
ImageFormat.YUY2
ImageFormat.YV12
ImgaeFormat.RGB_565
ImageFormat.JPEG
如果不设置，默认返回NV21的数据

4.setPictureSize

设置保存图片的大小

5.setPictureFormat

设置保存图片的格式，格式和setPreviewFormat一样

6.setDisplayOrientation

设置相机预览画面旋转的角度，degress取值0，90，180，270

7.setPreviewDisplay

设置实时预览SurfaceHolder

8.setPreviewCallback

监听相机预览数据回调

9.setParameters

设置相机的Parameters
其他一些设置，大家可以查看Android文档进行相应的设置

设置方向

设置相机的预览方向，orientation比较详细的介绍

private void setCameraDisplayOrientation() {
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    Camera.getCameraInfo(mCameraId, cameraInfo);
    int rotation = getWindowManager().getDefaultDisplay().getRotation();  //自然方向
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0:
            degrees = 0;
            break;
        case Surface.ROTATION_90:
            degrees = 90;
            break;
        case Surface.ROTATION_180:
            degrees = 180;
            break;
        case Surface.ROTATION_270:
            degrees = 270;
            break;
    }

    int result;
    //cameraInfo.orientation 图像传感方向
    if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        result = (cameraInfo.orientation + degrees) % 360;
        result = (360 - result) % 360;
    } else {
        result = (cameraInfo.orientation - degrees + 360) % 360;
    }

    mOrientation = result;
    //相机预览方向
    mCamera.setDisplayOrientation(result);
}

拍照

private void takePicture() {
    if (null != mCamera) {
        mCamera.takePicture(new Camera.ShutterCallback() {
            @Override
            public void onShutter() {

            }
        }, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(byte[] data, Camera camera) {
                //base data
            }
        }, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(final byte[] data, Camera camera) {
                mCamera.startPreview();
                //save data
            }
        });
    }
}

takePicture的源码实现：

public final void takePicture(ShutterCallback shutter, PictureCallback raw,
            PictureCallback jpeg) {
        takePicture(shutter, raw, null, jpeg);
    }

shutter(ShutterCallback)：快门按下后的回调
raw(PictureCallback)：raw图像数据
jpeg(PictureCallback)：jpeg图像生成以后的回调

释放相机资源

在使用完成后，onPause或者onDestory中进行相机资源的释放

private void releaseCamera() {
    if (null != mCamera) {
        mCamera.stopPreview();
        mCamera.stopFaceDetection();
        mCamera.setPreviewCallback(null);
        mCamera.release();
        mCamera = null;
    }
}

stopPreview：停止预览
release：释放资源

Camera2使用

设计框架

来自官网的模型图，展示了相关的工作流程

重新设计 Android Camera API 的目的在于大幅提高应用对于 Android 设备上的相机子系统的控制能力，同时重新组织 API，提高其效率和可维护性。
在CaptureRequest中设置不同的Surface用于接收不同的图片数据，最后从不同的Surface中获取到图片数据和包含拍照相关信息的CaptureResult。

优点

通过设计框架的改造和优化，Camera2具备了以下优点:

改进了新硬件的性能。Supported Hardware Level的概念，不同厂商对Camera2的支持程度不同，从低到高有LEGACY、LIMITED、FULL 和 LEVEL_3四个级别
以更快的间隔拍摄图像
显示来自多个摄像机的预览
直接应用效果和滤镜

开发流程

框架上的变化，对整个使用流程变化也非常大，首先了解一些主要的开发类

类

CameraManager

相机系统服务，用于管理和连接相机设备

CameraDevice

相机设备类，和Camera1中的Camera同级

CameraCharacteristics

主要用于获取相机信息，内部携带大量的相机信息，包含摄像头的正反(LENS_FACING)、AE模式、AF模式等，和Camera1中的Camera.Parameters类似

CaptureRequest

相机捕获图像的设置请求，包含传感器，镜头，闪光灯等

CaptureRequest.Builder

CaptureRequest的构造器，使用Builder模式，设置更加方便

CameraCaptureSession

请求抓取相机图像帧的会话，会话的建立主要会建立起一个通道。一个CameraDevice一次只能开启一个CameraCaptureSession。
源端是相机，另一端是 Target，Target可以是Preview，也可以是ImageReader。

ImageReader

用于从相机打开的通道中读取需要的格式的原始图像数据，可以设置多个ImageReader。

流程

Camera2开发流程

获取CameraManager

CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

获取相机信息

for (String cameraId : cameraManager.getCameraIdList()) {
    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);

    Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
    if (null != facing && facing == CameraCharacteristics.LENS_FACING_FRONT) {
        continue;
    }
    ....
}

这里默认选择前置摄像头，并获取相关相机信息。

初始化ImageReader

mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 2);
mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
    @Override
    public void onImageAvailable(ImageReader reader) {
        Log.d("DEBUG", "##### onImageAvailable: " + mFile.getPath());
        mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));
    }
}, mBackgroundHandler);

ImageReader是获取图像数据的重要途径，通过它可以获取到不同格式的图像数据，例如JPEG、YUV、RAW等。通过ImageReader.newInstance(int width, int height, int format, int maxImages)创建ImageReader对象，有4个参数：

width：图像数据的宽度
height：图像数据的高度
format：图像数据的格式，例如ImageFormat.JPEG，ImageFormat.YUV_420_888等
maxImages：最大Image个数，Image对象池的大小，指定了能从ImageReader获取Image对象的最大值，过多获取缓冲区可能导致OOM，所以最好按照最少的需要去设置这个值

ImageReader其他相关的方法和回调：

ImageReader.OnImageAvailableListener：有新图像数据的回调
acquireLatestImage()：从ImageReader的队列里面，获取最新的Image，删除旧的，如果没有可用的Image，返回null
acquireNextImage()：获取下一个最新的可用Image，没有则返回null
close()：释放与此ImageReader关联的所有资源
getSurface()：获取为当前ImageReader生成Image的Surface

打开相机设备

try {
    if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
        throw new RuntimeException("Time out waiting to lock camera opening.");
    }

    cameraManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);
} catch (Exception e) {
    e.printStackTrace();
}

cameraManager.openCamera(@NonNull String cameraId,@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)的三个参数:

cameraId：摄像头的唯一标识
callback：设备连接状态变化的回调
handler：回调执行的Handler对象，传入null则使用当前的主线程Handler

其中callback回调：

private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(@NonNull CameraDevice camera) {
        mCameraOpenCloseLock.release();
        mCameraDevice = camera;
        createCameraPreviewSession();
    }

    @Override
    public void onDisconnected(@NonNull CameraDevice camera) {
        mCameraOpenCloseLock.release();
        camera.close();
        mCameraDevice = null;
    }

    @Override
    public void onError(@NonNull CameraDevice camera, int error) {
        mCameraOpenCloseLock.release();
        camera.close();
        mCameraDevice = null;
    }

    @Override
    public void onClosed(@NonNull CameraDevice camera) {
        super.onClosed(camera);
    }
};

onOpened：表示相机打开成功，可以真正开始使用相机，创建Capture会话
onDisconnected：当相机断开连接时回调该方法，需要进行释放相机的操作
onError：当相机打开失败时，需要进行释放相机的操作
onClosed：调用Camera.close()后的回调方法

创建Capture会话

在CameraDevice.StateCallback的onOpened回调中执行：

private void createCameraPreviewSession() {
    SurfaceTexture texture = mTextureView.getSurfaceTexture();
    assert texture != null;
    texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
    Surface surface = new Surface(texture);

    try {
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        mPreviewRequestBuilder.addTarget(surface);

        // Here, we create a CameraCaptureSession for camera preview.
        mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                new CameraCaptureSession.StateCallback() {

                    @Override
                    public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                        // The camera is already closed
                        if (null == mCameraDevice) {
                            return;
                        }

                        // When the session is ready, we start displaying the preview.
                        mCaptureSession = cameraCaptureSession;
                        try {
                            // Auto focus should be continuous for camera preview.
                            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                            // Flash is automatically enabled when necessary.
                            setAutoFlash(mPreviewRequestBuilder);

                            // Finally, we start displaying the camera preview.
                            mPreviewRequest = mPreviewRequestBuilder.build();
                            mCaptureSession.setRepeatingRequest(mPreviewRequest,
                                    mCaptureCallback, mBackgroundHandler);
                        } catch (CameraAccessException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onConfigureFailed(
                            @NonNull CameraCaptureSession cameraCaptureSession) {
                        Toast.makeText(Camera2Activity.this, "configureFailed", Toast.LENGTH_SHORT).show();
                    }
                }, null
        );
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

这段的代码核心方法是mCameraDevice.createCaptureSession()创建Capture会话，它接受了三个参数：

outputs：用于接受图像数据的surface集合，这里传入的是一个preview的surface
callback：用于监听 Session 状态的CameraCaptureSession.StateCallback对象
handler：用于执行CameraCaptureSession.StateCallback的Handler对象，传入null则使用当前的主线程Handler

创建CaptureRequest

CaptureRequest是向CameraCaptureSession提交Capture请求时的信息载体，其内部包括了本次Capture的参数配置和接收图像数据的Surface。

mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
mPreviewRequestBuilder.addTarget(surface);

通过CameraDevice.createCaptureRequest()创建CaptureRequest.Builder对象，传入一个templateType参数，templateType用于指定使用何种模板创建CaptureRequest.Builder对象，templateType的取值：

TEMPLATE_PREVIEW：预览模式
TEMPLATE_STILL_CAPTURE：拍照模式
TEMPLATE_RECORD：视频录制模式
TEMPLATE_VIDEO_SNAPSHOT：视频截图模式
TEMPLATE_MANUAL：手动配置参数模式

除了模式的配置，CaptureRequest还可以配置很多其他信息，例如图像格式、图像分辨率、传感器控制、闪光灯控制、3A(自动对焦-AF、自动曝光-AE和自动白平衡-AWB)控制等。在createCaptureSession的回调中可以进行设置

// Auto focus should be continuous for camera preview.
mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// Flash is automatically enabled when necessary.
setAutoFlash(mPreviewRequestBuilder);

// Finally, we start displaying the camera preview.
mPreviewRequest = mPreviewRequestBuilder.build();

代码中设置了AF为设置未图片模式下的连续对焦，并设置自动闪光灯。最后通过build()方法生成CaptureRequest对象。

预览

Camera2中，通过连续重复的Capture实现预览功能，每次Capture会把预览画面显示到对应的Surface上。连续重复的Capture操作通过mCaptureSession.setRepeatingRequest(mPreviewRequest,mCaptureCallback, mBackgroundHandler)实现，该方法有三个参数：

request：CaptureRequest对象
listener：监听Capture 状态的回调
handler：用于执行CameraCaptureSession.CaptureCallback的Handler对象，传入null则使用当前的主线程Handler

停止预览使用mCaptureSession.stopRepeating()方法。

拍照

设置上面的request，session后，就可以真正的开始拍照操作

mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);

该方法也有三个参数，和mCaptureSession.setRepeatingRequest一样：

request：CaptureRequest对象
listener：监听Capture 状态的回调
handler：用于执行CameraCaptureSession.CaptureCallback的Handler对象，传入null则使用当前的主线程Handler

这里设置了mCaptureCallback：

private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
    @Override
    public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
        process(partialResult);
    }

    @Override
    public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
        process(result);
    }

    private void process(CaptureResult result) {
        switch (mState) {
            case STATE_PREVIEW: {
                // We have nothing to do when the camera preview is working normally.
                break;
            }
            case STATE_WAITING_LOCK: {
                Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
                Log.d("DEBUG", "##### process STATE_WAITING_LOCK: " + afState);
                if (afState == null) {
                    captureStillPicture();
                } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState ||
                        CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                    // CONTROL_AE_STATE can be null on some devices
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null ||
                            aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                        mState = STATE_PICTURE_TAKEN;
                        captureStillPicture();
                    } else {
                        runPrecaptureSequence();
                    }
                }
                break;
            }
            case STATE_WAITING_PRECAPTURE: {
                // CONTROL_AE_STATE can be null on some devices
                Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                if (aeState == null ||
                        aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
                        aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                    mState = STATE_WAITING_NON_PRECAPTURE;
                }
                break;
            }
            case STATE_WAITING_NON_PRECAPTURE: {
                // CONTROL_AE_STATE can be null on some devices
                Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                    mState = STATE_PICTURE_TAKEN;
                    captureStillPicture();
                }
                break;
            }
        }
    }
};

通过设置mState来区分当前状态，是在预览还是拍照

关闭相机

退到后台或者当前页面被关闭的时候，已经不需要使用相机了，需要进行相机关闭操作，释放资源，

private void closeCamera() {
    try {
        mCameraOpenCloseLock.acquire();
        if (null != mCaptureSession) {
            mCaptureSession.close();
            mCaptureSession = null;
        }
        if (null != mCameraDevice) {
            mCameraDevice.close();
            mCameraDevice = null;
        }
        if (null != mImageReader) {
            mImageReader.close();
            mImageReader = null;
        }
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
    } finally {
        mCameraOpenCloseLock.release();
    }
}

先后对CaptureSession，CameraDevice，ImageReader进行close操作，释放资源。
这里仅仅对Camera2基本使用流程做了介绍，一些更高级的用法需要大家自行去实践。在Camera1中需要对画面进行方向矫正，而Camera2是否需要呢，关于相机Orientation相关的知识，通过后面的章节再进行介绍。

CameraView

CameraView的目的就是帮助开发者能够快速集成Camera1和Camera2的特性，可以用下面这张表来说明：

开发流程

CameraView定义

xml中定义

<com.google.android.cameraview.CameraView
    android:id="@+id/camera"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:keepScreenOn="true"
    android:adjustViewBounds="true"
    app:autoFocus="true"
    app:aspectRatio="4:3"
    app:facing="back"
    app:flash="auto"/>

xml中可以配置：

autoFocus：是否自动对焦
aspectRatio：预览画面比例
facing：前后摄像头
flash：闪光灯模式

增加生命周期

@Override
protected void onResume() {
    super.onResume();
    mCameraView.start();
}

@Override
protected void onPause() {
    mCameraView.stop();
    super.onPause();
}

这样声明后，就可以完成预览的工作了

相机状态回调

在xml声明CameraView后，增加回调

if (mCameraView != null) {
    mCameraView.addCallback(mCallback);
}
...
private CameraView.Callback mCallback
            = new CameraView.Callback() {

    @Override
    public void onCameraOpened(CameraView cameraView) {
        Log.d(TAG, "onCameraOpened");
    }

    @Override
    public void onCameraClosed(CameraView cameraView) {
        Log.d(TAG, "onCameraClosed");
    }

    @Override
    public void onPictureTaken(CameraView cameraView, final byte[] data) {
        Log.d(TAG, "onPictureTaken " + data.length);
        Toast.makeText(cameraView.getContext(), R.string.picture_taken, Toast.LENGTH_SHORT)
                .show();
        getBackgroundHandler().post(new Runnable() {
            @Override
            public void run() {
                File file = new File(getExternalFilesDir(Environment.DIRECTORY_PICTURES),
                        "picture.jpg");
                Log.d(TAG, "onPictureTaken file path: " + file.getPath());
                OutputStream os = null;
                try {
                    os = new FileOutputStream(file);
                    os.write(data);
                    os.close();
                } catch (IOException e) {
                    Log.w(TAG, "Cannot write to " + file, e);
                } finally {
                    if (os != null) {
                        try {
                            os.close();
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                }
            }
        });
    }

};

有三个回调方法，相机打开，相机关闭，和拍照。

拍照

mCameraView.takePicture();

就是这么简单，点击后拍照，然后回调中处理图像数据

CameraX

CameraX 是一个 Jetpack 支持库，目的是简化Camera的开发工作，它是基于Camera2 API的基础，向后兼容至 Android 5.0（API 级别 21）。
它有以下几个特性：

易用性，只需要几行代码就可以实现预览和拍照
保持设备的一致性，在不同相机设备上，对宽高比、屏幕方向、旋转、预览大小和高分辨率图片大小，做到都可以正常使用
相机特性的扩展，增加人像、HDR、夜间模式和美颜等功能

开发流程

库引用

目前CameraX最新版本是1.0.0-alpha06，在app的build.gradle引用：

dependencies {
    // CameraX core library.
    def camerax_version = "1.0.0-alpha06"
    implementation "androidx.camera:camera-core:${camerax_version}"
    // If you want to use Camera2 extensions.
    implementation "androidx.camera:camera-camera2:${camerax_version}"

    def camerax_view_version = "1.0.0-alpha03"
    def camerax_ext_version = "1.0.0-alpha03"
    //other
    // If you to use the Camera View class
    implementation "androidx.camera:camera-view:$camerax_view_version"
    // If you to use Camera Extensions
    implementation "androidx.camera:camera-extensions:$camerax_ext_version"
}

因为CameraX是一个 Jetpack 支持库，相机的打开和释放都是使用了Jetpack的Lifecycle来进行处理。

预览

预览参数设置，使用PreviewConfig.Builder()实现：

PreviewConfig config = new PreviewConfig.Builder()
                .setLensFacing(CameraX.LensFacing.BACK)
                .setTargetRotation(mTextureView.getDisplay().getRotation())
                .setTargetResolution(new Size(640, 480))
                .build();

Preview preview = new Preview(config);
preview.setOnPreviewOutputUpdateListener(new Preview.OnPreviewOutputUpdateListener() {
    @Override
    public void onUpdated(@NonNull Preview.PreviewOutput output) {
        if (mTextureView.getParent() instanceof ViewGroup) {
            ViewGroup viewGroup = (ViewGroup) mTextureView.getParent();
            viewGroup.removeView(mTextureView);
            viewGroup.addView(mTextureView, 0);

            mTextureView.setSurfaceTexture(output.getSurfaceTexture());
            updateTransform();
        }
    }
});

//lifecycle
CameraX.bindToLifecycle(this, preview);

PreivewConfig.Builder可以设置的属性很多，这里只设置了摄像头、旋转方向、预览分辨率，还有很多其他方法，大家可以自行试验。
在preview回调监听中，把output的SurfaceTexture设置到mTextureView中，实现图像预览，最后增加Lifecycle的绑定。

拍照

ImageCaptureConfig captureConfig = new ImageCaptureConfig.Builder()
        .setTargetAspectRatio(AspectRatio.RATIO_16_9)
        .setCaptureMode(ImageCapture.CaptureMode.MIN_LATENCY)
        .setTargetRotation(getWindowManager().getDefaultDisplay().getRotation())
        .build();

ImageCapture imageCapture = new ImageCapture(captureConfig);
mTakePicture.setOnClickListener((view) -> {
    final File file = new File(getExternalMediaDirs()[0], System.currentTimeMillis() + ".jpg");
    Log.d("DEBUG", "##### file path: " + file.getPath());
    imageCapture.takePicture(file, ContextCompat.getMainExecutor(getApplicationContext()), new ImageCapture.OnImageSavedListener() {
        @Override
        public void onImageSaved(@NonNull File file) {
            Log.d("DEBUG", "##### onImageSaved: " + file.getPath());
        }

        @Override
        public void onError(@NonNull ImageCapture.ImageCaptureError imageCaptureError, @NonNull String message, @Nullable Throwable cause) {
            Log.d("DEBUG", "##### onError: " + message);
        }
    });
});

CameraX.bindToLifecycle(this, preview, imageCapture);

拍照的参数通过ImageCaptureConfig.Builder设置，这里只设置了图片宽高比、拍摄模式和旋转方向，还有很多其他方法，大家可以自行试验。
真正调用拍照的方法：

takePicture(OnImageCapturedListener)：此方法为拍摄的图片提供内存缓冲区。
takePicture(File, OnImageSavedListener)：此方法将拍摄的图片保存到提供的文件位置。
takePicture(File, OnImageSavedListener, Metadata)：此方法可用于指定要嵌入已保存文件的 Exif 中的元数据。

例子调用的是takePicture(File, OnImageSavedListener)，直接存为文件。最后再增加Lifecycle的绑定。

图片分析

ImageAnalysisConfig analysisConfig = new ImageAnalysisConfig.Builder()
        .setImageReaderMode(ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE)
        .build();

ImageAnalysis imageAnalysis = new ImageAnalysis(analysisConfig);
imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(getApplicationContext()),
        new LuminosityAnalyzer());

CameraX.bindToLifecycle(this, preview, imageCapture, imageAnalysis);

...
private class LuminosityAnalyzer implements ImageAnalysis.Analyzer {
    private long lastAnalyzedTimestamp = 0L;

    @Override
    public void analyze(ImageProxy image, int rotationDegrees) {
        final Image img = image.getImage();
        if (img != null) {
            Log.d("DEBUG", img.getWidth() + "," + img.getHeight());
        }
    }
}

图片分析，不是必要的步骤，但是ImageAnalysis，可以对每帧图像进行分析。
设置参数通过ImageAnalysisConfig.Builder()，这里只设置了ImageReaderMode，它有两种模式：

阻止模式(ImageReaderMode.ACQUIRE_NEXT_IMAGE)：就是Camera2中的acquireNextImage()，获取下一个最新的可用Image
非阻止模式(ImageReaderMode.ACQUIRE_LATEST_IMAGE)：Camera2中的acquireLatestImage()，获得图像队列中最新的图片，并且会清空队列,删除已有的旧的图像

最后还是增加Lifecycle的绑定。CameraX的使用也非常简单，把Camera2中复杂的API封装到统一的config中，只需要几行代码，就实现需要的功能。

最后

以上就是风中毛衣为你收集整理的Android Camera1-Camera2-CameraView和CameraX使用基础知识Camera1使用Camera2使用设计框架开发流程CameraViewCameraX的全部内容，希望文章能够帮你解决Android Camera1-Camera2-CameraView和CameraX使用基础知识Camera1使用Camera2使用设计框架开发流程CameraViewCameraX所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Android
浏览次数：59 次浏览
发布日期：2023-06-25 14:40:01
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_26_f1_12__7_ky.html

Android Camera1-Camera2-CameraView和CameraX使用基础知识Camera1使用Camera2使用设计框架开发流程CameraViewCameraX

概述

基础知识

相关开发类

术语

相机功能

区域测光和对焦

人脸检测

延时视频

Camera1使用

权限声明

开发流程

打开相机

创建预览画面

设置相机参数

设置方向

拍照

释放相机资源

Camera2使用

设计框架

优点

开发流程

类

CameraManager

CameraDevice

CameraCharacteristics

CaptureRequest

CaptureRequest.Builder

CameraCaptureSession

ImageReader

流程

获取CameraManager

获取相机信息

初始化ImageReader

打开相机设备

创建Capture会话

创建CaptureRequest

预览

拍照

关闭相机

CameraView

开发流程

CameraView定义

增加生命周期

相机状态回调

拍照

CameraX

开发流程

库引用

预览

拍照

图片分析

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复