Android Camera2的基本使用（预览、拍照）

最新推荐文章于 2024-10-19 18:16:44 发布
最新推荐文章于 2024-10-19 18:16:44 发布
阅读量3.4k 收藏 29
点赞数 28
分类专栏： Android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56892136/article/details/134883326
版权
本文详细介绍了如何使用AndroidCamera2API获取摄像头参数，创建CameraDevice和CaptureSession，以及如何实现实时预览和拍照并获取每一帧图像。重点讨论了SensorOrientation、帧率控制和ImageReader在处理图像流中的应用。
摘要由CSDN通过智能技术生成

一、背景

需要使用Camera2来实时抓取每一帧的图像

二、Camera2相关的类

1.CameraManager

摄像头管理类，可以获取摄像头ID、摄像头支持分辨率、传感器旋转角度等摄像头信息。
同时打开关闭摄像头也需要通过这个类
以下是这个类的基本使用，用来获取摄像头信息

	private void getCameraInfo(){
		CameraManager cameraManager= (CameraManager) getSystemService(Context.CAMERA_SERVICE);
		try {
			cameraNames = cameraManager.getCameraIdList();
		} catch (CameraAccessException e) {
			throw new RuntimeException(e);
		}


		for (String cameraName : cameraNames) {
			StringBuilder info=new StringBuilder("cameraId:"+cameraName+"{\n");

			List<int[]> list=new ArrayList<>();
			CameraCharacteristics characteristics = null;
			try {
				characteristics = cameraManager.getCameraCharacteristics(cameraName);
			} catch (CameraAccessException e) {
				throw new RuntimeException(e);
			}
			int sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
			info.append("sensorOrientation:"+sensorOrientation+",\n");
			Range<Integer>[] ranges = characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
			Log.e("lkx","range:"+ Arrays.toString(ranges));
			int lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING);
			Long aLong = characteristics.get(CameraCharacteristics.SENSOR_INFO_MAX_FRAME_DURATION);
			Log.e("lkx",cameraName+":"+aLong);
			switch (lensFacing) {
				case CameraMetadata.LENS_FACING_FRONT:
					info.append("lensFacing(前后摄):"+"front"+",\n");
					break;
				case CameraMetadata.LENS_FACING_BACK:
					info.append("lensFacing(前后摄):"+"back"+",\n");
					break;
				case CameraMetadata.LENS_FACING_EXTERNAL:
					info.append("lensFacing(前后摄):"+"external"+",\n");
					break;
			}
			info.append("}\n\n");

			Size[] supportedSizes = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
				.getOutputSizes(ImageFormat.YUV_420_888);

			for (Size size : supportedSizes) {
				int width = size.getWidth();
				int height = size.getHeight();
				// 在这里处理支持的分辨率格式
				int[] temp={width,height};
				list.add(temp);
			}
			cameraInfoList.put(cameraName, String.valueOf(info));
			map.put(cameraName,list);
		}
	}

要获取摄像机的参数信息，主要是通过CameraCharacteristics这个类的get方法：
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES FPS范围
SENSOR_ORIENTATION 传感器旋转角度，有的摄像头不是0度，需要根据传感器角度去调整预览和拍照的角度
LENS_FACING 前后摄
SENSOR_INFO_MAX_FRAME_DURATION 两帧之间的间隔，单位是纳秒 使用1秒除以这个参数可以计算出帧率
SCALER_STREAM_CONFIGURATION_MAP 支持的分辨率

2.CameraDevice

用于表示连接的相机设备

该类中有一个方法
CaptureRequest.Builder createCaptureRequest(int templateType)
用于创建一个CaptureRequest
其中传入的参数需要注意：

TEMPLATE_PREVIEW : 创建预览的请求
TEMPLATE_STILL_CAPTURE: 创建一个适合于静态图像捕获的请求，图像质量优先于帧速率
TEMPLATE_RECORD : 创建视频录制的请求
TEMPLATE_VIDEO_SNAPSHOT : 创建视视频录制时截屏的请求
TEMPLATE_ZERO_SHUTTER_LAG :创建一个适用于零快门延迟的请求。在不影响预览帧率的情况下最大化图像质量
TEMPLATE_MANUAL : 创建一个基本捕获请求，这种请求中所有的自动控制都是禁用的(自动曝光，自动白平衡、自动焦点)

