Android之camera1和2的简单使用-Toy模板网

这篇具有很好参考价值的文章主要介绍了Android之camera1和2的简单使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

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

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

每个版本也有一些重要的更新点，需要的时候搜一下Android开发者官网即可。今天先对比下老旧的camera1和camera2。

Camera1 预览、拍照

首先，先申请权限：

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

<uses-feature
android:name="android.hardware.camera"
android:required="true" />
获取相机个数

一般手机中，都有前置摄像头和后置摄像头，我们可以根据 Camera 的 getNumberOfCameras() 方法，来获取这些信息。比如：

//获取相机个数
int numberOfCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numberOfCameras; i++) {
Camera.CameraInfo info = new Camera.CameraInfo();
//获取相机信息
Camera.getCameraInfo(i, info);
//前置摄像头
if (Camera.CameraInfo.CAMERA_FACING_FRONT == info.facing) {
mFrontCameraId = i;
mFrontCameraInfo = info;
} else if (Camera.CameraInfo.CAMERA_FACING_BACK == info.facing) {
mBackCameraId = i;
mBackCameraInfo = info;
}
}

可以看到，通过 Camera.getCameraInfo(i, info) 就可以拿到当前的 CameraInfo 的信息，里面有个参数我们需要注意一下，就是 facing，它表示当前摄像机面对的方向，理解为前置和后置，然后我们把这些信息也保存起来。

打开摄像头

接着，我们可以使用 Camera.open(cameraid) 去打开摄像头

//根据 cameraId 打开不同摄像头
mCamera = Camera.open(cameraId);
打开我们的摄像头之后，可以对它进行一些配置，比如设置预览方向等，这个话题我们等到下面出现了再说。

配置摄像头属性

在开启相机预览之前，我们需要对相机进行一些参数配置，比如聚焦，预览尺寸等；这里我使用的是 SurfaceView，所以等SurfaceView 创建好之后，可以对它进行一些参数的设置：

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

# startPreview
private void startPreview(int width, int height) {
//配置camera参数
initPreviewParams(width, height);
//设置预览 SurfaceHolder
Camera camera = mCamera;
if (camera != null) {
try {
camera.setPreviewDisplay(mSurfaceView.getHolder());
} catch (IOException e) {
e.printStackTrace();
}
}
//开始显示
camera.startPreview();
}

在Camra 中，我们可以通过 camera.getParameters() 拿到相机默认的参数，如果要配置自己的参数，可以使用 camera.setParameters(parameters) 去设置，不过这个比较比较好使，所以相机的配置开启这些，可以使用 HandlerThread 去开启，这里就不增加多余代码了。
initPreviewParams 的完整代码如下：

private void initPreviewParams(int shortSize, int longSize) {
Camera camera = mCamera;
if (camera != null) {
Camera.Parameters parameters = camera.getParameters();
//获取手机支持的尺寸
List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
Camera.Size bestSize = getBestSize(shortSize, longSize, sizes);
//设置预览大小
parameters.setPreviewSize(bestSize.width, bestSize.height);
//设置图片大小，拍照
parameters.setPictureSize(bestSize.width, bestSize.height);
//设置格式,所有的相机都支持 NV21格式
parameters.setPreviewFormat(ImageFormat.NV21);
//设置聚焦
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);

camera.setParameters(parameters);
}
}

相机预览大小

首先，应该根据自己UI的大小去设置相机预览的大小，如果你的控件为 200x200，但相机的数据为 1920x1080 ，这样填充过去，画面肯定是会被拉伸的。所以，可以通过

List<Camera.Size> sizes = parameters.getSupportedPreviewSizes()
拿到手机相机支持的所有尺寸；所以，我们需要找到比例相同，或者近似的大小，跟UI配合，这样画面才不会拉伸，注意相机的 width > height，所以获取一个最佳的预览尺寸可以这样写：

/**
* 获取预览最后尺寸
*/
private Camera.Size getBestSize(int shortSize, int longSize, List<Camera.Size> sizes) {
Camera.Size bestSize = null;
float uiRatio = (float) longSize / shortSize;
float minRatio = uiRatio;
for (Camera.Size previewSize : sizes) {
float cameraRatio = (float) previewSize.width / previewSize.height;

//如果找不到比例相同的，找一个最近的,防止预览变形
float offset = Math.abs(cameraRatio - minRatio);
if (offset < minRatio) {
minRatio = offset;
bestSize = previewSize;
}
//比例相同
if (uiRatio == cameraRatio) {
bestSize = previewSize;
break;
}

}
return bestSize;
}

