先看代码：
private SurfaceView mSurfaceView;
private SurfaceHolder mSurfaceHolder;
private CameraManager cameraManager; cameraManager = new CameraManager(this);
mSurfaceView = (SurfaceView) findViewById(R.id.java_surface_view);
mSurfaceHolder = mSurfaceView.getHolder(); // mSurfaceView 不需要自己的缓冲区
mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
// mSurfaceView添加回调
mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder holder) { //SurfaceView创建
try {
cameraManager.openDriver(mSurfaceHolder);
cameraManager.startPreview();
} catch (IOException e) {
e.printStackTrace();
}
} @Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { } @Override
public void surfaceDestroyed(SurfaceHolder holder) { //SurfaceView销毁
holder.removeCallback(this); // Camera is being used after Camera.release() was called
cameraManager.stopPreview();
cameraManager.closeDriver(); }
});
自定义一个 CameraManager 类，在关闭当前页面，释放camera资源时偶尔报错
Camera is being used after Camera.release() was called
第一次，加了一句 holder.removeCallback(this); 运行发现还是时不时出现报错。
第二次在释放 camera前加 camera.setPreviewCallback(null); 问题解决。
/**
* 关闭预览
*/
public synchronized void stopPreview() {
Log.e(TAG, "stopPreview");
if (autoFocusManager != null) {
autoFocusManager.stop();
autoFocusManager = null;
}
if (camera != null && previewing) {
camera.stopPreview();
camera.setPreviewCallback(null); // Camera is being used after Camera.release() was called
previewing = false;
}
} /**
* 关闭camera
*/
public synchronized void closeDriver() {
Log.e(TAG, "closeDriver");
if (camera != null) {
camera.release();
camera = null;
}
}
原来：如果程序中加入了previewCallback，在surfaceDestroy释放camera的时候，最好执行myCamera.setOneShotPreviewCallback(null); 或者myCamera.setPreviewCallback(null);中止这种回调，然后再释放camera更安全。否则可能会报错。
附：CameraManager类：
package com.myproject.facedetection.entity; import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.hardware.Camera;
import android.util.Log;
import android.view.Display;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.WindowManager; import com.opencvlib.ObjectDetector; import org.opencv.android.Utils;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Rect;
import org.opencv.imgproc.Imgproc; import java.io.IOException;
import java.util.ArrayList;
import java.util.List; import static com.myproject.facedetection.common.myUtils.ByteToBitmap; /**
* User:lizhangqu(513163535@qq.com)
* Date:2015-09-05
* Time: 10:56
*/
public class CameraManager implements Camera.PreviewCallback {
private static final String TAG = CameraManager.class.getName();
private Camera camera;
private Camera.Parameters parameters;
private AutoFocusManager autoFocusManager;
private int requestedCameraId = -1; // 默认打开后置摄像头
private int cameraPosition;//0代表前置摄像头，1代表后置摄像头
private int numCameras = Camera.getNumberOfCameras(); // 初始化摄像头数量
private Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
private Context mContext; private boolean initialized;
private boolean previewing;
private ArrayList<ObjectDetector> mObjectDetects;
private CustomImageButton cimbt;
private SurfaceHolder holder; /**
* 打开摄像头
*
* @param cameraId 摄像头id
* @return Camera
*/
public Camera open(int cameraId) {
if (numCameras <= 0) {
Log.e(TAG, "No cameras!");
return null;
} // 如果 cameraId 在 [0-numCameras) 之间则打开cameraId 否则默认优先打开后置
boolean explicitRequest = (cameraId >= 0 && cameraId < numCameras); int index = 0;
if (!explicitRequest) {
// Select a camera if no explicit camera requested
while (index < numCameras) {
Camera.getCameraInfo(index, cameraInfo);
cameraId = index;
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
cameraPosition = 1;
break;
}
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
cameraPosition = 0;
continue;
} index++;
}
} // 不在 [0-numCameras) 之间 且 没有默认打开的
Camera camera;
if (index < numCameras) {
Log.e(TAG, "Opening camera #" + cameraId);
camera = Camera.open(cameraId);
} else {
Log.e(TAG, "Requested camera does not exist: " + cameraId);
camera = null;
} int rotation = getDisplayOrientation();
camera.setDisplayOrientation(rotation);
camera.setPreviewCallback(this);
//camera.setOneShotPreviewCallback(this); // 激活 onPreviewFrame 执行一次
return camera;
} public int getDisplayOrientation() {
Display display = ((WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int rotation = display.getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
Camera.CameraInfo camInfo = new Camera.CameraInfo();
Camera.getCameraInfo(Camera.CameraInfo.CAMERA_FACING_BACK, camInfo);
int result = (camInfo.orientation - degrees + 360) % 360;
return result;
} public CameraManager(Context context, ArrayList<ObjectDetector> mObjectDetects, CustomImageButton cimbt, SurfaceHolder holder) {
this.mContext = context;
this.mObjectDetects = mObjectDetects;
this.cimbt = cimbt;
this.holder = holder;
} /**
* 打开camera
*
* @throws IOException IOException
*/
public synchronized void openDriver()
throws IOException {
Log.e(TAG, "openDriver");
Camera theCamera = camera;
if (theCamera == null) {
theCamera = open(requestedCameraId);
if (theCamera == null) {
throw new IOException();
}
camera = theCamera;
}
theCamera.setPreviewDisplay(holder); if (!initialized) {
initialized = true;
parameters = camera.getParameters();
List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes(); int w = 800;
int h = 600;
for (Camera.Size size : previewSizes) {
Log.e("TAG", "previewSizes width:" + size.width);
Log.e("TAG", "previewSizes height:" + size.height);
if (size.width - w <= 200 & size.width >= w) {
w = size.width;
h = size.height;
break;
}
}
Log.e("w*h", String.format("%d*%d", w, h));
parameters.setPreviewSize(w, h);
parameters.setPictureFormat(ImageFormat.JPEG);
parameters.setJpegQuality(100);
parameters.setPictureSize(800, 600);
theCamera.setParameters(parameters);
}
} /*
切换摄像头
*/
public synchronized void changeCamera() throws IOException {
for (int i = 0; i < numCameras; i++) {
Camera.getCameraInfo(i, cameraInfo);//得到每一个摄像头的信息
//现在是后置，变更为前置
if (cameraPosition == 1) {
//代表摄像头的方位 CAMERA_FACING_FRONT前置 CAMERA_FACING_BACK后置
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
stopPreview();
closeDriver(); requestedCameraId = i;
initialized = false; openDriver();
startPreview();
cameraPosition = 0;
break;
}
} else {
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
stopPreview();
closeDriver(); requestedCameraId = i;
initialized = false; openDriver();
startPreview();
cameraPosition = 1;
break;
}
} }
} @Override
public void onPreviewFrame(byte[] bytes, Camera camera) {
Camera.Size previewSize = camera.getParameters().getPreviewSize(); Bitmap bitmap = ByteToBitmap(bytes, previewSize);
//Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);//将data byte型数组转换成bitmap文件 final Matrix matrix = new Matrix();//转换成矩阵旋转90度
if (cameraPosition == 1) {
matrix.setRotate(90);
} else {
matrix.setRotate(-90);
}
bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);//旋转图片 Mat grayscaleImage = new Mat(previewSize.height, previewSize.width, CvType.CV_8UC4);
int absoluteFaceSize = (int) (previewSize.height * 0.2); if (bitmap != null) {
Mat inputFrame = new Mat();
Utils.bitmapToMat(bitmap, inputFrame); if (!bitmap.isRecycled()) {
bitmap.recycle();
} // Create a grayscale image
Imgproc.cvtColor(inputFrame, grayscaleImage, Imgproc.COLOR_RGBA2RGB); MatOfRect mRect = new MatOfRect(); int maxRectArea = 0 * 0;
Rect maxRect = null; int facenum = 0; for (ObjectDetector detector : mObjectDetects) {
// 检测目标
Rect[] object = detector.detectObjectImage(inputFrame, mRect);
Log.e(TAG, object.length + ""); for (Rect rect : object) {
++facenum;
// 找出最大的面积
int tmp = rect.width * rect.height;
if (tmp >= maxRectArea) {
maxRectArea = tmp;
maxRect = rect;
}
}
} Bitmap rectBitmap = null;
if (facenum != 0) {
// 剪切最大的头像
//Log.e("剪切的长宽", String.format("高:%s,宽:%s", maxRect.width, maxRect.height));
Rect rect = new Rect(maxRect.x, maxRect.y, maxRect.width, maxRect.height);
Mat rectMat = new Mat(inputFrame, rect); // 从原始图像拿
rectBitmap = Bitmap.createBitmap(rectMat.cols(), rectMat.rows(), Bitmap.Config.ARGB_8888);
Utils.matToBitmap(rectMat, rectBitmap); Bitmap resizeBmp = cimbt.resizeBitmap(rectBitmap, cimbt.getWidth(), cimbt.getHeight());
cimbt.setBitmap(resizeBmp);
} else {
cimbt.clearnImage();
cimbt.setText("没有检测到人脸");
}
} } public interface OnObjectTrackingInterface {
// 传输camera的字节流
void onCameraByteStream(byte[] bytes, Camera camera); } /**
* camera是否打开
*
* @return camera是否打开
*/ public synchronized boolean isOpen() {
return camera != null;
} /**
* 关闭camera
*/
public synchronized void closeDriver() {
Log.e(TAG, "closeDriver");
if (camera != null) {
camera.release();
camera = null;
}
} /**
* 开始预览
*/
public synchronized void startPreview() {
Log.e(TAG, "startPreview");
Camera theCamera = camera;
if (theCamera != null && !previewing) {
theCamera.startPreview();
previewing = true;
autoFocusManager = new AutoFocusManager(camera);
}
} /**
* 关闭预览
*/
public synchronized void stopPreview() {
Log.e(TAG, "stopPreview");
if (autoFocusManager != null) {
autoFocusManager.stop();
autoFocusManager = null;
}
if (camera != null && previewing) {
camera.stopPreview();
camera.setPreviewCallback(null); // Camera is being used after Camera.release() was called
previewing = false;
}
} /**
* 打开闪光灯
*/
public synchronized void openLight() {
Log.e(TAG, "openLight");
if (camera != null) {
parameters = camera.getParameters();
parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
camera.setParameters(parameters);
}
} /**
* 关闭闪光灯
*/
public synchronized void offLight() {
Log.e(TAG, "offLight");
if (camera != null) {
parameters = camera.getParameters();
parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
camera.setParameters(parameters);
}
} /**
* 拍照
*
* @param shutter ShutterCallback
* @param raw PictureCallback
* @param jpeg PictureCallback
*/
public synchronized void takePicture(final Camera.ShutterCallback shutter, final Camera.PictureCallback raw,
final Camera.PictureCallback jpeg) {
camera.takePicture(shutter, raw, jpeg);
} private Bitmap reSize(byte[] data) {
Log.i(TAG, "myJpegCallback:onPictureTaken...");
Bitmap cutMap = BitmapFactory.decodeByteArray(data, 0, data.length);//data是字节数据，将其解析成位图
//设置FOCUS_MODE_CONTINUOUS_VIDEO)之后，myParam.set("rotation", 90)失效。图片竟然不能旋转了，故这里要旋转下
Matrix matrix = new Matrix();
matrix.postRotate((float) 90.0);
Bitmap rotaBitmap = Bitmap.createBitmap(cutMap, 0, 0, cutMap.getWidth(), cutMap.getHeight(), matrix, false); //旋转后rotaBitmap是960×1280.预览surfaview的大小是540×800
//将960×1280缩放到540×800
Bitmap sizeBitmap = Bitmap.createScaledBitmap(rotaBitmap, 540, 800, true);
Bitmap rectBitmap = Bitmap.createBitmap(sizeBitmap, 100, 200, 300, 300);//截取
return rectBitmap;
}
}
CameraManager