预览时需要传入TEMPLATE_PREVIEW

createCaptureSession
public abstract void createCaptureSession (List outputs,
CameraCaptureSession.StateCallback callback,
Handler handler)
outputs 目标Surface集
callback 创建CaptureSession的回调
handler 调用callback的线程
通过该方法创建一个CaptureSession

			mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()),
				new CameraCaptureSession.StateCallback() {
					@Override
					public void onConfigured(@NonNull CameraCaptureSession session) {
						if (mCameraDevice == null) {
							return;
						}
						cameraCaptureSession = session;
						updatePreview();
					}

					@Override
					public void onConfigureFailed(@NonNull CameraCaptureSession session) {
						Toast.makeText(MainActivity.this, "Configuration change", Toast.LENGTH_SHORT).show();
					}
				}, null);

3.CaptureRequest

表示一次操作请求，预览、拍照时都需要传入这个对象。
通过上面CameraDevice的createCaptureRequest可以获得CaptureRequest.Builder
CaptureRequest.Builder.build()就可以获得这个对象

4.CaptureRequest.Builder

CaptureRequest的构建器 通过CameraDevice的createCaptureRequest获取实例

addTarget(Surface outputTarget)
添加一个Surface到列表中作为此请求的输出目标
可以添加多个surface，但是重复添加无效

set
set(Key key, T value)
为CaptureRequest的字段设置值
例：
// 自动聚焦
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)

5.CameraCaptureSession

CameraDevice配置的一个捕获会话，调用此类的方法可以进行预览、拍照。
setRepeatingRequest(request: CaptureRequest, listener: CameraCaptureSession.CaptureCallback?, handler: Handler?)

							mCaptureSession.setRepeatingRequest(mPreviewRequest,
								mCaptureCallback, mBackgroundHandler);
								...
							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);
						
								}
						
							};

该方法创建一个无限捕捉图像的请求，可以用于预览，方法需要一个request，可传入回调函数

6.ImageReader

ImageReader类允许应用程序直接访问渲染成表面的图像数据

			mImageReader = ImageReader.newInstance(mWidth, mHeight,
				ImageFormat.YUV_420_888, /*maxImages*/60);
			mImageReader.setOnImageAvailableListener(
				mOnImageAvailableListener, mBackgroundHandler);

			//通过addTarget把imagereader的surface添加到预览的request里，这样可以实时获取每帧的图像数据
			mPreviewRequestBuilder.addTarget(mImageReader.getSurface());

	private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
		= new ImageReader.OnImageAvailableListener() {

		@Override
		public void onImageAvailable(ImageReader reader) {
		//由于添加到了预览的request，每获取到一帧图像都会回调这个方法
			Image mImage=reader.acquireNextImage();
			//获取到的image对象就是图片数据，此处可以对图片进行操作
			mImage.close(); //记得释放

		}


	};

三、Demo

此Demo仅仅实现最低需求的预览和拍照，代码需要完善。

逻辑代码

public class MainActivity extends AppCompatActivity {

	private static final String TAG = "Camera2Demo";
	private TextureView textureView;
	private CameraDevice mCameraDevice;
	private Size imageDimension;
	private CaptureRequest.Builder captureRequestBuilder;
	private CameraCaptureSession cameraCaptureSession;
	private ImageReader imageReader;

