简介：
Android 5.0开始出现了新的相机Camera 2 API，用来替代以前的camera api。
Camera2 API不仅提高了android系统的拍照性能，还支持RAW照片输出，还可以设置相机的对焦模式，曝光模式，快门等等。
Camera2 中主要的API类
CameraManager类 : 摄像头管理类，用于检测、打开系统摄像头，通过
getCameraCharacteristics(cameraId)可以获取摄像头特征。CameraCharacteristics类：相机特性类，例如，是否支持自动调焦，是否支持zoom，是否支持闪光灯一系列特征。
CameraDevice类： 相机设备,类似早期的camera类。
CameraCaptureSession类：用于创建预览、拍照的Session类。通过它的
setRepeatingRequest()方法控制预览界面 , 通过它的capture()方法控制拍照动作或者录像动作。CameraRequest类：一次捕获的请求，可以设置一些列的参数，用于控制预览和拍照参数，例如：对焦模式，曝光模式，zoom参数等等。
接下来，进一步介绍，Camera2 API中的各种常见类和抽象类。
CameraManager类
CameraCharacteristics cameraCharacteristics =manager.getCameraCharacteristics(cameraId);通过以上代码可以获取摄像头的特征对象，例如： 前后摄像头，分辨率等。
CameraCharacteristics类
相机特性类
CameraCharacteristics是一个包含相机参数的对象，可以通过一些key获取对应的values.
以下几种常用的参数：
LENS_FACING:获取摄像头方向。LENS_FACING_FRONT是前摄像头，LENS_FACING_BACK是后摄像头。
SENSOR_ORIENTATION：获取摄像头拍照的方向。
FLASH_INFO_AVAILABLE：获取是否支持闪光灯。
SCALER_AVAILABLE_MAX_DIGITAL_ZOOM：获取最大的数字调焦值，也就是zoom最大值。
LENS_INFO_MINIMUM_FOCUS_DISTANCE：获取最小的调焦距离，某些手机上获取到的该values为null或者0.0。前摄像头大部分有固定焦距，无法调节。
INFO_SUPPORTED_HARDWARE_LEVEL：获取摄像头支持某些特性的程度。
以下手机中支持的若干种程度：
INFO_SUPPORTED_HARDWARE_LEVEL_FULL：全方位的硬件支持，允许手动控制全高清的摄像、支持连拍模式以及其他新特性。
INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED：有限支持，这个需要单独查询。
INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY：所有设备都会支持，也就是和过时的Camera API支持的特性是一致的。
CameraDevice类
CameraDevice的reateCaptureRequest(int templateType)方法创建CaptureRequest.Builder。
templateType参数有以下几种：
TEMPLATE_PREVIEW ：预览
TEMPLATE_RECORD：拍摄视频
TEMPLATE_STILL_CAPTURE：拍照
TEMPLATE_VIDEO_SNAPSHOT：创建视视频录制时截屏的请求
TEMPLATE_ZERO_SHUTTER_LAG：创建一个适用于零快门延迟的请求。在不影响预览帧率的情况下最大化图像质量。
TEMPLATE_MANUAL：创建一个基本捕获请求，这种请求中所有的自动控制都是禁用的(自动曝光，自动白平衡、自动焦点)。
CameraDevice.StateCallback抽象类
该抽象类用于CemeraDevice相机设备状态的回调。
/**
* 当相机设备的状态发生改变的时候，将会回调。
*/
protected final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
/**
* 当相机打开的时候，调用
* @param cameraDevice
*/
@Override
public void onOpened(@NonNull CameraDevice cameraDevice) {
mCameraDevice = cameraDevice;
startPreView();
}
@Override
public void onDisconnected(@NonNull CameraDevice cameraDevice) {
cameraDevice.close();
mCameraDevice = null;
}
/**
* 发生异常的时候调用
*
* 这里释放资源，然后关闭界面
* @param cameraDevice
* @param error
*/
@Override
public void onError(@NonNull CameraDevice cameraDevice, int error) {
cameraDevice.close();
mCameraDevice = null;
}
/**
*当相机被关闭的时候
*/
@Override
public void onClosed(@NonNull CameraDevice camera) {
super.onClosed(camera);
}
};CameraCaptureSession.StateCallback抽象类
该抽象类用于Session过程中状态的回调。
public static abstract class StateCallback {
//摄像头完成配置，可以处理Capture请求了。
public abstract void onConfigured(@NonNull CameraCaptureSession session);
//摄像头配置失败
public abstract void onConfigureFailed(@NonNull CameraCaptureSession session);
//摄像头处于就绪状态，当前没有请求需要处理
public void onReady(@NonNull CameraCaptureSession session) {}
//摄像头正在处理请求
public void onActive(@NonNull CameraCaptureSession session) {}
//请求队列中为空，准备着接受下一个请求。
public void onCaptureQueueEmpty(@NonNull CameraCaptureSession session) {}
//会话被关闭
public void onClosed(@NonNull CameraCaptureSession session) {}
//Surface准备就绪
public void onSurfacePrepared(@NonNull CameraCaptureSession session,@NonNull Surface surface) {}
}接下来，是介绍拍照和录像流程步骤。
使用流程:
1. 打开指定的方向的相机
最先获取CameraManager对象，通过该对象的getCameraIdList()获取到一些列的摄像头参数。
通过循环匹配，获取到指定方向的摄像头，例如后摄像头等。
CameraManager manager = (CameraManager)getSystemService(Context.CAMERA_SERVICE);
//获取到可用的相机
for (String cameraId : manager.getCameraIdList()) {
//获取到每个相机的参数对象，包含前后摄像头，分辨率等
CameraCharacteristics cameraCharacteristics = manager.getCameraCharacteristics(cameraId);
//摄像头的方向
Integer facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
if(facing==null){
continue;
}
//匹配方向,指定打开后摄像头
if(facing!=CameraCharacteristics.LENS_FACING_BACK){
continue;
}
//打开指定的摄像头
manager.openCamera(mCameraId, stateCallback, workThreadManager.getBackgroundHandler());
return;
}当然，实际开发中，还需要获取相机支持的特性(闪光灯，zoom调焦,手动调焦等)，和设置摄像头的参数（例如：预览的Size）。
2. 创建预览的界面：
创建 CameraDevice.StateCallback 对象，且开启一个相机。当相机开启后，将出现相机预览界面。
CameraDevice.StateCallback 对象传入CameraManager中openCamera(mCameraId, stateCallback, workThreadManager.getBackgroundHandler())的第二个参数，用于监听摄像头的状态。
/**
* 相机设备
*/
protected CameraDevice mCameraDevice;
/**
* 当相机设备的状态发生改变的时候，将会回调。
*/
protected final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
/**
* 当相机打开的时候，调用
* @param cameraDevice
*/
@Override
public void onOpened(@NonNull CameraDevice cameraDevice) {
mCameraDevice = cameraDevice;
createCameraPreviewSession();
}
// 省略该状态接口的部分方法
...............
};
/**
* 预览请求的Builder
*/
private CaptureRequest.Builder mPreviewRequestBuilder;
/**
* 相机开始预览，创建一个CameraCaptureSession对象
*/
private void createCameraPreviewSession() {
// 将CaptureRequest的构建器与Surface对象绑定在一起
mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
// 为相机预览，创建一个CameraCaptureSession对象
mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()), stateCallback, null);
}
创建完预览的界面后，接下来需要开始刷新。
3. 在预览界面过程中，需要间隔刷新界面
相机预览使用TextureView来实现。创建一个CameraCaptureSession ，通过一个用于预览界面的CaptureRequest，间隔复用给CameraCaptureSession。
private CameraCaptureSession mCaptureSession;
CameraCaptureSession.StateCallback stateCallback=new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
//当cameraCaptureSession已经准备完成，开始显示预览界面
mCaptureSession = cameraCaptureSession;
setCameraCaptureSession();
}
//省略该接口的部分方法
.......
}
/**
* 设置CameraCaptureSession的特征:
* <p>
* 自动对焦，闪光灯
*/
private void setCameraCaptureSession() {
//设置预览界面的特征，通过mPreviewRequestBuilder.set()方法,例如，闪光灯，zoom调焦等
..........
//为CameraCaptureSession设置间隔的CaptureRequest，用间隔刷新预览界面。
mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), mCaptureCallback, workThreadManager.getBackgroundHandler());
}只要未开始拍照动作或者录像动作，该复用的CaptureRequest会重复的刷新预览界面。
接下来，等待用户点击拍照按钮或者录像按钮，进行拍照动作，或者录像动作。
4. 拍照动作：
首先锁住焦点，通过在相机预览界面个性CaptureRequest。然后，以类似方式，需要运行一个预捕获序列。接下来，可已经准备好捕捉图片。创建一个新的CaptureRequest，且拍照。
/**
* 拍照一个静态的图片
* ,当在CaptureCallback监听器响应的时候调用该方法。
* <p>
* 当数字调焦缩放的时候，在写入图片数中也要设置。
*/
private void captureStillPicture() {
try {
// 创建一个拍照的CaptureRequest.Builder
final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
captureBuilder.addTarget(imageReader.getSurface());
//设置一系列的拍照参数，这里省略
...........
//先停止以前的预览状态
mCaptureSession.stopRepeating();
mCaptureSession.abortCaptures();
//执行拍照动作
mCaptureSession.capture(captureBuilder.build(), captureCallback, null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}拍照界面产生的数据只是在手机内存中，图片是一个磁盘文件，还需要一个将拍照产生数据写入文件中的操作类ImageReader。
先是创建ImageReader对象，和设置监听器等一些列参数。
/**
* 处理静态图片的输出
*/
private ImageReader imageReader;
//对于静态图片，使用可用的最大值来拍摄。
Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizeByArea());
//设置ImageReader,将大小，图片格式
imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/2);
imageReader.setOnImageAvailableListener(onImageAvailableListener, workThreadManager.getBackgroundHandler());
接下来，将ImageReader的surface配置到captureBuilder对象中captureBuilder.addTarget(imageReader.getSurface());
最后，当拍照完成后，会在该监听状态中回调：
/**
* ImageReader的回调监听器
* <p>
* onImageAvailable被调用的时候，已经拍照完，准备保存的操作
* 通常写入磁盘文件中。
*/
protected final ImageReader.OnImageAvailableListener onImageAvailableListener = (ImageReader reader)
-> writePictureData(reader.acquireNextImage());
public void writePictureData(Image image) {
if (camera2ResultCallBack != null) {
camera2ResultCallBack.callBack(ObservableBuilder.createWriteCaptureImage(appContext, image));
}
}
/**
* 将JPEG图片的数据，写入磁盘中
*
* @param context
* @param mImage
* @return
*/
public static Observable<String> createWriteCaptureImage(final Context context, final Image mImage) {
Observable<String> observable = Observable.create(subscriber -> {
File file = FileUtils.createPictureDiskFile(context, FileUtils.createBitmapFileName());
ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
byte[] bytes = new byte[buffer.remaining()];
buffer.get(bytes);
FileOutputStream output = null;
try {
output = new FileOutputStream(file);
output.write(bytes);
} catch (IOException e) {
e.printStackTrace();
} finally {
mImage.close();
if (null != output) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
subscriber.onNext(file.getAbsolutePath());
});
return observable;
}
这里采用RxJava+RxAndroid异步通讯，避免太多回调接口。
5. 录像动作
录像是长时间的动作，录像过程中需要重复性的刷新录制界面。其余的步骤和拍照动作基本类似。
/**
* 开始视频录制。
*/
private void startRecordingVideo() {
try {
//创建录制的session会话中的请求
mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
//设置录制参数，这里省略
.........
// Start a capture session
// Once the session starts, we can update the UI and start recording
mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
mPreviewSession = cameraCaptureSession;
Log.i(TAG, " startRecordingVideo 正式开始录制 ");
updatePreview();
}
//该接口的方法，部分省略
.............
}, workThreadManager.getBackgroundHandler());
} catch (CameraAccessException | IOException e) {
e.printStackTrace();
}
}
//录制过程中，不断刷新录制界面
private void updatePreview() {
try {
mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, workThreadManager.getBackgroundHandler());
} catch (CameraAccessException e) {
e.printStackTrace();
}
}和拍照类似，将视频数据写入磁盘文件中，也是需要一个操作类 MediaRecorder来实现的。
先是创建该操作类对象，设置一些列参数：
/**
* MediaRecorder
*/
private MediaRecorder mMediaRecorder;
/**
* 设置媒体录制器的配置参数
* <p>
* 音频，视频格式，文件路径，频率，编码格式等等
*
* @throws IOException
*/
private void setUpMediaRecorder() throws IOException {
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mNextVideoAbsolutePath = FileUtils.createVideoDiskFile(appContext, FileUtils.createVideoFileName()).getAbsolutePath();
mMediaRecorder.setOutputFile(mNextVideoAbsolutePath);
mMediaRecorder.setVideoEncodingBitRate(10000000);
//每秒30帧
mMediaRecorder.setVideoFrameRate(30);
mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight());
mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
switch (mSensorOrientation) {
case SENSOR_ORIENTATION_DEFAULT_DEGREES:
mMediaRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(rotation));
break;
case SENSOR_ORIENTATION_INVERSE_DEGREES:
mMediaRecorder.setOrientationHint(ORIENTATIONS.get(rotation));
break;
default:
break;
}
mMediaRecorder.prepare();
}间隔性的随着视频录制而输出数据到文件中。
// 为 MediaRecorder设置Surface
Surface recorderSurface = mMediaRecorder.getSurface();
surfaces.add(recorderSurface);
mPreviewBuilder.addTarget(recorderSurface);最后，当录制视频结束后，停止输出：
// 停止录制
mMediaRecorder.stop();
mMediaRecorder.reset();6. 恢复到预览界面：
完成一些列拍照或录像动作后,重新恢复到预览界面。
/**
* 完成一些列拍照或录像动作后，释放焦点。
*/
private void unlockFocus() {
try {
//向session重新发送，预览的间隔性请求，出现预览界面。
mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, workThreadManager.getBackgroundHandler());
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
当然，还有关闭相机操作，和与Activity生命周期绑定的操作，这里不再做介绍了。
以上代码来源于，Camera2App项目。
下一篇，开始介绍，如何开发一个真正的相机程序。
资源参考：