当 UI 的比例跟相机支持的比例相同，直接返回，否则则找近似的。

效果如下：

发现预览的方向是反的；这个时候就需要使用 setDisplayOrientation() 去设置预览方向了。

调整预览方向
首先，在调整预览方向钱，我们需要先了解一些知识。

屏幕坐标： Android 坐标系中，在（0,0）坐标那，向右为 x 轴，向下为 y 轴。
自然方向：设置的自然方向，比如手机默认就是竖直是自然方向，平板的话，横向就是自然方向
图片传感器方向：手机的图片数据都来自摄像头硬件传感器，这个传感器有个默认的方向，一般是手机是横向的，这就跟手机的自然方向成 90° 关系了。

所以，我们要做的就是，就是把传感器拿到的图片，进行一个角度的变化，使图像能跟自然方向一致：

所以，我们的方向调整可以这样写：

private void adjustCameraOrientation(Camera.CameraInfo info) {
//判断当前的横竖屏
int rotation = getWindowManager().getDefaultDisplay().getRotation();

int degress = 0;
//获取手机的方向
switch (rotation) {
case Surface.ROTATION_0:
degress = 0;
break;
case Surface.ROTATION_90:
degress = 90;
break;
case Surface.ROTATION_180:
degress = 180;
break;
case Surface.ROTATION_270:
degress = 270;
break;
}
int result = 0;
//后置摄像头
if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
result = (info.orientation - degress + 360) % 360;
} else if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
//先镜像
result = (info.orientation + degress) % 360;
result = (360 - result) % 360;
}
mCamera.setDisplayOrientation(result);

}

最后可得：

切换摄像头

现在用到的都是后置摄像头，切换也比较简单，首先先释放相机支援，然后再从配置参数，预览再来一遍即可：

//关闭摄像头
closeCamera();

mCameraID = mCameraID == mFrontCameraId ? mBackCameraId : mFrontCameraId;
//打开相机
openCamera(mCameraID);
//开启预览
startPreview(mSurfaceView.getWidth(), mSurfaceView.getHeight());

#closeCamera
private void closeCamera() {
//停止预览
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}

拍照及调整图片方向

Camera 的拍照也比较简单，使用 takePicture(ShutterCallback shutter, PictureCallback raw， PictureCallback jpeg) 方法即可，它的三个参数如下：

ShutterCallback ：拍照瞬间调用，如果空回调，则由声音，传 null ，则没效果
PictureCallback ：图片的原始数据，即没处理过的
PictureCallback ：图片的 JPEG 数据
拿到 byte 数据后，转换成bitmap即可，如下：

Camera camera = mCamera;
camera.takePicture(new Camera.ShutterCallback() {
@Override
public void onShutter() {

}
}, null, new Camera.PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera) {
new SavePicAsyncTask(data).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
});
这里的图片保存，用一个 AsyncTask 来保存：

/**
* 保存图片
*/
class SavePicAsyncTask extends AsyncTask<Void, Void, File> {

byte[] data;
File file;

public SavePicAsyncTask(byte[] data) {
this.data = data;
File dir = new File(Constants.PATH);
if (!dir.exists()) {
dir.mkdirs();
}
String name = "test.jpg";
file = new File(dir, name);
}

@Override
protected File doInBackground(Void... voids) {
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
if (bitmap == null) {
return null;
}
FileOutputStream fos = null;
try {
fos = new FileOutputStream(file);
//保存之前先调整方向
Camera.CameraInfo info = mCameraID == mFrontCameraId ? mFrontCameraInfo : mBackCameraInfo;
if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
bitmap = BitmapUtils.rotate(bitmap, 90);
} else {
bitmap = BitmapUtils.rotate(bitmap, 270);
}
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);

} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
CloseUtils.close(fos);
}
return file;
}

@Override
protected void onPostExecute(File file) {
super.onPostExecute(file);
if (file != null) {
Toast.makeText(Camera1Activity.this, "图片保存成功", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(Camera1Activity.this, "图片保存失败", Toast.LENGTH_SHORT).show();
}
}
}

#BitmapUtils#rotate
public static Bitmap rotate(Bitmap bitmap,float degress){
Matrix matrix = new Matrix();
matrix.postRotate(degress);
return Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
}

