Android Camera2拍照流程

时间 2019-11-06

标签 android camera2 camera 拍照流程栏目 Android 繁體版

原文原文链接

Android Camera2拍照流程

最近在看Camera2相关的内容，初看感受调用比较复杂，所以结合googlesamples中的示例总结一下大体的调用流程java

概述

android.hardware.camera2包向链接在Android设备上的相机设备提供了接口，它用来代替已经废弃的Camera类。android

这个包将相机设备模拟为一个管道，它接收一个捕获一帧图像的输入请求，每一个请求捕获一帧图像，而后输出每一次捕获结果的元数据包，以及一组输出图像缓存区。git

想要获取、查询或者打开一个可用的相机设备，须要获取一个CameraManager实例。github

每一个CameraDevice都提供一组静态属性来描述硬件设备和设备可用的设定以及输出参数。这些信息由一个CameraCharacteristics对象提供，它能够经过**CameraManager.getCameraCharacteristics(cameraId)**来得到。缓存

想要从一个相机设备捕获一张图像或者获取图像流，应用程序须要调用CameraDevice的createCaptureSession方法建立一个CameraCaptureSession对象，该方法须要一组与相机设备一块儿使用的一组输出的Surface，每一个Surface都须要实现配置好适当的尺寸和格式以匹配相机可用的尺寸和格式，目标Surface能够从不少类中获取到，好比：SurfaceView, SurfaceTexture 经过Surface(SurfaceTexture), MediaCodec, MediaRecorder, Allocation, and ImageReader。session

一般来讲，相机的预览图像能够发送到SurfaceView和TextureView(经过它的SurfaceTexture)来展现出来。JPEG图像或者用于DngCreator的RAW缓冲区的捕获能够用ImageReader经过JPEG或RAW_SENSOR格式来完成。ide

而后咱们须要构造一个CaptureRequest对象，它定义了相机捕获一帧数据所须要的全部参数，它还列举了此次捕获图像应该以哪个配置好的Surface做为目标，CameraDevice 有一个工厂方法createCaptureRequest来建立一个指定类型的CaptureRequest.Builder对象。oop

一旦一个CaptureRequest对象被配置好了，就能够把它交给一个活动的CameraCaptureSession来拍一张照片或者不断重复的捕获图像做为预览。发送一个捕获的请求后，相机设备会产生一个TotalCaptureResult对象，它包含了捕获时相机的状态和最后起做用的设置等信息，相机还会发送一帧图像数据到包含在这个请求中的每个Surface。布局

下面是我画的一个大体的调用流程图，比较粗糙post

调用流程

获取cameraId以及相关参数

用TextureView来接受预览的图像数据，在Activity/Fragment的onResume方法中判断textureview是否能够渲染，能够的画直接调用相机的相关方法，不然的话注册监听。用HandlerThread开启一个后台线程，建立一个该线程的Handler

private TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() {
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        openCamera(width, height);
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {

    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

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

    if (previewView.isAvailable()) {
        openCamera(previewView.getWidth(), previewView.getHeight());
    } else {
        previewView.setSurfaceTextureListener(surfaceTextureListener);
    }
}

private void startBackground() {
    handlerThread = new HandlerThread("cameraThread");
    handlerThread.start();
    mHandler = new Handler(handlerThread.getLooper());
}
复制代码

下面开始经过CameraManager来获取相机列表并获得咱们须要的相机id已经相关参数

private void setupCamera(int width, int height) {
    CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        //获取可用的相机列表
        String[] cameraIdList = cameraManager.getCameraIdList();
        for (String cameraId : cameraIdList) {
            //获取该相机的CameraCharacteristics，它保存的相机相关的属性
            CameraCharacteristics cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId);
            //获取相机的方向
            Integer facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
            //若是是前置摄像头就continue，咱们这里只用后置摄像头
            if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
                continue;
            }
            //获取相机支持的流的参数的集合
            StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            //获取输出格式为ImageFormat.JPEG支持的全部尺寸
            Size[] outputSizes = map.getOutputSizes(ImageFormat.JPEG);
            //获取支持的最大的尺寸，SizeByteConparable是一个实现了Comparator接口的类，比较简单
            Size max = Collections.max(Arrays.asList(outputSizes), new SizeByteConparable());
            //实例化一个ImageReader对象
            imageReader = ImageReader.newInstance(max.getWidth(), max.getHeight(), ImageFormat.JPEG, 2);
            //给imageReader对象设置监听
            imageReader.setOnImageAvailableListener(mOnImageAvaliableListener, mHandler);
            mPreviewSize = new Size(width, height);
            //保存cameraId
            this.cameraId = cameraId;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
复制代码

上面的方法就获取到了咱们想要的cameraid以及相关参数，其中有一个ImageReader，它内部有一个Surface对象，在须要拍照的时候，咱们将这个Surface对象设置为CaptureRequest的target surface，那么相机就会将捕获的图像数据渲染到这个surface中，咱们就能够经过ImageReader来获取图像出具来保存到本地，其中OnImageAvaliableListener就是当相机将图像数据显然到ImageReader的Surface中时的回调。

打开相机

private CameraDevice.StateCallback cameraStateCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(@NonNull CameraDevice camera) {
        mCameraDevice = camera;
        createCaptureSession();
    }

    @Override
    public void onDisconnected(@NonNull CameraDevice camera) {

    }

    @Override
    public void onError(@NonNull CameraDevice camera, int error) {

    }
};