	private CaptureRequest captureRequest;


	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		initPermission(); //权限申请
		textureView = findViewById(R.id.texture_view);
		textureView.setSurfaceTextureListener(textureListener);
		CameraCaptureSession.CaptureCallback CaptureCallback
			= new CameraCaptureSession.CaptureCallback() {

			@Override
			public void onCaptureCompleted(@NonNull CameraCaptureSession session,
						       @NonNull CaptureRequest request,
						       @NonNull TotalCaptureResult result) {
				//点击拍照后调用此回调 此处弹出提示
				Toast.makeText(MainActivity.this,"Saved:xx/xx/xx/xx.jpg",Toast.LENGTH_SHORT).show();
			}
		};
		findViewById(R.id.picture).setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				try {
					//创建了一个拍照的请求
					final CaptureRequest.Builder captureBuilder =
						mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
					//与imageReader关联，当点击拍照获取到可用图片时，会触发ImageReader的回调，可在ImageReader的回调中对图片进行保存等处理
					captureBuilder.addTarget(imageReader.getSurface());
					cameraCaptureSession.capture(captureBuilder.build(),CaptureCallback,null);
				} catch (CameraAccessException e) {
					throw new RuntimeException(e);
				}
			}
		});
	}


	private final TextureView.SurfaceTextureListener textureListener =
		new TextureView.SurfaceTextureListener() {
			@Override
			public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
				Log.e(TAG, "onSurfaceTextureAvailable");
				openCamera();
			}

			@Override
			public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
				Log.e(TAG, "onSurfaceTextureSizeChanged");
			}

			@Override
			public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
				Log.e(TAG, "onSurfaceTextureDestroyed");
				return false;
			}

			@Override
			public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
				Log.e(TAG, "onSurfaceTextureUpdated");
			}
		};
	//相机状态变化时会调用这里的回调函数
	private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
		@Override
		public void onOpened(@NonNull CameraDevice camera) {
			//相机打开时执行
			Log.e(TAG, "onOpened");
			mCameraDevice=camera;
			//创建相机预览会话
			createCameraPreviewSession();
		}

		@Override
		public void onDisconnected(@NonNull CameraDevice camera) {
			//相机链接断开
		}

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

		}
	};

	private void openCamera() {
		CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
		try {
			//通过cameraId获取Camera参数
			String cameraId = cameraManager.getCameraIdList()[0];
			CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
			StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
			imageDimension=map.getOutputSizes(SurfaceTexture.class)[0];
			imageReader=ImageReader.newInstance(640,480, ImageFormat.YUV_420_888,10);
			imageReader.setOnImageAvailableListener(onImageAvailableListener,null);
			if (ActivityCompat.checkSelfPermission(this, android.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;
			}
			cameraManager.openCamera(cameraId, stateCallback, null);

		} catch (CameraAccessException e) {
			throw new RuntimeException(e);
		}
	}
	private boolean initPermission(){
		ActivityCompat.requestPermissions(MainActivity.this, new String[]{android.Manifest.permission.READ_EXTERNAL_STORAGE, android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.CAMERA}, 1);
		// 高版本Android SDK时使用如下代码
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
			if(!Environment.isExternalStorageManager()){
				Intent intent = new Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION);
				startActivity(intent);
				return false;
			}
		}



		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
			if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
				requestPermissions(new String[] {Manifest.permission.CAMERA}, 1);
				return false;
			}
		}
		return true;
	}
	private void createCameraPreviewSession(){
		SurfaceTexture surfaceTexture=textureView.getSurfaceTexture();
		assert surfaceTexture!=null;

		surfaceTexture.setDefaultBufferSize(imageDimension.getWidth(),imageDimension.getHeight());
		//预览的输出画面
		Surface surface=new Surface(surfaceTexture);

		try {
			//预览请求
			captureRequestBuilder=mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
			captureRequestBuilder.addTarget(surface);
			mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()),
				new CameraCaptureSession.StateCallback() {
					@Override
					public void onConfigured(@NonNull CameraCaptureSession session) {
						if (mCameraDevice == null) {
							return;
						}
						cameraCaptureSession = session;
						updatePreview();
					}

					@Override
					public void onConfigureFailed(@NonNull CameraCaptureSession session) {
						Toast.makeText(MainActivity.this, "Configuration change", Toast.LENGTH_SHORT).show();
					}
				}, null);
		} catch (CameraAccessException e) {
			throw new RuntimeException(e);
		}


	}
	private void updatePreview(){
		captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
		captureRequest = captureRequestBuilder.build();

		try {
			cameraCaptureSession.setRepeatingRequest(captureRequest,null,null);
		} catch (CameraAccessException e) {
			throw new RuntimeException(e);
		}
	}
	private final ImageReader.OnImageAvailableListener onImageAvailableListener=
		new ImageReader.OnImageAvailableListener() {
			@Override
			public void onImageAvailable(ImageReader reader) {
				Image image=null;
				image=reader.acquireLatestImage();
				Log.e("lkx","1");
				//此处可对图片进行处理 比如保存到本地
				image.close();
			}
		};
}