当拿到 byte[] 数据时，使用 BitmapFactory.decodeByteArray 解析 bitmap ，但此时的图片也是不对的，需要对它进行一个旋转，如上所示，这样，我们的拍照就也完成了。

Camera2 的使用
从功能来讲，Camera2 废弃了 Camera1 的框架，它支持更多的功能，比如：

获取更多的帧(预览/拍照)信息，以及每一帧的参数配置
支持更多的图片格式(yuv/raw)等
一些新特性
…
Pipeline

Camera2 的将摄像头包装成管道(Pipeline)，它会捕获单个帧的输入请求，每个请求捕获单个图像，然后把这些数据包装成数据包，从而把这些图像数据输出到图片缓冲区中。

这些请求时按顺序处理的，它按顺序处理每一帧的请求，并返回请求结果给客户端，看下面这张图：

假设我们要同时拍摄两张不同尺寸的图片，那么它的过程应该是这样的：

创建一个用于 Pipeline 获取图片信息的 CaptureRequest
创建两个不同的 Surface ，用来接收图片数据，并把他们加到 CaptureRequest 中
发送配置好的的 CaptureRequest 到Pipeline 中，等待返回拍照结果
上面需要记住的是，CaptureReuqest 创建之前，我们已经把相机的数据都配置好，比如聚焦、闪光灯等，接着才把它输入给 Camrea2 的底层，它会被放入到一个被叫做 In-Flight Capture Queue 的队列中，当 In-Flight Capture Queue 队列空闲时，我们就可以从它拿到不同的图片数据给到Surface ，且能拿到CaptureResult 这个返回结果信息。

Supported Hardware Level

我们支持，Camera 支持了很多新功能的特性，但这也要看你的手机厂商的支持程度，所以，为了方便区分，Camera2 使用 Supported Hardware Level 来判断你是否支持 Camera2 的特性，它分为4个登记：

LEGACY ：向后兼容模式，支持Camera1 的功能，不支持 Camera2 的新特性
LIMITED ：除了支持 Camera1 的特性，还支持部分 Camera2 的高级特性
FULL ：支持所有 Camera2 的高级特性
LEVEL_3 ：新增更多的 Camera2 特性，利于YUV 数据等
再了解一些主要的开发类:

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 的开发。

相机预览

申请权限

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

<uses-feature
android:name="android.hardware.camera"
android:required="true" />
<uses-feature android:name="android.hardware.camera.autofocus" />
简单流程如下：

通过context.getSystemService(Context.CAMERA_SERVICE) 获取CameraManager.
通过 getCameraCharacteristics() 方法，拿到相机的所有信息，比如支持的预览大小，level 等
通过 CameraManager 的 openCamera() 方法，从回调中拿到 CameraDevice ，它表示当前相机设备
CameraDevice 通过 createCaptureRequest 创建 CaptureRequest.Builder ，用来配置相机属性，通过 createCaptureSession 创建 CameraCaptureSession ，它是 Pipeline 的实例，然后交给底层处理
获取相机信息

通过 CameraManager 的 getCameraCharacteristics() 方法，来获取相机的信息；CameraManager 是一个负责查询和建立相机连接的系统服务，它的功能不多，主要如下：

将相机信息装载到 CameraCharacteristics 中。
根据指定的相机ID 连接相机
提供将闪光灯设置为手电筒的快捷方式
所以它的代码如下：

try {
//获取相机服务 CameraManager
mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

//遍历设备支持的相机 ID ，比如前置，后置等
String[] cameraIdList = mCameraManager.getCameraIdList();
for (String cameraId : cameraIdList) {
// 拿到装在所有相机信息的 CameraCharacteristics 类
CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
//拿到相机的方向，前置，后置，外置
Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);

if (facing != null) {
//后置摄像头
if (facing == CameraCharacteristics.LENS_FACING_BACK) {
mBackCameraId = cameraId;
mBackCameraCharacteristics = characteristics;
}else if (facing == CameraCharacteristics.LENS_FACING_FRONT){
//前置摄像头
mFrontCameraId = cameraId;
mFrontCameraCharacteristics = characteristics;
}
mCameraId = cameraId;
}

//是否支持 Camera2 的高级特性
Integer level = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
/**
* 不支持 Camera2 的特性
*/
if (level == null || level == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY){
// Toast.makeText(this, "您的手机不支持Camera2的高级特效", Toast.LENGTH_SHORT).show();
// break;
}

}

} catch (CameraAccessException e) {
e.printStackTrace();
}

