现在的手机一般都会提供相机功能，有些相机的镜头甚至支持1000万以上像素，有些甚至支持光学变焦，这些手机已经变成了专业数码相机。为了充分利用手机上的相机功能，AndroID应用可以控制拍照和录制视频。
使用AndroID 5.0的Camera v2拍照
AndroID 5.0对拍照API进行了全新的设计，新增了全新设计的Camera v2 API，这些API不仅大幅提高了AndroID系统拍照的功能，还能支持RAW照片输出，甚至允许程序调整相机的对焦模式、曝光模式、快门等。
AndroID 5.0的Camera v2主要涉及如下API。
Ø CameraManager：摄像头管理器。这是一个全新的系统管理器，专门用于检测系统摄像头、打开系统摄像头。除此之外，调用CameraManager的getCameracharacteristics(String)方法即可获取指定摄像头的相关特性。
Ø Cameracharacteristics：摄像头特性。该对象通过CameraManager来获取，用于描述特定摄像头所支持的各种特性。
Ø CameraDevice：代表系统摄像头。该类的功能类似于早期的Camera类。
Ø CameraCaptureSession：这是一个非常重要的API，当程序需要预览、拍照时，都需要先通过该类的实例创建Session。而且不管预览还是拍照，也都是由该对象的方法进行控制的，其中控制预览的方法为setRepeatingRequest()；控制拍照的方法为capture()。
为了监听CameraCaptureSession的创建过程，以及监听CameraCaptureSession的拍照过程，Camera v2 API为CameraCaptureSession提供了StateCallback、CaptureCallback等内部类。
Ø CameraRequest和CameraRequest.Builder：当程序调用setRepeatingRequest()方法进行预览时，或调用capture()方法进行拍照时，都需要传入CameraRequest参数。CameraRequest代表了一次捕获请求，用于描述捕获图片的各种参数设置，比如对焦模式、曝光模式……总之，程序需要对照片所做的各种控制，都通过CameraRequest参数进行设置。CameraRequest.Builder则负责生成CameraRequest对象。
理解了上面API的功能和作用之后，接下来即可使用Camera v2 API来控制摄像头拍照了。控制拍照的步骤大致如下。
调用CameraManager的openCamera(String cameraID, CameraDevice.StateCallback callback, Handler handler)方法打开指定摄像头。该方法的第一个参数代表要打开的摄像头ID；第二个参数用于监听摄像头的状态；第三个参数代表执行callback的Handler，如果程序希望直接在当前线程中执行callback，则可将handler参数设为null。
当摄像头被打开之后，程序即可获取CameraDevice—即根据摄像头ID获取了指定摄像头设备，然后调用CameraDevice的createCaptureSession(List<Surface> outputs, CameraCaptureSession. StateCallback callback，Handler handler)方法来创建CameraCaptureSession。该方法的第一个参数是一个List集合，封装了所有需要从该摄像头获取图片的Surface，第二个参数用于监听CameraCaptureSession的创建过程；第三个参数代表执行callback的Handler，如果程序希望直接在当前线程中执行callback，则可将handler参数设为null。
不管预览还是拍照，程序都调用CameraDevice的createCaptureRequest(int templateType)方法创建CaptureRequest.Builder，该方法支持TEMPLATE_PREVIEW（预览）、TEMPLATE_RECORD（拍摄视频）、TEMPLATE_STILL_CAPTURE（拍照）等参数。
通过第3步所调用方法返回的CaptureRequest.Builder设置拍照的各种参数，比如对焦模式、曝光模式等。
调用CaptureRequest.Builder的build()方法即可得到CaptureRequest对象，接下来程序可通过CameraCaptureSession的setRepeatingRequest()方法开始预览，或调用capture()方法拍照。
实例：拍照时自动对焦
本实例示范了使用Camera v2来进行拍照。当用户按下拍照键时，该应用会自动对焦，当对焦成功时拍下照片。该程序的界面中提供了一个自定义TextureVIEw来显示预览取景，十分简单。该自定义TextureVIEw类的代码如下。
程序清单：codes\11\3\CameraV2Test\app\src\main\java\org\crazyit\media\MainActivity.java
public class autoFitTextureVIEw extends TextureVIEw
{
private int mRatioWIDth = 0;
private int mRatioHeight = 0;
public autoFitTextureVIEw(Context context, AttributeSet attrs)
{
super(context, attrs);
}
public voID setAspectRatio(int wIDth, int height)
{
mRatioWIDth = wIDth;
mRatioHeight = height;
requestLayout();
}
@OverrIDe
protected voID onMeasure(int wIDthMeasureSpec, int heightmeasureSpec)
{
super.onMeasure(wIDthMeasureSpec, heightmeasureSpec);
int wIDth = MeasureSpec.getSize(wIDthMeasureSpec);
int height = MeasureSpec.getSize(heightmeasureSpec);
if (0 == mRatioWIDth || 0 == mRatioHeight)
{
setMeasuredDimension(wIDth, height);
}
else
{
if (wIDth < height * mRatioWIDth / mRatioHeight)
{
setMeasuredDimension(wIDth, wIDth * mRatioHeight / mRatioWIDth);
}
else
{
setMeasuredDimension(height * mRatioWIDth / mRatioHeight, height);
}
}
}
}
接下来的MainActivity将会使用CameraManager来打开CameraDevice，并通过CameraDevice创建CameraCaptureSession，然后即可通过CameraCaptureSession进行预览或拍照了。该Activity的代码如下。
程序清单：codes\11\3\CameraV2Test\app\src\main\java\org\crazyit\media\MainActivity.java
public class MainActivity extends Activity implements VIEw.OnClickListener
{
private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static
{
ORIENTATIONS.append(Surface.ROTATION_0, 90);
ORIENTATIONS.append(Surface.ROTATION_90, 0);
ORIENTATIONS.append(Surface.ROTATION_180, 270);
ORIENTATIONS.append(Surface.ROTATION_270, 180);
}
private autoFitTextureVIEw textureVIEw;
// 摄像头ID（通常0代表后置摄像头，1代表前置摄像头）
private String mCameraID = "0";
// 定义代表摄像头的成员变量
private CameraDevice cameraDevice;
// 预览尺寸
private Size prevIEwSize;
private CaptureRequest.Builder prevIEwRequestBuilder;
// 定义用于预览照片的捕获请求
private CaptureRequest prevIEwRequest;
// 定义CameraCaptureSession成员变量
private CameraCaptureSession captureSession;
private ImageReader imageReader;
private final TextureVIEw.SurfaceTextureListener mSurfaceTextureListener
= new TextureVIEw.SurfaceTextureListener()
{
@OverrIDe
public voID onSurfaceTextureAvailable(SurfaceTexture texture
, int wIDth, int height)
{
// 当TextureVIEw可用时，打开摄像头
openCamera(wIDth, height);
}
@OverrIDe
public voID onSurfaceTextureSizeChanged(SurfaceTexture texture
, int wIDth, int height){ }
@OverrIDe
public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) { return true; }
@OverrIDe
public voID onSurfaceTextureUpdated(SurfaceTexture texture){}
};
private final CameraDevice.StateCallback stateCallback = new CameraDevice. StateCallback()
{
// 摄像头被打开时激发该方法
@OverrIDe
public voID onopened(CameraDevice cameraDevice)
{
MainActivity.this.cameraDevice = cameraDevice;
// 开始预览
createCameraPrevIEwSession(); // ②
}
// 摄像头断开连接时激发该方法
@OverrIDe
public voID ondisconnected(CameraDevice cameraDevice)
{
cameraDevice.close();
MainActivity.this.cameraDevice = null;
}
// 打开摄像头出现错误时激发该方法
@OverrIDe
public voID one rror(CameraDevice cameraDevice, int error)
{
cameraDevice.close();
MainActivity.this.cameraDevice = null;
MainActivity.this.finish();
}
};
@OverrIDe
protected voID onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentVIEw(R.layout.main);
textureVIEw = (autoFitTextureVIEw) findVIEwByID(R.ID.texture);
// 为该组件设置监听器
textureVIEw.setSurfaceTextureListener(mSurfaceTextureListener);
findVIEwByID(R.ID.capture).setonClickListener(this);
}
@OverrIDe
public voID onClick(VIEw vIEw)
{
captureStillPicture();
}
private voID captureStillPicture()
{
try
{
if (cameraDevice == null)
{
return;
}
// 创建作为拍照的CaptureRequest.Builder
final CaptureRequest.Builder captureRequestBuilder = cameraDevice
.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// 将imageReader的surface作为CaptureRequest.Builder的目标
captureRequestBuilder.addTarget(imageReader.getSurface());
// 设置自动对焦模式
captureRequestBuilder.set(CaptureRequest.CONTRol_AF_MODE,
CaptureRequest.CONTRol_AF_MODE_CONTINUOUS_PICTURE);
// 设置自动曝光模式
captureRequestBuilder.set(CaptureRequest.CONTRol_AE_MODE,
CaptureRequest.CONTRol_AE_MODE_ON_auto_FLASH);
// 获取设备方向
int rotation = getwindowManager().getDefaultdisplay().getRotation();
// 根据设备方向计算设置照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION
, ORIENTATIONS.get(rotation));
// 停止连续取景
captureSession.stopRepeating();
// 捕获静态图像
captureSession.capture(captureRequestBuilder.build()
, new CameraCaptureSession.CaptureCallback() // ⑤
{
// 拍照完成时激发该方法
@OverrIDe
public voID onCaptureCompleted(CameraCaptureSession session
, CaptureRequest request, TotalCaptureResult result)
{
try
{
// 重设自动对焦模式
prevIEwRequestBuilder.set(CaptureRequest.CONTRol_AF_TRIGGER,
CameraMetadata.CONTRol_AF_TRIGGER_CANCEL);
// 设置自动曝光模式
prevIEwRequestBuilder.set(CaptureRequest.CONTRol_AE_MODE,
CaptureRequest.CONTRol_AE_MODE_ON_auto_FLASH);
// 打开连续取景模式
captureSession.setRepeatingRequest(prevIEwRequest, null, null);
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
}
}, null);
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
}
// 打开摄像头
private voID openCamera(int wIDth, int height)
{
setUpCameraOutputs(wIDth, height);
CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_ SERVICE);
try
{
// 打开摄像头
manager.openCamera(mCameraID, stateCallback, null); // ①
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
}
private voID createCameraPrevIEwSession()
{
try
{
SurfaceTexture texture = textureVIEw.getSurfaceTexture();
texture.setDefaultBufferSize(prevIEwSize.getWIDth(), prevIEwSize.getHeight());
// 创建作为预览的CaptureRequest.Builder
prevIEwRequestBuilder = cameraDevice
.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
// 将textureVIEw的surface作为CaptureRequest.Builder的目标
prevIEwRequestBuilder.addTarget(new Surface(texture));
// 创建CameraCaptureSession，该对象负责管理处理预览请求和拍照请求
cameraDevice.createCaptureSession(Arrays.asList(surface
, imageReader.getSurface()), new CameraCaptureSession.StateCallback() // ③
{
@OverrIDe
public voID onConfigured(CameraCaptureSession cameraCaptureSession)
{
// 如果摄像头为null，直接结束方法
if (null == cameraDevice)
{
return;
}
// 当摄像头已经准备好时，开始显示预览
captureSession = cameraCaptureSession;
try
{
// 设置自动对焦模式
prevIEwRequestBuilder.set(CaptureRequest.CONTRol_AF_MODE,
CaptureRequest.CONTRol_AF_MODE_CONTINUOUS_PICTURE);
// 设置自动曝光模式
prevIEwRequestBuilder.set(CaptureRequest.CONTRol_AE_MODE,
CaptureRequest.CONTRol_AE_MODE_ON_auto_FLASH);
// 开始显示相机预览
prevIEwRequest = prevIEwRequestBuilder.build();
// 设置预览时连续捕获图像数据
captureSession.setRepeatingRequest(prevIEwRequest,
null, null); // ④
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
}
@OverrIDe
public voID onConfigureFailed(CameraCaptureSession cameraCaptureSession)
{
Toast.makeText(MainActivity.this, "配置失败！"
, Toast.LENGTH_SHORT).show();
}
}, null
);
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
}
private voID setUpCameraOutputs(int wIDth, int height)
{
CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_ SERVICE);
try
{
// 获取指定摄像头的特性
Cameracharacteristics characteristics
= manager.getCameracharacteristics(mCameraID);
// 获取摄像头支持的配置属性
StreamConfigurationMap map = characteristics.get(
Cameracharacteristics.SCALER_STREAM_CONfigURATION_MAP);
// 获取摄像头支持的最大尺寸
Size largest = Collections.max(
Arrays.asList(map.getoutputSizes(ImageFormat.JPEG)),
new CompareSizesByArea());
// 创建一个ImageReader对象，用于获取摄像头的图像数据
imageReader = ImageReader.newInstance(largest.getWIDth(), largest.getHeight(),
ImageFormat.JPEG, 2);
imageReader.setonImageAvailableListener(
new ImageReader.OnImageAvailableListener()
{
// 当照片数据可用时激发该方法
@OverrIDe
public voID onImageAvailable(ImageReader reader)
{
// 获取捕获的照片数据
Image image = reader.acquireNex@R_502_5411@();
ByteBuffer buffer = image.getPlanes()[0].getBuffer();
byte[] bytes = new byte[buffer.remaining()];
// 使用IO流将照片写入指定文件
file file = new file(getExternalfilesDir(null), "pic.jpg");
buffer.get(bytes);
try (
fileOutputStream output = new fileOutputStream(file))
{
output.write(bytes);
Toast.makeText(MainActivity.this, "保存: "
+ file, Toast.LENGTH_SHORT).show();
}
catch (Exception e)
{
e.printstacktrace();
}
finally
{
image.close();
}
}
}, null);
// 获取最佳的预览尺寸
prevIEwSize = chooSEOptimalSize(map.getoutputSizes(
SurfaceTexture.class), wIDth, height, largest);
// 根据选中的预览尺寸来调整预览组件（TextureVIEw）的长宽比
int orIEntation = getResources().getConfiguration().orIEntation;
if (orIEntation == Configuration.ORIENTATION_LANDSCAPE)
{
textureVIEw.setAspectRatio(prevIEwSize.getWIDth(), prevIEwSize.
getHeight());
}
else
{
textureVIEw.setAspectRatio(prevIEwSize.getHeight(),
prevIEwSize.getWIDth());
}
}
catch (CameraAccessException e)
{
e.printstacktrace();
}
catch (NullPointerException e)
{
System.out.println("出现错误。");
}
}
private static Size chooSEOptimalSize(Size[] choices
, int wIDth, int height, Size aspectRatio)
{
// 收集摄像头支持的大过预览Surface的分辨率
List<Size> bigEnough = new ArrayList<>();
int w = aspectRatio.getWIDth();
int h = aspectRatio.getHeight();
for (Size option : choices)
{
if (option.getHeight() == option.getWIDth() * h / w &&
option.getWIDth() >= wIDth && option.getHeight() >= height)
{
bigEnough.add(option);
}
}
// 如果找到多个预览尺寸，获取其中面积最小的
if (bigEnough.size() > 0)
{
return Collections.min(bigEnough, new CompareSizesByArea());
}
else
{
System.out.println("找不到合适的预览尺寸！！！");
return choices[0];
}
}
// 为Size定义一个比较器Comparator
static class CompareSizesByArea implements Comparator<Size>
{
@OverrIDe
public int compare(Size lhs, Size rhs)
{
// 强转为long保证不会发生溢出
return Long.signum((long) lhs.getWIDth() * lhs.getHeight() -
(long) rhs.getWIDth() * rhs.getHeight());
}
}
}
上面程序中的①号粗体字代码用于打开系统摄像头，openCamera()方法的第一个参数代表请求打开的摄像头ID，此处传入的摄像头ID为"0"，这代表打开设备后置摄像头；如果需要打开设备指定摄像头（比如前置摄像头），可以在调用openCamera()方法时传入相应的摄像头ID。
CameraManager提供了getCameraIDList()方法来获取设备的摄像头列表，还提供了getCameracharacteristics(String cameraID)方法来获取指定摄像头的特性。例如如下代码：
// 获取设备上摄像头列表
String[] IDs = CameraManager.getCameraIDList();
// 创建一个空的CameraInfo对象，用于获取摄像头信息
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
for ( String ID : IDs)
{
Cameracharacteristics cc = getCameracharacteristics(ID);
// 接下来的代码就可以通过cc来获取该摄像头的特性了
...
}
上面程序中的①号粗体字代码打开后置摄像头时传入了一个stateCallback参数，该参数代表的对象可检测摄像头的状态改变，当摄像头的状态发生改变时，程序将会自动回调该对象的相应方法。该程序的关键是重写了stateCallback的onopened(CameraDevice cameraDevice)方法—当摄像头被打开时将会自动激发该方法，通过该方法的参数即可让程序获取被打开的摄像头设备。除此之外，程序在onopened()方法的②号粗体字代码处调用createCameraPrevIEwSession()方法创建了CameraCaptureSession，并开始预览取景。
createCameraPrevIEwSession()方法中的③号粗体字代码调用了CameraDevice的createCaptureSession()方法来创建CameraCaptureSession，调用该方法时也传入了一个CameraCaptureSession.StateCallback参数，这样即可保证当CameraCaptureSession被创建成功之后立即开始预览。
createCameraPrevIEwSession()方法的第一行粗体字代码将texture组件添加为prevIEwRequestBuilder的target，这意味着程序通过prevIEwRequestBuilder获取的图像数据将会被显示在texture组件上。
程序重写了CameraCaptureSession.StateCallback的onConfigured()方法—当CameraCaptureSession创建成功时将会自动回调该方法，该方法先通过prevIEwRequestBuilder设置了预览参数，然后调用CameraCaptureSession对象的setRepeatingRequest()方法开始预览。
当单击程序界面上的拍照按钮时，程序将会激发该Activity的captureStillPicture()方法。该方法的实现逻辑同样很简单：程序先创建一个CaptureRequest.Builder对象，该方法中第一行粗体字代码将ImageReader添加成CaptureRequest.Builder的target—这意味着当程序拍照时，图像数据将会被传给此ImageReader。接下来程序通过CaptureRequest.Builder设置了拍照参数，然后通过⑤号粗体字代码调用CameraCaptureSession的capture()方法拍照即可，调用该方法时也传入了CaptureCallback参数，这样可以保证拍照完成之后会重新开始预览。
注意：该应用打开摄像头、创建CameraCaptureSession、预览、拍照时都没有传入Handler参数，这意味着程序直接在主线程中完成相应的Callback任务，这样可能导致程序响应变慢。对于实际的应用，我们建议传入Handler参数，这样即可让Handler使用新线程来执行Callback任务，这样才可提高应用的响应速度。
由于该程序需要使用手机的摄像头，因此还需要在AndroIDManifest.xml文件中增加如下配置：
<!-- 授予该程序使用摄像头的权限 -->
<uses-permission androID:name="androID.permission.CAMERA" />
在Genymotion模拟器上运行该程序可能看到如图1所示的预览界面—这是因为Genymotion模拟器可以使用宿主电脑上的摄像头作为相机摄像头。
为了让模拟器能显示图1所示的预览界面，建议读者启用Genymotion模拟器的摄像头支持：单击Genymotion模拟器右边的摄像头图标，即可看到如图2所示的对话框。按该图上标出的提示即可打开Genymotion模拟器的摄像头支持。
运行该程序，按下右下角的“拍照”键，程序将会把拍得的照片保存下来，界面上也会显示该照片的存储目录。
<ignore_Js_op>
图1 预览界面
<ignore_Js_op>
本文摘自《疯狂AndroID讲义（第2版）》
总结以上是内存溢出为你收集整理的android camera2 详解说明（一）全部内容，希望文章能够帮你解决android camera2 详解说明（一）所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）