Android中的Camera简介
这里主要将一些camera的一些简单用法，当然如果是用camera2的童鞋，可以参考： 。这里主要讲解：
* 如何利用camera开启相机实现预览
* 实现拍照功能，以及图片大小设定
* 切换前后置摄像头
* 闪光灯的开启
* 前置镜像
* 给拍照的图片加水印
* 自动对焦与手动对焦
* 相机的放大缩小
* 相机拍照的横竖方向的监听
好了，我们先来先看看预览的效果
在之前，我先定义了一个接口ICameraHelper，用于控制整个相机的功能：
/**
* @CreadBy ：DramaScript
* @date 2017/7/10
*/
public interface ICameraHelper {
//打开相机
boolean open(int cameraId);
//设置相机宽高比 图片和预览大小
void setConfig(Config config);
//是否开启预览
boolean preview();
// 切换前后摄像头
boolean switchTo(int cameraId);
// 拍照
void takePhoto(TakePhotoCallback callback,int nRotation);
// 相机是否关闭
boolean close();
//设置预览的纹理
void setPreviewTexture(SurfaceTexture texture);
//获得预览大小
Point getPreviewSize();
//获得图片的大小
Point getPictureSize();
//设置预览时每一帧的回调
void setOnPreviewFrameCallback(PreviewFrameCallback callback);
void setFlash(int flashMode);
class Config{
float rate; //宽高比
int minPreviewWidth;
int minPictureWidth;
}
interface TakePhotoCallback{
void onTakePhoto(Bitmap bitmap);
}
interface PreviewFrameCallback{
void onPreviewFrame(byte[] bytes, int width, int height);
}
}下面我们定义CameraHelper实现ICameraHelper，然后来实现这些方法：
首先实现打开相机方法open(int cameraId)：
@Override
public boolean open(int cameraId) {
mCamera = Camera.open(cameraId);
this.cameraId = cameraId;
if (mCamera != null) {
Camera.Parameters param = mCamera.getParameters();
picSize = getPropPictureSize(param.getSupportedPictureSizes(), mConfig.rate,
mConfig.minPictureWidth);
preSize = getPropPreviewSize(param.getSupportedPreviewSizes(), mConfig.rate, mConfig
.minPreviewWidth);
//设置照片生成的大小
picWide = picSize.width;
picHeight = picSize.height;
param.setPictureSize(picWide, picHeight);
//生成照片预览大小
param.setPreviewSize(preSize.width, preSize.height);
mCamera.setParameters(param);
Camera.Size pre = param.getPreviewSize();
Camera.Size pic = param.getPictureSize();
mPicSize = new Point(pic.height, pic.width);
mPreSize = new Point(pre.height, pre.width);
Log.e("wuwang", "camera previewSize:" + mPreSize.x + "/" + mPreSize.y);
return true;
}
return false;
}
/**
* 获得生成照片的大小
*
* @param list
* @param th
* @param minWidth
* @return
*/
private Camera.Size getPropPictureSize(List<Camera.Size> list, float th, int minWidth) {
Collections.sort(list, sizeComparator);
int i = 0;
for (Camera.Size s : list) {
if ((s.height >= minWidth) && equalRate(s, th)) {
break;
}
i++;
}
if (i == list.size()) {
i = 0;
}
return list.get(i);
/**
* 获得预览大小
*
* @param list
* @param th
* @param minWidth
* @return
*/
private Camera.Size getPropPreviewSize(List<Camera.Size> list, float th, int minWidth) {
Collections.sort(list, sizeComparator);
int i = 0;
for (Camera.Size s : list) {
if ((s.height >= minWidth) && equalRate(s, th)) {
break;
}
i++;
}
if (i == list.size()) {
i = 0;
}
return list.get(i);
}这个方法，通过Camera.open(cameraId);来获取Camera对象，其中cameraId可以为0也可以为1，前者代表后置摄像头。然后通过Camera.Parameters来设置相机的一些参数，比如预览大小，图片生成大小，当然这里使根据手机找出了最合适的尺寸大小，可以根据自己的需求设定图片的大小，至于预览的大小，建议不要太大，容易造成机型不适配，我记得HTC的U的手机，最大支持720的。设置太大也容易消化GPU，造成手机的发烫。
接下来就是拍照方法实现：
@Override
public void takePhoto(final TakePhotoCallback callback, final int nRotation) {
mCamera.takePicture(null, null, new Camera.PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera) {
Log.e("tag", "拍照的角度：" + nRotation);
Bitmap bm = null;
if (nRotation==0){
bm = setTakePicktrueOrientation(cameraId, BitmapFactory.decodeByteArray(data, 0, data.length));
}else {
bm = BitmapFactory.decodeByteArray(data, 0, data.length);
if (isFrontCamera) {
bm = rotateBitmapByDegree(bm, 270 - nRotation, false);
} else {
bm = rotateBitmapByDegree(bm, nRotation + 90, false);
}
}
callback.onTakePhoto(bm);
}
});
}这里拍照方法，调用takePicture方法，实现Camera.PictureCallback接口，为了后面对bitmap操作，直接将byte数组转成bitmap返回。这里有一个问题，那就是拍照的图片并不是拍照时的样子，这里我们通过：
private class AlbumOrientationEventListener extends OrientationEventListener {
public AlbumOrientationEventListener(Context context) {
super(context);
}
public AlbumOrientationEventListener(Context context, int rate) {
super(context, rate);
}
@Override
public void onOrientationChanged(int orientation) {
if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) {
return;
}
//保证只返回四个方向
int newOrientation = ((orientation + 45) / 90 * 90) % 360;
if (newOrientation != mOrientation) {
mOrientation = newOrientation;
Log.e("MJHTEST", "mOrientation = " + mOrientation);
//返回的mOrientation就是手机方向，为0°、90°、180°和270°中的一个
}
}
}来监听手机的横竖变化，根据相应的角度进行调整。下面你是矫正角度的方法：
/**
* 将图片按照某个角度进行旋转
*
* @param bm 需要旋转的图片
* @param degree 旋转角度
* @return 旋转后的图片
*/
public static Bitmap rotateBitmapByDegree(Bitmap bm, int degree, boolean bFlip) {
if (degree >= 360)
degree -= 360;
if (degree < 0)
degree += 360;
Bitmap returnBm = null;
// 根据旋转角度，生成旋转矩阵
android.graphics.Matrix matrix = new android.graphics.Matrix();
matrix.postRotate(degree);
try {
// 将原始图片按照旋转矩阵进行旋转，并得到新的图片
returnBm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(),
bm.getHeight(), matrix, true);
} catch (OutOfMemoryError e) {
}
if (returnBm == null) {
returnBm = bm;
}
if (bm != returnBm) {
bm.recycle();
}
return returnBm;
}至于切换摄像头，其实就是根据cameraId的变化，重新开启预览相机：
@Override
public boolean switchTo(int cameraId) {
close();
open(cameraId);
if (cameraId == 1) {
isFrontCamera = true;
} else {
isFrontCamera = false;
}
return false;
}然后开启闪光灯的操作，有三种模式：开启常亮的闪光灯，拍照时根据环境亮度开启闪光灯，关闭闪光灯三种模式：
/**
* 开启闪光灯
*/
public void turnLightOn() {
if (mCamera == null) {
return;
}
Camera.Parameters parameters = mCamera.getParameters();
if (parameters == null) {
return;
}
List<String> flashModes = parameters.getSupportedFlashModes();
// Check if camera flash exists
if (flashModes == null) {
// Use the screen as a flashlight (next best thing)
return;
}
String flashMode = parameters.getFlashMode();
if (!Camera.Parameters.FLASH_MODE_ON.equals(flashMode)) {
// Turn on the flash
if (flashModes.contains(Camera.Parameters.FLASH_MODE_ON)) {
parameters.setFlashMode(Camera.Parameters.FLASH_MODE_ON);
mCamera.setParameters(parameters);
} else {
}
}
}
//关闭闪光灯
public void turnLightOff() {
if (mCamera == null) {
return;
}
Camera.Parameters parameters = mCamera.getParameters();
if (parameters == null) {
return;
}
List<String> flashModes = parameters.getSupportedFlashModes();
String flashMode = parameters.getFlashMode();
// Check if camera flash exists
if (flashModes == null) {
return;
}
if (!Camera.Parameters.FLASH_MODE_OFF.equals(flashMode)) {
// Turn off the flash
if (flashModes.contains(Camera.Parameters.FLASH_MODE_OFF)) {
parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
mCamera.setParameters(parameters);
} else {
}
}
}接下来就是前置摄像头镜像功能，意思就是我们的手机拍照，前置拍出来的照片都是左右反的，需要将图片进行相应的调整：
/**
* 拍摄照片自动镜像
* @param bmp
* @return
*/
public static Bitmap convertBmp(Bitmap bmp) {
int w = bmp.getWidth();
int h = bmp.getHeight();
Matrix matrix = new Matrix();
matrix.postScale(-1, 1); // 镜像水平翻转
Bitmap convertBmp = Bitmap.createBitmap(bmp, 0, 0, w, h, matrix, true);
return convertBmp;
}拍好照片，可能需要考虑给照片加个水印，这里不讨论实时的给相机每一帧加，因为没必要，又不是做贴纸，所以只是在拍照后加入水印操作：
/**
* 设置水印图片在右下角
* @param src
* @param watermark
* @param paddingRight
* @param paddingBottom
* @return
*/
public static Bitmap createWaterMaskRightBottom(
Context context, Bitmap src, Bitmap watermark,
int paddingRight, int paddingBottom) {
return createWaterMaskBitmap(src, watermark,
src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
}
private static Bitmap createWaterMaskBitmap(Bitmap src, Bitmap watermark,
int paddingLeft, int paddingTop) {
if (src == null) {
return null;
}
int width = src.getWidth();
int height = src.getHeight();
//创建一个bitmap
Bitmap newb = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);// 创建一个新的和SRC长度宽度一样的位图
//将该图片作为画布
Canvas canvas = new Canvas(newb);
//在画布 0，0坐标上开始绘制原始图片
canvas.drawBitmap(src, 0, 0, null);
//在画布上绘制水印图片
canvas.drawBitmap(watermark, paddingLeft, paddingTop, null);
// 保存
canvas.save(Canvas.ALL_SAVE_FLAG);
// 存储
canvas.restore();
return newb;
}每个相机基本上都有自动对焦和手动对焦功能，自动对焦其实就是在初始化相机的设置参数：
camera.cancelAutoFocus();//只有加上了这一句，才会自动对焦手动对焦，需要获取屏幕收触控的点，根据点来设置对焦的地方：
/**
* 手动聚焦
*
* @param point 触屏坐标
*/
protected boolean onFocus(Point point, Camera.AutoFocusCallback callback) {
mCamera = manager.getmCamera();
if (mCamera == null) {
Log.e("tag","------------------------1");
return false;
}
Camera.Parameters parameters = null;
try {
parameters = mCamera.getParameters();
} catch (Exception e) {
e.printStackTrace();
Log.e("tag","------------------------2");
return false;
}
//不支持设置自定义聚焦，则使用自动聚焦，返回
if(Build.VERSION.SDK_INT >= 14) {
if (parameters.getMaxNumFocusAreas() <= 0) {
return focus(callback);
}
Log.i("tag", "onCameraFocus:" + point.x + "," + point.y);
List<Camera.Area> areas = new ArrayList<Camera.Area>();
int left = point.x - 300;
int top = point.y - 300;
int right = point.x + 300;
int bottom = point.y + 300;
left = left < -1000 ? -1000 : left;
top = top < -1000 ? -1000 : top;
right = right > 1000 ? 1000 : right;
bottom = bottom > 1000 ? 1000 : bottom;
areas.add(new Camera.Area(new Rect(left, top, right, bottom), 100));
parameters.setFocusAreas(areas);
try {
//本人使用的小米手机在设置聚焦区域的时候经常会出异常，看日志发现是框架层的字符串转int的时候出错了，
//目测是小米修改了框架层代码导致，在此try掉，对实际聚焦效果没影响
mCamera.setParameters(parameters);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
Log.e("tag","------------------------3");
return false;
}
}
return focus(callback);
}
private boolean focus(Camera.AutoFocusCallback callback) {
try {
mCamera.autoFocus(callback);
} catch (Exception e) {
e.printStackTrace();
Log.e("tag","------------------------4");
return false;
}
return true;
}最后就是相机的缩放了，直接上代码了：
public void setZoom(int zoom) {
if (mCamera == null) return;
Camera.Parameters parameters;
//注意此处为录像模式下的setZoom方式。在Camera.unlock之后，调用getParameters方法会引起android框架底层的异常
//stackoverflow上看到的解释是由于多线程同时访问Camera导致的冲突，所以在此使用录像前保存的mParameters。
parameters = mCamera.getParameters();
if (!parameters.isZoomSupported()) return;
parameters.setZoom(zoom);
mCamera.setParameters(parameters);
mZoom = zoom;
}好了，相机camera的基本操作都在这里。
基于GlSurfaceView自定义CamerView自定义相机
我们相机的数据有两种常用的方法来预览，第一种就是利用SurfaceView控件，设置SurfaceHolder句柄来预览，这种方式相对比较简单，但是却不能很好的满足我们一些需求，比如在自定义相机中设置自定义的滤镜，贴纸，甚至加上AR的效果。所以，我们选择第二种方式，利用Opengl来绘制摄像头的数据。这样方便后面的拓展，其中的流程如下图：
这里面的关键是生成的纹理id如何通过opengl来绑定在一起，然后通过纹理id来生成SurfaceTexture，然后将摄像数据与GLSurfaceView绑定在一起显示出来。下面我们通过代码来分析。首先如何生成纹理id：
private int createTextureID(){
int[] texture = new int[1];
GLES20.glGenTextures(1, texture, 0);
GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture[0]);
GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);
GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
return texture[0];
}此时的纹理id是没有和opengl绑定相关的，这个时候需要在GLSurfaceView的Render中的onSurfaceCreated进行相应的绑定操作：
@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
int texture = createTextureID();
surfaceTexture=new SurfaceTexture(texture);
mOesFilter.create();
mOesFilter.setTextureId(texture);
}上面通过纹理id生成了一个SurfaceTexture对象，然后把这个对象交给相机的CameraHelper，通过一下方法设置：
@Override
public void setPreviewTexture(SurfaceTexture texture) {
if (mCamera != null) {
try {
mCamera.setPreviewTexture(texture);
} catch (IOException e) {
e.printStackTrace();
}
}
}这是时候摄像头的数据就已经和GLSurfaceView完成一半的工作了，不了解GLSurfaceView的绘图方式的请参考：http://www.jianshu.com/p/442682fda917
接下来，就是需要通过opengl的一些操作将摄像头数据正常显示出来了，其实主要还是实现onDrawFrame方法：
/**
* 启用顶点坐标和纹理坐标进行绘制
*/
protected void onDraw(){
GLES20.glEnableVertexAttribArray(mHPosition);
GLES20.glVertexAttribPointer(mHPosition,2, GLES20.GL_FLOAT, false, 0,mVerBuffer);
GLES20.glEnableVertexAttribArray(mHCoord);
GLES20.glVertexAttribPointer(mHCoord, 2, GLES20.GL_FLOAT, false, 0, mTexBuffer);
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP,0,4);
GLES20.glDisableVertexAttribArray(mHPosition);
GLES20.glDisableVertexAttribArray(mHCoord);
}这里的主要opengl指令相关的类在于CameraFilter：
/**
* @CreadBy ：DramaScript
* @date 2017/7/10
*/
public class CameraFilter extends BaseFilter {
//连续矩阵句柄
private int mHCoordMatrix;
//连续矩阵值
private float[] mCoordMatrix= Arrays.copyOf(OM,16);
public CameraFilter(Resources mRes) {
super(mRes);
}
@Override
protected void onCreate() {
//创建opengl2
createProgramByAssetsFile("shader/oes_base_vertex.sh","shader/oes_base_fragment.sh");
mHCoordMatrix= GLES20.glGetUniformLocation(mProgram,"vCoordMatrix");
}
public void setCoordMatrix(float[] matrix){
this.mCoordMatrix=matrix;
}
@Override
protected void onBindTexture() {
GLES20.glActiveTexture(GLES20.GL_TEXTURE0+getTextureType());
GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,getTextureId());
GLES20.glUniform1i(mHTexture,getTextureType());
}
@Override
protected void onSetExpandData() {
super.onSetExpandData();
GLES20.glUniformMatrix4fv(mHCoordMatrix,1,false,mCoordMatrix,0);
}
@Override
protected void onSizeChanged(int width, int height) {
}
}上面通过加载Assets目录下的sh文件来显示，sh写的是opengl相关的代码，其中的顶点着色器和片元着色器：
#extension GL_OES_EGL_image_external : require
precision mediump float;
varying vec2 textureCoordinate;
uniform samplerExternalOES vTexture;
void main() {
gl_FragColor = texture2D( vTexture, textureCoordinate );
}attribute vec4 vPosition;
attribute vec2 vCoordinate;
uniform mat4 vMatrix;
varying vec2 aCoordinate;
void main(){
gl_Position=vMatrix*vPosition;
aCoordinate=vCoordinate;
}其实主要还是整个流程，以及对opengl的一些相关术语的理解，如果不明opengl的相关术语描述。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