上面的注释都很清晰了，我们是通过 CameraCharacteristics 去知道当前的相机方向；除了这些，它还包含相机的其他信息，比如：

是否有闪光灯 FLASH_INFO_AVAILABLE
是否有 AE 模式 CONTROL_AE_AVAILABLE_MODES
光爆等，如果你对 Camera1 比较熟悉，那么 CameraCharacteristics 有点像 Camera1 的 Camera.CameraInfo 或者 Camera.Parameters
打开摄像头

比 Camera1 好的就是，Camera2 在打开摄像头之前，就可以进行参数的配置，比如预览尺寸等。
我们知道，摄像头需要 Surface 来装载数据，这里使用的是 TextureView 来装载：

mTextureView = findViewById(R.id.surface);
所以，当它创建完成拿到宽高之后，我们就可以打开摄像头了：

private void openCamera(int width, int height) {
//判断不同摄像头，拿到 CameraCharacteristics
CameraCharacteristics characteristics = mCameraId.equals(mBackCameraId) ? mBackCameraCharacteristics : mFrontCameraCharacteristics;
//拿到配置的map
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

//获取摄像头传感器的方向
mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
//获取预览尺寸
Size[] previewSizes = map.getOutputSizes(SurfaceTexture.class);
//获取最佳尺寸
Size bestSize = getBestSize(width, height, previewSizes);
/**
* 配置预览属性
* 与 Cmaera1 不同的是，Camera2 是把尺寸信息给到 Surface (SurfaceView 或者 ImageReader)，
* Camera2 会根据 Surface 配置的大小，输出对应尺寸的画面;
* 注意摄像头的 width > height ，而我们使用竖屏，所以宽高要变化一下
*/
mTextureView.getSurfaceTexture().setDefaultBufferSize(bestSize.getHeight(),bestSize.getWidth());

/**
* 设置图片尺寸，这里图片的话，选择最大的分辨率即可
*/
Size[] sizes = map.getOutputSizes(ImageFormat.JPEG);
Size largest = Collections.max(
Arrays.asList(sizes),
new CompareSizesByArea());
//设置imagereader，配置大小，且最大Image为 1，因为是 JPEG
mImageReader = ImageReader.newInstance(largest.getWidth(),largest.getHeight(),
ImageFormat.JPEG,1);

//拍照监听
mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);

try {
//打开摄像头，监听数据
mCameraManager.openCamera(mCameraId,new CameraDeviceCallback(),null);
} catch (CameraAccessException e) {
e.printStackTrace();
}

}

在用 mCameraManager.openCamera() 打开摄像头之前，我们通过

//拿到配置的map
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
拿到可用的map，这样就可以通过 getOutputSizes() 等拿到相机支持的所有尺寸了，通过前面的camera1也解释了，为啥要有最佳尺寸，不然会有图片拉伸的问题。

而与 Camera1 不同的是，Camera2 会根据 Surface 配置的大小，输出对应尺寸的画面，所以这里设置 mTextureView 的大小即可，注意摄像头的 width > height ，而我们使用竖屏，所以宽高要变化一下。

接着设置图片的尺寸，这里当然是越轻越好了，所以选择最大尺寸即可。ImageReader 等到后面拍照时再讲解。

最后调用 mCameraManager.openCamera() ，它有三个参数：

cameraId ：Camera 的 ID，比如前置、后置和外置
CameraDevice.StateCallback ：当连接到相机时，该回调就会被调用，生成 CameraDevice
handler ：调用 CameraDevice.StateCallback 的 Handler，传null，则调用主线程，建议传入 HandlerThread 的hander，毕竟这种都是耗时的。
CameraDevice

CameraDevice 表示当前的相机设备，它的主要职责有:

根据指定的参数创建 CameraCaptureSession
根据指定的模板创建 CaptureRequest
关闭相机设备
监听相机状态，比如断开，开启成功失败的监听
如下：

class CameraDeviceCallback extends CameraDevice.StateCallback{

@Override
public void onOpened(@NonNull CameraDevice camera) {
mCameraDevice = camera;
//此时摄像头已经打开，可以预览了
createPreviewPipeline(camera);
}

@Override
public void onDisconnected(@NonNull CameraDevice camera) {
camera.close();
}

@Override
public void onError(@NonNull CameraDevice camera, int error) {
camera.close();
}
}