布局文件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:orientation="vertical">

    <TextureView
        android:id="@+id/texture_view"
        android:layout_width="match_parent"
        android:layout_height="588dp"></TextureView>

    <Button
        android:id="@+id/picture"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:text="take_photo" />

</LinearLayout>

效果展示

在这里插入图片描述
启动apk，是一个预览框和一个拍照按钮

在这里插入图片描述
点击拍照，会弹出提示框
在这里插入图片描述
log也打印了，imageReader的回调正常调用

四、思考

对于刚开始提出来的需求，需要对每一帧图像进行实时抓取。通过这个demo我们不难发现，imageReader是通过addTarget添加到了拍照这个请求上，每次点击拍照，会生成一个可用图像，有了可用对象才会触发imageReader的回调。既然这样我们可以将imageReader通过addTarget绑定到预览的那个请求上，预览是无限获取每一帧的图像，每一帧都是一个可用图像，那么每一帧就都可以触发imageReader的回调函数，这样就可以在回调函数中对每一帧的图像进行处理。
需要注意，获取图像的帧率受很多因素影响，图片过大会使帧数降低，使用使应该尽量保证图片尺寸较小。初始化ImageReader时，newInstance方法的最后一个参数maxImage如果太小也会影响帧数。同时，也应该尽量保证对每一帧的图像数据处理耗时较低，可以通过Handler交给其他线程完成耗时任务。

The maxImages parameter determines the maximum number of Image objects that can be be acquired from the ImageReader simultaneously. Requesting more buffers will use up more memory, so it is important to use only the minimum number necessary for the use case.

上面是谷歌对maxImages这个参数的解释，翻译为中文：
maxImages参数决定可以同时从ImageReader获取的图像对象的最大数量。请求更多缓冲区将消耗更多内存，因此仅使用用例所需的最小数量是很重要的。

参数小会影响帧率，参数大会消耗更多内存。这两者之间需要进行平衡。