private void openCamera(int width, int height) {
    //第一步的方法
    setupCamera(width, height);
    CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        // TODO: Consider calling
        // ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        // public void onRequestPermissionsResult(int requestCode, String[] permissions,
        // int[] grantResults)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.
        return;
    }
    try {
        cameraManager.openCamera(cameraId, cameraStateCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
复制代码

打开相机的方法比较简单，就调用了CaneraManager的openCamera方法，传入cameraId以及一个callback，当相机打开成功，失败或者相机断开链接是会调用这个callback。

建立CameraCaptureSession，开始预览

上一步在打开相机成功的毁掉中调用了createCaptureSession方法，下面是该方法的实现：

private CameraCaptureSession.StateCallback sessionCallback = new CameraCaptureSession.StateCallback() {
    @Override
    public void onConfigured(@NonNull CameraCaptureSession session) {
        //保存为全局变量
        mCameraCaptureSession = session;
        //设置自动对焦模式为连续自动对焦
        previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        //建立CaptureRequest
        previewRequest = previewRequestBuilder.build();
        try {
            //开始预览，因为咱们如今并不须要对预览的图像数据作处理，因此这里的第二个参数就传null
            mCameraCaptureSession.setRepeatingRequest(previewRequest, null, mHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onConfigureFailed(@NonNull CameraCaptureSession session) {

    }
};

private void createCaptureSession() {
    //获取TextureView的SurfaceTexture，用来下一步建立Surface
    SurfaceTexture surfaceTexture = previewView.getSurfaceTexture();
    //设置默认的缓冲区大小
    surfaceTexture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
    //建立Surface
    Surface surface = new Surface(surfaceTexture);
    try {
        //获取一个预览的CaptureRequestBuilder，注意类型为CameraDevice.TEMPLATE_PREVIEW
        previewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        //将上面建立的Surface设置为request的目标surface，这里最终就会渲染到咱们布局文件里面的TextureView
        previewRequestBuilder.addTarget(surface);
        //建立CameraCaptureSession
        mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()), sessionCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}
复制代码

这个时候已经能够预览了

拍照

经过上面三个步骤已经能够在屏幕上显示预览了，如今开始作拍照操做，从第一部分咱们能够知道拍照也是要经过向CameraCaptureSession发送一个CaptureRequest来实现。

private CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() {
    @Override
    public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
        super.onCaptureCompleted(session, request, result);
        try {
           //拍照完成后从新开启预览
            mCameraCaptureSession.setRepeatingRequest(previewRequest,previewCaptureCallback,mHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
};

@OnClick(R.id.capture)
public void onViewClicked() {
    CaptureRequest.Builder captureRequestBuilder = null;
    try {
        //用CameraDevice建立一个CaptureRequest.Builder,类型为CameraDevice.TEMPLATE_STILL_CAPTURE，也就是说咱们须要请求以个静态的图像。
        captureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
                CameraMetadata.CONTROL_AF_TRIGGER_START);
        //将imageReader的Surface设置为请求的目标Surface
        captureRequestBuilder.addTarget(imageReader.getSurface());
        captureRequest = captureRequestBuilder.build();
        //中止预览
        mCameraCaptureSession.stopRepeating();
        mCameraCaptureSession.abortCaptures();
        //开始请求拍照
        mCameraCaptureSession.capture(captureRequest, captureCallback, mHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private ImageReader.OnImageAvailableListener mOnImageAvaliableListener = new ImageReader.OnImageAvailableListener() {
    @Override
    public void onImageAvailable(ImageReader reader) {
        //发送拍照的请求后，相机将图像数据填充到imageReader的Surface中的时候会回调这里
        //咱们想后台线程post一个runnable
        mHandler.post(new SaveImageRunnable(reader.acquireNextImage()));
    }
};

//一个保存图片的Runnable
public class SaveImageRunnable implements Runnable {
    private Image image;
    private File file;

    public SaveImageRunnable(Image image) {
        this(image, new File(getExternalFilesDir(null), "image-capture.jpg"));
    }

    public SaveImageRunnable(Image image, File file) {
        this.image = image;
        this.file = file;
    }

    @Override
    public void run() {
        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
        byte[] byteBuffer = new byte[buffer.remaining()];
        buffer.get(byteBuffer);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            fos.write(byteBuffer);
        } catch (java.io.IOException e) {
            e.printStackTrace();
        } finally {
            try {
                assert fos != null;
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

至此相机预览以及拍照流程就完成了，因为这里只总结大体流程，简化了不少细节，好比方向，对焦，闪光灯等，致使拍出的照片质量不高。后面会总结一下用Camera2视频录制的流程。