摄像头(4)用Camera和SurfaceView自定义拍照程序

1.定制拍照程序的基本步骤

　　1,打开照相机：Camera.open 这是独占方式打开的

　　2,创建SurfaceView对象 多缓冲,多线程view

　　3,添加回调事件监听器（SurfaceHolder.addCallback）

　　4,预览（Camera.startPreview）

　　5,拍照（Camera.takePicture）,它是异步的,要在参数中指定回调函数

2.示例

2.1 主activity

 import android.app.Activity;
 import android.content.pm.PackageManager;
 import android.hardware.Camera;
 import android.os.Bundle;
 import android.view.Window;
 import android.view.WindowManager;

 /*
  * 定制拍照程序
  * 注意Camera从5.0开始过期.用Camera2
  */
 public class CustomCameraActivity extends Activity {

     //定制拍照 第1步,加权限

     //定制拍照 第2步,准备相关api
     private Camera mCamera;//用来拍照

     private Preview mPreview;//用来预览和处理拍照事件.它是一个自定义surfaceView

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         //定制拍照 第3步,设置全屏.
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);

     }

     protected void onResume() {
         super.onResume();
         //定制拍照 第4步, 打开 Camera并得到Camera实例,注意这是独占的,打开后其它程序不能打开.
         mCamera = Camera.open();
         mPreview.setCamera(mCamera);

         //定制拍照 第5步,构造预览view,这是一个自定义的surfaceView,拍照事件,及预览都在它内部实现.
         mPreview = new Preview(this);
         setContentView(mPreview);
     }

     //定制拍照 第6步,释放camera
     @Override
     protected void onPause() {
         super.onPause();

         if (mCamera != null) {
             mCamera.release();
             mCamera = null;
             mPreview.setCamera(null);
         }
     }

     //检测Android设备是否支持照相机
     private boolean checkCameraHardware(){
         if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
             return true;
         }else{
             return false;
         }
     }
 }

