转载请注明出处:
http://blog.csdn.net/xiaohao0724/article/details/68488145
这两天在研究自定义Camera,解决了预览变形、横屏问题下面来记录下成果。
老规矩先上图:
要想自定义相机需要用到两个核心类：Camera和SurfaceView
Camera类一些API
Camera用于管理和操作camera资源，它提供了完整的相机底层接口。可以通过camera.getParameters()来获取Camera的参数用以设置照片的预览尺寸、拍摄尺寸、预览帧、拍摄帧、设定光圈、曝光、聚焦、颜色特效等。
SurfaceView类
用于绘制相机预览图像的类，提供给用户实时的预览图像。普通的view以及派生类都是共享同一个surface的，所有的绘制都必须在UI线程中进行。而surfaceview是一种比较特殊的view，它并不与其他普通view共享surface，而是在内部持有了一个独立的surface,surfaceview负责管理这个surface的格式、尺寸以及显示位置。由于UI线程还要同时处理其他交互逻辑，因此对view的更新速度和帧率无法保证，而surfaceview由于持有一个独立的surface，因而可以在独立的线程中进行绘制，因此可以提供更高的帧率。自定义相机的预览图像由于对更新速度和帧率要求比较高，所以比较适合用surfaceview来显示。
SurfaceHolder
surfaceholder是控制surface的一个抽象接口，它能够控制surface的尺寸和格式，修改surface的像素，监视surface的变化等等，surfaceholder的典型应用就是用于surfaceview中。surfaceview通过getHolder()方法获得surfaceholder 实例，通过后者管理监听surface 的状态。
SurfaceHolder.Callback 接口
负责监听surface状态变化的接口，有三个方法：
surfaceCreated(SurfaceHolder holder)
在surface创建后立即被调用。在开发自定义相机时，可以通过重载这个函数调用camera.open()、camera.setPreviewDisplay()，来实现获取相机资源、连接camera和surface等操作。
surfaceChanged(SurfaceHolder holder, int format, int width, int height)
在surface发生format或size变化时调用。在开发自定义相机时，可以通过重载这个函数调用camera.startPreview来开启相机预览，使得camera预览帧数据可以传递给surface，从而实时显示相机预览图像。
surfaceDestroyed(SurfaceHolder holder)
在surface销毁之前被调用。在开发自定义相机时，可以通过重载这个函数调用camera.stopPreview()，camera.release()来实现停止相机预览及释放相机资源等操作。
Code
下面我们就来根据上面来用代码实现自定义相机
public class CustomCameraActivity extends Activity implements OnClickListener,
SurfaceHolder.Callback, Camera.PictureCallback {
private Camera camera;
private static final String TAG = "Havorld";
private Camera.Parameters parameters;
private int orientationDegrees = 90;
private FrameLayout frameLayout;
private ImageButton imageButton, reset, ok;
/** 路径: /storage/emulated/0/Pictures/ */
private String savePath;
private String path;
private SurfaceHolder surfaceHolder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_camera);
savePath = Environment
.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)
+ File.separator;
SurfaceView surfaceView = (SurfaceView) findViewById(R.id.surfaceView);
surfaceView.setOnClickListener(this);
frameLayout = (FrameLayout) findViewById(R.id.frameLayout);
imageButton = (ImageButton) findViewById(R.id.imageButton);
reset = (ImageButton) findViewById(R.id.reset);
ok = (ImageButton) findViewById(R.id.ok);
frameLayout.setOnClickListener(this);
imageButton.setOnClickListener(this);
reset.setOnClickListener(this);
ok.setOnClickListener(this);
// 到SurfaceHolder,SurfaceHolder相当于一个监听器,可以通过CallBack来监听 SurfaceView上的变化。
surfaceHolder = surfaceView.getHolder();
surfaceHolder.addCallback(this);
// 为了实现照片预览功能，需要将SurfaceHolder的类型设置为PUSH,这样画图缓存就由Camera类来管理，画图缓存是独立于Surface的
surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
startOrientationChangeListener();
}
private final void startOrientationChangeListener() {
OrientationEventListener mOrEventListener = new OrientationEventListener(
this) {
@Override
public void onOrientationChanged(int rotation) {
if (((rotation >= 0) && (rotation <= 45)) || (rotation >= 315)) {
orientationDegrees = 90;
} else if ((rotation > 45) && (rotation < 135)) {
orientationDegrees = 180;
} else if ((rotation >= 135) && (rotation <= 225)) {
orientationDegrees = 270;
} else if ((rotation > 225) && (rotation < 315)) {
orientationDegrees = 0;
}
// Log.e(TAG, "rotation："+rotation);
}
};
mOrEventListener.enable();
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
Log.e(TAG, "surfaceCreated");
surfaceHolder = holder;
initCamera();
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
Log.e(TAG, "surfaceChanged");
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.e(TAG, "surfaceDestroyed");
// 当Surface被销毁的时候，该方法被调用
// 在这里需要释放Camera资源
releaseCamera();
}
@SuppressWarnings("deprecation")
private void initCamera() {
// 判断是否有摄像头
if (!getPackageManager()
.hasSystemFeature(PackageManager.FEATURE_CAMERA))
return;
// 获取摄像头的个数
// int numberOfCameras = Camera.getNumberOfCameras();
// 后置摄像头
camera = Camera.open(Camera.CameraInfo.CAMERA_FACING_BACK);
/**
* 获取设备Camera特性参数。由于不同的设备Camera的特性是不同的，所以在设置时需要首先判断设备对应的特性，再加以设置
*/
parameters = camera.getParameters();
// 获取可预览的尺寸集合
List<Size> supportedPreviewSizes = parameters
.getSupportedPreviewSizes();
Size previewSize = PreviewSizeUtil
.getSupportSize(supportedPreviewSizes);
// 获取可设置图片的大小集合
List<Size> supportedPictureSizes = parameters
.getSupportedPictureSizes();
// 设置生成最大的图片
// Size pictureSize =
// PreviewSizeUtil.getSupportSize(supportedPictureSizes);
Size pictureSize = supportedPictureSizes.get((supportedPictureSizes
.size() - 1) / 2);
// 获取可设置的帧数
List<Integer> supportedPreviewFrameRates = parameters
.getSupportedPreviewFrameRates();
Integer frameRates = supportedPreviewFrameRates
.get((supportedPreviewFrameRates.size() - 1) / 2);
// 设置Camera的参数
parameters.setPreviewSize(previewSize.width, previewSize.height);
parameters.setPictureSize(pictureSize.width, pictureSize.height);
// 设置帧数(每秒从摄像头里面获得几个画面)
parameters.setPreviewFrameRate(frameRates);
// 设置图片格式
parameters.setPictureFormat(ImageFormat.JPEG);
// 设置照片质量
parameters.setJpegQuality(100);
// 首先获取系统设备支持的所有颜色特效，如果设备不支持颜色特性将返回一个null， 如果有符合我们的则设置
List<String> colorEffects = parameters.getSupportedColorEffects();
Iterator<String> colorItor = colorEffects.iterator();
while (colorItor.hasNext()) {
String currColor = colorItor.next();
if (currColor.equals(Camera.Parameters.EFFECT_SOLARIZE)) {
// parameters.setColorEffect(Camera.Parameters.EFFECT_AQUA);
break;
}
}
// 获取对焦模式
List<String> focusModes = parameters.getSupportedFocusModes();
// [auto, infinity, macro, continuous-video, continuous-picture, manual]
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
// 设置自动对焦
parameters.setFocusMode(Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
// 设置闪光灯自动开启
List<String> flashModes = parameters.getSupportedFlashModes();
if (flashModes.contains(Camera.Parameters.FLASH_MODE_AUTO)) {
// 自动闪光
parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
}
int orientationDegrees = PreviewSizeUtil.getCameraDisplayOrientation(
this, Camera.CameraInfo.CAMERA_FACING_BACK);
// 设置相机镜头旋转角度(默认摄像头是横拍)
camera.setDisplayOrientation(orientationDegrees);
try {
// 设置显示
camera.setPreviewDisplay(surfaceHolder);
} catch (IOException exception) {
releaseCamera();
}
// 设置完成需要再次调用setParameter方法才能生效
camera.setParameters(parameters);
// 开始预览
camera.startPreview();
}
private void releaseCamera() {
if (camera != null) {
camera.setPreviewCallback(null);
camera.stopPreview();
camera.release();
camera = null;
}
}
@Override
public void onPictureTaken(byte[] data, Camera camera) {
path = savePath + "XiuMF_" + System.currentTimeMillis() + ".jpg";
File file = new File(path);
OutputStream output = null;
try {
output = new FileOutputStream(file);
output.write(data);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 拍照后预览会停止，重新开启下
camera.startPreview();
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.frameLayout:
case R.id.imageButton:
if (parameters != null) {
// 设置照片在相册的旋转角度(默认摄像头是横放)
// parameters.setRotation(orientationDegrees);
parameters.set("rotation", orientationDegrees);
// 获取当前手机屏幕方向
camera.setParameters(parameters);
Log.e(TAG, "orientationDegrees:" + orientationDegrees);
}
/**
* ShutterCallback shutter:按下快门的回调 PictureCallback raw:原始图像数据的回调
* PictureCallback postview:压缩图像 PictureCallback
* jpeg:压缩成jpg格式的图像数据的回调
*/
camera.takePicture(null, null, null, this);
break;
case R.id.ok:// 获取照片
Intent intent = getIntent();
if (intent != null) {
intent.putExtra("path", path);
setResult(-1, intent);
}
finish();
break;
case R.id.reset: // 删除照片
File file = new File(path);
if (file.exists()) {
file.delete();
}
file = null;
break;
default:
break;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
releaseCamera();
}
}
PreviewSizeUtil类
public class PreviewSizeUtil {
/**
* 获取最大的预览/图片尺寸
*
* @return 预览尺寸集合
*/
public static Size getSupportSize(List<Size> listSize) {
if (listSize == null || listSize.size() <= 0) {
return null;
}
Size largestSize = listSize.get(0);
if (listSize.size() > 1) {
Iterator<Camera.Size> iterator = listSize.iterator();
while (iterator.hasNext()) {
Camera.Size size = iterator.next();
if (size.width > largestSize.width && size.height > largestSize.height) {
largestSize = size;
}
}
}
return largestSize;
}
/**
* 获取拍照时偏移方向的角度(此方法在手机方向没有锁定，为*切换时易用)
*
* @param activity
* @param cameraId 开启相机的id(0.后相机,1.前相机)
* @return 偏移的角度
*/
public static int getCameraDisplayOrientation(Activity activity,
int cameraId) {
CameraInfo info = new Camera.CameraInfo();
Camera.getCameraInfo(cameraId, info);
int rotation = activity.getWindowManager().getDefaultDisplay()
.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;
}
int result;
if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
result = (info.orientation + degrees) % 360;
result = (360 - result) % 360; // compensate the mirror
} else { // back-facing
result = (info.orientation - degrees + 360) % 360;
}
return result;
}
}