在 onOpened 创建我们CaptureRequest ，配置相机参数信息，如下：

private void createPreviewPipeline(CameraDevice cameraDevice){
try {
//创建作为预览的 CaptureRequst.builder
final CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
Surface surface = new Surface(mTextureView.getSurfaceTexture());
//添加 surface 容器
captureBuilder.addTarget(surface);
// 创建CameraCaptureSession，该对象负责管理处理预览请求和拍照请求,这个必须在创建 Seesion 之前就准备好，传递给底层用于遏制 pipeline
cameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
mCameraCaptureSession = session;
try {
//设置自动聚焦
captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//设置自动曝光
captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

//创建 CaptureRequest
CaptureRequest build = captureBuilder.build();
//设置预览时连续捕获图片数据
session.setRepeatingRequest(build,null,null);
}catch (Exception e){

}
}

@Override
public void onConfigureFailed(@NonNull CameraCaptureSession session) {
Toast.makeText(Camera2Activity.this, "配置失败", Toast.LENGTH_SHORT).show();
}
},null);
} catch (Exception e) {
e.printStackTrace();
}
}

在开启预览之前，我们需要先创建 CaptureRequest ，上面已经说过 CaptureRequest 是向 CameraCaptureSession 提交 Capture 请求的信息载体，内部包含了本次的 Capture 参数配置和接受图像数据的 Surface。

CaptureRequest 可以配置的信息非常多，比如图像格式、图像分辨率、聚焦、闪光灯控制等，可以说绝大部分配置都是通过 CaptureRequest 配置的。

上面通过 cameraDevice.createCaptureRequest() 来创建一个 CaptureRequest.Builder 对象，其中createCaptureRequest() 方法的参数是 templateType 用于指定哪种模板，Camera2 根据不同场景，为我们配置了一些常用的参数模板：

TEMPLATE_PREVIEW：适用于配置预览的模板
TEMPLATE_RECORD：适用于视频录制的模板。
TEMPLATE_STILL_CAPTURE：适用于拍照的模板。
TEMPLATE_VIDEO_SNAPSHOT：适用于在录制视频过程中支持拍照的模板。
TEMPLATE_MANUAL：适用于希望自己手动配置大部分参数的模板。
这里我们需要一个预览的 CaptureRequest ，所以选择 TEMPLATE_PREVIEW的模板。

接着，需要设置要承载图像数据的 Surface，我们用到两个，一个是 TextureView 用来预览的，一个是 ImageReader 用来拍照的。

由于这个 CaptureRequest 是用来预览的，所以通过 addTarget 设置进去。最后通过 cameraDevice.createCaptureSession() 创建 CameraCaptureSession ，然后再配置一下聚焦和曝光的配置，就可以把 CaptureRequest 通过 Session 发送给底层了。

开启和关闭预览

在 Camera2 中，本质上是不断的重复 Captrue 的过程，每一次 Capture 都会把预览的数据输出到对应的 Surface 中，所以，为了达到预览的效果，需要使用：

session.setRepeatingRequest(build,null,null);
它的三个参数如下：

request ：在不断重复执行 Capture 时使用的 CaptureRequest 对象
callback ：监听每一次 Capture 状态的 CameraCaptureSession.CaptureCallback 对象，例如 onCaptureStarted() 意味着一次 Capture 的开始，而 onCaptureCompleted() 意味着一次 Capture 的结束。
handler ：用于执行 CameraCaptureSession.CaptureCallback 的Handler 对象，传null为主线程，也可以使用其他线程的 Handler
关闭预览

通过上面的理解，关闭预览也很简单啦：

//停止预览
mCameraCaptureSession.stopRepeating();
拍照

上面我们学习了预览，也提到了 ImageReader 是用来接收图像数据的，那怎么拍照呢？

拍照其实也是一个 Captrue，这样的话，我们就可以再创建一个 CaptureRequest 去执行拍照的就可以了，代码如下：