2.2 用来预览和处理拍照事件的类,关键

 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.List;

 import android.content.Context;
 import android.hardware.Camera;
 import android.hardware.Camera.PictureCallback;
 import android.hardware.Camera.Size;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.View.OnClickListener;

 /*
  * 它是一个自定义surfaceView,
  * 用来预览和处理拍照事件.
  * 注意它实现的接口
  */
 class Preview extends ViewGroup implements SurfaceHolder.Callback,OnClickListener {

     //自定义预览和处理拍照事件 第1步, 准备相关成员
     SurfaceView mSurfaceView;             //surface view
     SurfaceHolder mHolder;                //SurfaceHolder
     Size mPreviewSize;                    //当前预览窗口尺寸.
     List<Size> mSupportedPreviewSizes;    //当前设备支持的所有预览尺寸
     Camera mCamera;                        //摄像头对象
     Context mContext;                    //上下文

     public Preview(Context context) {
         super(context);
         mContext = context;

         //自定义预览和处理拍照事件 第2步,创建surface view
         mSurfaceView = new SurfaceView(context);
         addView(mSurfaceView);
         //自定义预览和处理拍照事件 第3步,得到 SurfaceHolder
         mHolder = mSurfaceView.getHolder();

         //自定义预览和处理拍照事件 第4步,添加SurfaceHolder回调
         mHolder.addCallback(this);
     }
     public void setCamera(Camera camera) {
         mCamera = camera;
         if (mCamera != null) {
             //自定义预览和处理拍照事件 第5步,得到支持的预览尺寸,注意Camera是在本类外打开的.
             mSupportedPreviewSizes = mCamera.getParameters().getSupportedPictureSizes();
             //更新 layout
             requestLayout();
         }
     }
     //from  SurfaceHolder.Callback
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         try {
             if (mCamera != null) {
                 //自定义预览和处理拍照事件 第6步,在SurfaceView创建时,设置camera的预览view
                 mCamera.setPreviewDisplay(holder);
             }
         } catch (Exception e) {
         }

     }
     //from  SurfaceHolder.Callback
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         if (mCamera != null) {
             //自定义预览和处理拍照事件 第7步,在SurfaceView销毁时,停止预览
             mCamera.stopPreview();
         }
     }
     //from  SurfaceHolder.Callback
     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width,
             int height) {
         //自定义预览和处理拍照事件 第8步,在SurfaceView窗口大小变化时,设置预览尺寸,大小不可随意写.
         //一定要注意 预览尺寸不是实际尺寸,
         Camera.Parameters parameters = mCamera.getParameters();
         parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);

         mCamera.setParameters(parameters);
         mCamera.startPreview();

     }
     //from ViewGroup
     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         //自定义预览和处理拍照事件 第9步,是本类是ViewGroup,预览view是它上面的一个view,这里设置ViewGroup的layout
         if (changed && getChildCount() > ) {
             final View child = getChildAt();

             int parentWidth = r - l;
             int parentHeight = b - t;

             int previewWidth = parentWidth;
             int previewHeight = parentHeight;

             if (mPreviewSize != null) {
                 previewWidth = mPreviewSize.width;
                 previewHeight = mPreviewSize.height;
             }
             //外层的宽高比大于采集预览的宽高比.
             if (parentWidth * previewHeight > parentHeight * previewWidth) {
                 final int scaledChildWidth = previewWidth * parentHeight
                         / previewHeight;
                 // child.layout((width - scaledChildWidth)/2,
                 // 0,(width+scaledChildWidth)/2,height);

                 //child 就是surface view
                 child.layout(, , , );
             } else {
                 final int scaledChildHeight = previewHeight * parentWidth
                         / previewWidth;
                 //child 就是surface view
                 child.layout(, (parentHeight - scaledChildHeight) / , parentWidth,
                         (parentHeight + scaledChildHeight) / );
             }

         }

     }
     //自定义预览和处理拍照事件 第10步,从所有预览尺寸中选一个最优的.
     private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
         double ASPECT_TOLERANCE = 0.1;
         double targetRatio = w / h;
         if (sizes == null)
             return null;

         Size optimalSize = null;
         double minDiff = Double.MAX_VALUE;
         int targetHeight = h;

         for (Size size : sizes) {
             double ratio = size.width / size.height;
             if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) {
                 continue;
             }
             if (Math.abs(size.height - targetHeight) < minDiff) {
                 optimalSize = size;
                 minDiff = Math.abs(size.height - targetHeight);
             }
         }

         if (optimalSize == null) {
             minDiff = Double.MAX_VALUE;
             for (Size size : sizes) {
                 if (Math.abs(size.height - targetHeight) < minDiff) {
                     optimalSize = size;
                     minDiff = Math.abs(size.height - targetHeight);
                 }
             }
         }
         return optimalSize;
     }

     //自定义预览和处理拍照事件 第11步,在onMeasure中处理最佳预览尺寸
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int width = resolveSize(getSuggestedMinimumWidth(),
                 widthMeasureSpec);
         int height = resolveSize(getSuggestedMinimumHeight(),
                 heightMeasureSpec);

         setMeasuredDimension(width, height);

         if (mSupportedPreviewSizes != null) {
             mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes,width, height);
         }
     }
     //自定义预览和处理拍照事件 第12步, 在预览view上点击屏幕时,拍照
     //注意回调函数
     public void onClick(View view) {
         //它是异步的.
         mCamera.takePicture(null, null, mPictureCallback);
     }

     //自定义预览和处理拍照事件 第13步, 拍照的回调.
     private PictureCallback mPictureCallback = new PictureCallback() {

         @Override
         public void onPictureTaken(byte[] data, Camera camera) {
             mCamera.startPreview();//再次启动预览,这步可选.
             File pictureFile = new File("/sdcard/image.jpg");
             try {
                 FileOutputStream fos = new FileOutputStream(pictureFile);
                 fos.write(data);
                 fos.close();
             } catch (Exception e) {
             }
         }
     };
 }