Android Camera2拍照流程
最近在看Camera2相关的内容，初看感觉调用比较复杂，因此结合googlesamples中的示例总结一下大致的调用流程
概述
android.hardware.camera2包向连接在Android设备上的相机设备提供了接口，它用来代替已经废弃的Camera类。
这个包将相机设备模拟为一个管道，它接收一个捕获一帧图像的输入请求，每个请求捕获一帧图像，然后输出每一次捕获结果的元数据包，以及一组输出图像缓存区。
想要获取、查询或者打开一个可用的相机设备，需要获取一个CameraManager实例。
每个CameraDevice都提供一组静态属性来描述硬件设备和设备可用的设定以及输出参数。这些信息由一个CameraCharacteristics对象 提供，它可以通过**CameraManager.getCameraCharacteristics(cameraId)**来获得。
想要从一个相机设备捕获一张图像或者获取图像流，应用程序需要调用CameraDevice的createCaptureSession方法创建一个CameraCaptureSession对象，该方法需要一组与相机设备一起使用的一组输出的Surface，每个Surface都需要实现配置好适当的尺寸和格式以匹配相机可用的尺寸和格式，目标Surface可以从很多类中获取到，比如：SurfaceView, SurfaceTexture 通过Surface(SurfaceTexture), MediaCodec, MediaRecorder, Allocation, and ImageReader。
通常来说，相机的预览图像可以发送到SurfaceView和TextureView(通过它的SurfaceTexture)来展示出来。JPEG图像或者用于DngCreator的RAW缓冲区的捕获可以用ImageReader通过JPEG或RAW_SENSOR格式来完成。
然后我们需要构造一个CaptureRequest对象，它定义了相机捕获一帧数据所需要的所有参数，它还列举了这次捕获图像应该以哪一个配置好的Surface作为目标，CameraDevice 有一个工厂方法createCaptureRequest来创建一个指定类型的CaptureRequest.Builder对象。
一旦一个CaptureRequest对象被配置好了，就可以把它交给一个活动的CameraCaptureSession来拍一张照片或者不断重复的捕获图像作为预览。发送一个捕获的请求后，相机设备会产生一个TotalCaptureResult对象，它包含了捕获时相机的状态和最后起作用的设置等信息，相机还会发送一帧图像数据到包含在这个请求中的每一个Surface。
下面是我画的一个大致的调用流程图，比较粗糙
调用流程
获取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视频录制的流程。