子夜听雨
关注
专栏目录
android camera2实现实时预览和拍照
03-07
使用android studio，用camera2实现拍照并能够实时预览，并将照片存到手机里，路径代码有注释。保存格式：fpg。实现全网最简便的代码。
Android Camera2 Demo - 实现相机预览、拍照、录制视频功能
06-28
因为工作中要使用 Android Camera2 API 来实现相机功能，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，这个项目就是我研究的成果。 其中包括一个自己写的Camera2的Demo，支持预览、拍照和视频录制，以及若干个网上找的，具有参考价值的Camera2 Demo。 具体看我的博客 : https://blog.csdn.net/EthanCo/article/details/131371887 https://blog.csdn.net/EthanCo/article/details/131414981 https://blog.csdn.net/EthanCo/article/details/131418829
十分钟实现 Android Camera2 相机拍照
chuyouyinghe的专栏
09-11 415
因为工作中要使用，但因为Camera2比较复杂，网上资料也比较乱，有一定入门门槛，所以花了几天时间系统研究了下，并在CSDN上记录了下，希望能帮助到更多的小伙伴。上篇文章我们使用Camera2实现了相机预览的功能，这篇文章我们接着上文，来实现Camera2相机拍照的功能。
Android实现Camera2预览和拍照效果
01-05
简介 网上对于 Camera2 的介绍有很多，在 Github 上也有很多关于 Camera2 的封装库，但是对于那些库，封装性太强，有时候我们仅仅是需要个简简单单的拍照功能而已，因此，自定义一个 Camera 使之变得轻量级那是非常重要的了。(本文并非重复造轮子, 而是在于学习 Camera2API 的基本功能, 笔记之。) 学习要点: 使用 Android Camera2 API 的基本功能。 迭代连接到设备的所有相机的特征。 显示相机预览和拍摄照片。 Camera2 API 为连接到 Android 设备的各个相机设备提供了一个界面。 它替代了已弃用的 Camera 类。 使用
Android Camera2-预览、拍照、录像流程
xiaowang_lj的博客
07-20 2186
重复模式（Repeating）：指的是不断重复执行指定的 Capture 操作，当有其他模式的 Capture 提交时会暂停该模式，转而执行其他被模式的 Capture，当其他模式的 Capture 执行完毕后又会自动恢复继续执行该模式的 Capture，例如显示预览画面就是不断 Capture 获取每一帧画面。在 Camera2 上，你可以在规定的曝光时长范围内配置拍照的曝光时间，从而实现拍摄长曝光图片，你甚至可以延长每一帧预览画面的曝光时间让整个预览画面在暗环境下也能保证一定的亮度。
Android开发 Camera2（最全代码Camera2开发）
最新发布
weixin_42504805的博客
10-19 1003
因为Camera2提供的功能更加强大,所以使用比Camera1会复杂许多.需要调用的API和回调也更多.这里简单介绍一下这些API的对应功能.好初步认识Camera2.
Android原生Camera2完成预览和拍照
01-25
Android原生Camera2完成预览和拍照，通过这个demo，可以让我们更好地了解Camera2的使用
Android Camera2使用
qq_29848853的博客
12-03 1550
Android Camera2使用
Camera2的使用【详细】
m0_57150356的博客
11-17 3059
和Camera一样，Camera2也可以使用SurfaceView作为预览视图，但Camera2和Camera不同，他并不强制你拍摄前必须预览。 SurfaceView使用时请注意，一定要在SurfaceView创建完成后再进行预览的绑定，这一点和Camera、MediaPlayer等的操作是一样的。 但Camera绑定SurfaceView设置预览时使用的是SurfaceHolder，而Camera2使用的时Surface。 SurfaceView用于显示捕获的图片，作为预览捕获请求的目标。
android camera2
10-18
一个camera2的小demo,里面只能拍照，其它的暂时不能用
Android-使用Android相机拍摄照片和视频基于camera2api
08-13
使用Android相机拍摄照片和视频，基于camera2 api
Andriod Camera2 后台服务静默定时无预览拍照
07-18
总结，这个项目展示了如何利用Android Camera2 API在后台实现定时无预览拍照，涉及了Camera2 API的深入使用、后台服务的运行机制、定时任务的调度以及资源管理等多个方面。通过这种方式，开发者可以创建更加灵活和...
Android Camera2基本使用
u013420014的博客
07-13 1734
CaptureRequest.Builder在构建一个请求时，需要注意一点，那就是添加输出surface时，可以添加多个，如果是单纯的预览，那么就只需要添加预览用的surface，如果是录像，那么就需要添加预览surface以及录像surface，同时在创建会话mCameraDevice.createCaptureSession时，第一个参数要把CaptureRequest.Builder构建时添加的surface都放入list中，因为摄像头输出时只会输出到你传入的这些surface中。
Android Camera2 使用指北
08-06 3315
android camera2学习记录
Android Camera2
zenmela2011的专栏
08-11 4319
1.Camera2 Android API 21新增了Camera2，与之前的Camera架构完全不同，使用起来也比较复杂，但是功能变得很强大。 Camera2中几个比较重要的类： ①CameraManager： 管理手机上的所有摄像头设备。它其实是一个系统服务，通过getSystemService(Context.CAMERA_SERVICE)获取，它的作用主要是获取摄像头列表和打开指定的摄像头。 通过CameraManager对象可以得到一些相机的基本信息，这个信息就存储在CameraChara
Android相机Camera2的简单分析
WonderfulMTF的博客
05-10 3955
近期学习了解Android相机的使用，如何预览及切图，看了一些资料，在github上找到了google对于Camera2使用的Demo，就这份Demo做一个个人分析理解。 示例项目中有两份代码，一份Java编写，一份Kotlin编写，将分别做分析记录。一、Java示例目录结构非常简单，只有一个Activity，一个Fragment，一个自定义View。...
Android Camera2 教程 · 第一章 · 概览
06-18 1030
从 Android 5.0 开始，Google 引入了一套全新的相机框架 Camera2（android.hardware.camera2）并且废弃了旧的相机框架 Camera1（android.hardware.Camera）。作为一个专门从事相机应用开发的开发者来说，这一刻我等了太久了，C...
android 使用 camera2 完成预览和拍照
06-26
### 回答1： 使用 camera2 API 可以更加灵活、可定制和高效地完成 Android 相机应用开发，其相比 camera1 API 的性能有大幅提升。 在使用 camera2 API 完成预览和拍照前，需要进行以下几个步骤： 1. 获取 CameraManager 对象，查找可用的摄像头列表，并选择需要打开的摄像头。 2. 创建 CameraCaptureSession 对象，用于处理相机触发器的请求，并连接 CameraDevice 和 Surface。 3. 匹配预览和图片输出的 Surface，设置相应的尺寸和格式。 4. 创建 CaptureRequest 对象，设置相应的参数，如自动对焦模式、曝光模式等。 5. 使用 CameraCaptureSession 进行预览或拍照。 在预览时，可以使用 TextureView 或 SurfaceView 进行实时数据渲染，比如显示相机预览画面、拍照后处理和显示等，同时可以通过设置监听器动态获取相机输出的图像流数据。 在拍照时，需要创建 ImageReader 对象，设置输出数据的格式和尺寸，同时需要建立对应的 Surface，将其传入 CaptureRequest.Builder，设置请求类型并发起拍照请求。通过设置 ImageReader 的 OnImageAvailableListener 接口，即可接收到图片数据，并进行后续处理和保存。 以上是使用 camera2 API 完成预览和拍照的基本流程，实际开发中需要根据具体需求进行优化和调整。 ### 回答2： Android Camera2 API 是 Android 系统中相机功能的一种全新的 API，使用 Camera2 可以更灵活地操作相机设备并获得更高质量的照片。 使用 Camera2 实现预览非常简单，我们只需要实现一个 CameraDevice.StateCallback 接口实现类和一个 SurfaceView 主界面。在 StateCallback 的 onOpened 回调中获得 CameraDevice 的实例，然后通过 ImageReader 创建 SurfaceHolder，最后将 SurfaceHolder 通过 CameraDevice.createCaptureSession 接口跟 CameraDevice 进行绑定即可实现预览。 拍照的实现过程与预览类似，首先获得 CameraDevice 实例，然后创建一个 CaptureRequest.Builder 对象，将拍照设置参数通过 CaptureRequest.Builder.set 方法设置到 CaptureRequest.Builder 对象中，最后通过 CameraCaptureSession.capture 接口启动拍照操作即可。 当然，在使用 Camera2 API 进行操作相机时，还需要注意一些其他问题，比如不同的相机设备有不同的特性，需要针对不同的设备进行优化和适配，还需要保证应用的流畅性和稳定性，以达到更好的用户体验。 总之，使用 Camera2 API 实现预览和拍照是 Android 开发的一个重要技能，需要开发者深入了解该 API 的机制和使用方式，才能更好地实现优秀的相机应用。 ### 回答3： Android中的camera2是一种相机应用程序接口（API），旨在提高相机应用程序的功能和性能。相较于早期版本的camera API，camera2 API提供了更多的控制选项，允许开发者定制相机应用程序的功能，从而实现更好的用户体验。 使用camera2 API实现预览和拍照需要以下步骤： 1. 获取CameraManager对象。使用该对象可以获取系统中可用的相机列表，并在需要的时候打开指定相机。 2. 打开指定相机。调用CameraManager.openCamera()方法打开相机。 3. 创建CaptureSession。CaptureSession是与相机关联的一组输出Surface的集合。 4. 创建CaptureRequest。CaptureRequest是一个指定相机操作和设置的重要对象，可以通过它来设置各种模式、参数和目标Surface。 5. 创建Preview Request。处理预览界面。 6. 启动相机预览。启动前，可以使用CaptureRequest.Builder设置其他预览参数。 7. 拍照。当用户点击拍照按钮时，调用CaptureSession.capture()方法，即可拍照并接收回调。 8. 关闭相机。释放所有占用的资源，以便其他应用程序可以使用相机。 总之，在使用camera2 API实现预览和拍照时，需要使用许多类和方法。但只要开发者掌握了API中的基本概念和流程，就可以自由地使用该API，设计新型的相机应用程序，提供更好的功能和性能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值