//创建一个拍照的 session
final CaptureRequest.Builder captureRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
//设置装在图像数据的 Surface
captureRequest.addTarget(mImageReader.getSurface());
//聚焦
captureRequest.set(CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//自动曝光
captureRequest.set(CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
// 获取设备方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
// 根据设备方向计算设置照片的方向
captureRequest.set(CaptureRequest.JPEG_ORIENTATION
, getOrientation(rotation));
// 先停止预览
mCameraCaptureSession.stopRepeating();

代码比较好理解，只是通过 mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE) 创建了一个拍照的模板，而且在执行拍照之前，先停止预览。

接着就可以使用 mCameraCaptureSession.capture() 执行拍照了：

mCameraCaptureSession.capture(captureRequest.build(), new CameraCaptureSession.CaptureCallback() {
@Override
public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
super.onCaptureCompleted(session, request, result);
try {
//拍完之后，让它继续可以预览
CaptureRequest.Builder captureRequest1 = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
captureRequest1.addTarget(new Surface(mTextureView.getSurfaceTexture()));
mCameraCaptureSession.setRepeatingRequest(captureRequest1.build(),null,null);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
},null);
可以看到，当拍照结束的时候，我们又让它重新预览了，当然这里也看你的需求去设置。

保存图片

那保存图片在哪里弄呢？还记得我们在打开摄像头的时候，配置了 ImageReader 监听：

//拍照监听
mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);
在保存之前，我们先来了解一下，什么是 ImageReader

ImageReader

在 Camrea2 中，Imagereader 是获取图像数据的一个重要途径，我们可以通过它获取各种各样格式的图像数据，比如 JPEG、YUV和 RAW 等。通过 ImageReader.newInstance() 方法创建 ImageReader 对象，如下：

//设置imagereader，配置大小，且最大Image为 1，因为是 JPEG
mImageReader = ImageReader.newInstance(largest.getWidth(),largest.getHeight(),
ImageFormat.JPEG,1);
mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);
其中前面两个号理解，第三个参数，则是你要获取的图像数据的格式，这里使用 JPEG 即可，而最后一个参数，则表示最大 Image 的个数，可以理解成图像池的大小。

当有图像数据生成时，就是调用 ImageReader.OnImageAvailableListener 里面的 onImageAvailable() 方法

/**
* 拍照监听,当有图片数据时，回调该接口
*/
class ImageAvailable implements ImageReader.OnImageAvailableListener{

@Override
public void onImageAvailable(ImageReader reader) {
new SavePicAsyncTask(reader).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
}
接着，我们可以调用 ImageReader 的acquireNextImage()方法，来获取存有最新的 Image 对象，而 Image 对象里的图像数据又根据不同格式被划分成多个部分，分别存储在单独的 Plane 对象里，我们可以调用 Image.getPalnes() 获取所有有的 Palne 对象的数组，如下：

//获取捕获的照片数据
Image image = imageReader.acquireLatestImage();
//拿到所有的 Plane 数组
Image.Plane[] planes = image.getPlanes();
最后则通过 Plane.getBuffer() 获取每一个在 Plane 里存储的图像数据 ByteBuffer。比如

格式   Image个数   Plane 层级
JPEG   1   压缩过的数据，所以行数为0，解压缩需要使用BitmapFactory#decodeByteArray
YUV   3   一个明度通道+两个色彩CbCr通道，UV的宽高是Y的一半。
YUV 可以用下图来表示

所以，我们获取的图片如下：

FileOutputStream fos = null;
Image image = null;
try {
fos = new FileOutputStream(file);
//获取捕获的照片数据
image = imageReader.acquireLatestImage();
//拿到所有的 Plane 数组
Image.Plane[] planes = image.getPlanes();
//由于是 JPEG ，只需要获取下标为 0 的数据即可
ByteBuffer buffer = planes[0].getBuffer();
data = new byte[buffer.remaining()];
//把 bytebuffer 的数据给 byte数组
buffer.get(data);
Bitmap bitmap = BitmapFactory.decodeByteArray(data,0,data.length);
//旋转图片
if (mCameraId.equals(mFrontCameraId)){
bitmap = BitmapUtils.rotate(bitmap,270);
bitmap = BitmapUtils.mirror(bitmap);
}else{
bitmap = BitmapUtils.rotate(bitmap,90);
}
bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos);
fos.flush();
return bitmap;
}catch (Exception e){
Log.d(TAG, "zsr doInBackground: "+e.toString());
}finally {
CloseUtils.close(fos);
//记得关闭 image
if (image != null) {
image.close();
}
}
————————————————
版权声明：本文为CSDN博主「Jason_Lee155」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Jason_Lee155/article/details/126319221文章来源地址https://www.toymoban.com/news/detail-491463.html