android camera 根据加速器的变化实现自动对焦

实现的效果是当加速器的变化在设定范围外时，相机会自动对焦。


public class MainActivity extends AppCompatActivity implements SurfaceHolder.Callback {

    private SurfaceView surfaceview;
    private SurfaceHolder surfaceholder;
    private Camera camera = null;
    private ImageView imageView;
    private Button startPre;
    private Button stopPre;
    private Button getPicture;
    private SensorManager sensorManager;
    private MyListener myListener;
    private Sensor mySensor;

    private float mLastX;
    private float mLastY;
    private float mLastZ;
    private boolean initBool = false;
    private boolean myAutoFocus = true;
    private Camera.AutoFocusCallback autoFocusCallback;
    private Camera.Parameters parameters;
    private WindowManager wm;
    private int screenWidth;
    private int screenHeight;

/*    通过Camera方式来实现拍照
    通过Camera方式 会比通过Intent方式获得更为丰富的功能。通常创建一个定制化的Camera需要如下步骤：
            (1)    通过Camera.open()来获取Camera实例。
            (2)    创建Preview类，需要继承SurfaceView类并实现SurfaceHolder.Callback接口。
            (3)    为相机设置Preview
            (4)    构建一个Preview的Layout来 预览相机；
            (5)    为拍照建立Listener以获取拍照后的回调;
            (6)    拍照并保存文件;
            (7)    释放Camera。*/


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initSensor();
        initView();
        initEvent();

    }

    //初始化加速传感器
    private void initSensor() {
        sensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);
        mySensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        myListener = new MyListener();
        List<Sensor> list = sensorManager.getSensorList(Sensor.TYPE_ALL);
        //全部传感器
        for(Sensor sensor:list){
             Log.i("----->",""+sensor.getName());
        }
    }

    private void initView() {
        surfaceview = (SurfaceView) findViewById(R.id.surfaceview);
        startPre = (Button) this.findViewById(R.id.beginPrievw);
        stopPre = (Button) this.findViewById(R.id.stopPrievw);
        getPicture = (Button) this.findViewById(R.id.getPicture);
        imageView = (ImageView) this.findViewById(R.id.imageView);
    }

    private void initEvent() {

        surfaceholder = surfaceview.getHolder();
        surfaceholder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        surfaceholder.addCallback(this);

        stopPre.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                camera.stopPreview();
            }
        });

        getPicture.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                camera.takePicture(null, null, pictureCallback);
            }
        });

        //初始化自动对焦回掉
        autoFocusCallback = new Camera.AutoFocusCallback() {
            @Override
            public void onAutoFocus(boolean b, Camera camera) {
                myAutoFocus = true;
                if (b) {
                    camera.cancelAutoFocus();
                    Log.i("=========>", "对焦成功！");
                } else {
                    Log.i("=========>", "对焦失败！");
                }
            }
        };

        //获取屏幕的宽和高
         wm = (WindowManager)this
                .getSystemService(Context.WINDOW_SERVICE);
         screenWidth = wm.getDefaultDisplay().getWidth();
         screenHeight = wm.getDefaultDisplay().getHeight();
    }

    @Override
    public void surfaceCreated(SurfaceHolder surfaceHolder) {
        Log.i("------->", "surfaceCreated");
        System.out.println("surfacecreated");
        //获取camera对象
        if (camera == null) {
            camera = Camera.open();
            Log.i("------->", "Camera open");
        }
        try {
            //设置预览监听
            camera.setPreviewDisplay(surfaceHolder);
            parameters = camera.getParameters();
            List<Camera.Size> sizeList = parameters.getSupportedPreviewSizes();
//            parameters.setPictureFormat(PixelFormat.JPEG);
//            parameters.setJpegQuality(CameraProfile.QUALITY_HIGH);

            Log.i("pictureFromat",""+parameters.getPictureFormat());

            parameters.setPictureSize(3840, 2160);

            //获得相机的对焦模式有哪些
//            List<String> focusModes = parameters.getSupportedFocusModes();
//            for (String mode:focusModes){
//             //   Log.i("==-------->",""+mode);
//            }
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);

//            List<String> focusModes = parameters.getSupportedFocusModes();
//          //得到摄像头支持的分辨率
//          if (sizeList.size() > 1){
//                Iterator<Camera.Size> itor = sizeList.iterator();
//                while(itor.hasNext()){
//                    Camera.Size cur = itor.next();
//                    Log.i("------->","width:"+cur.width+"  "+cur.height);
//                }
//            }

            //设置预览的方向
            if (this.getResources().getConfiguration().orientation
                    != Configuration.ORIENTATION_LANDSCAPE) {
                parameters.set("orientation", "portrait");
                camera.setDisplayOrientation(90);
                parameters.setRotation(90);
            } else {
                parameters.set("orientation", "landscape");
                camera.setDisplayOrientation(0);
                parameters.setRotation(0);
            }
            camera.setParameters(parameters);
            camera.startPreview();
            //camera.cancelAutoFocus();
        } catch (IOException e) {
            e.printStackTrace();
            camera.release();
            Log.e("---->","摄像头创建失败");
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
        Log.i("------->", "surfaceChanged");
        myAutoFocus();
    }

    //对焦
    private void myAutoFocus() {
        try {
            camera.autoFocus(autoFocusCallback);
        } catch (Exception e) {
            Log.d("---->", "" + e.getMessage());
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
        Log.i("------->", "surfaceDestroyed");

        System.out.println("surfaceDestroyed");
        if (camera != null) {
            camera.stopPreview();
            camera.release();
            camera = null;
        }
    }

/*  camera.takePicture(shutterCallback,rawcallback,pictureCallback);*/

    private Camera.ShutterCallback shutterCallback = new Camera.ShutterCallback() {
        @Override
        public void onShutter() {
            //按下快门瞬间的处理事件处
        }
    };

    private Camera.PictureCallback rawcallback = new Camera.PictureCallback() {
        @Override
        public void onPictureTaken(byte[] bytes, Camera camera) {
            //处理raw代码
        }
    };

    private Camera.PictureCallback pictureCallback = new Camera.PictureCallback() {
        @Override
        public void onPictureTaken(byte[] bytes, Camera camera) {

            File pictureFile = getOutputMediafile();

            if (pictureFile == null) {
                Log.e("--------->", "获取文件路径失败！");
                return;
            }
            try {
                FileOutputStream fos = new FileOutputStream(pictureFile);
                fos.write(bytes);
                fos.close();
                Log.i("--------->", "照片保存文件成功！");
            } catch (FileNotFoundException e) {
                Log.d("-------->", "row");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes,0,bytes.length);
            imageView.setImageBitmap(bitmap);
            camera.startPreview();
        }
    };


    //加速传感器监听

    public class MyListener implements SensorEventListener{
        @Override
        public void onSensorChanged(SensorEvent sensorEvent) {
            //values[0]:X轴，values[1]：Y轴，values[2]：Z轴
            float[] values = sensorEvent.values;
            float x = values[0];
            float y = values[1];
            float z = values[2];
            if (!initBool){
                mLastX = x;
                mLastY = y;
                mLastZ = z;
                initBool = !initBool;
            }
            float deltaX  = Math.abs(mLastX - x);
            float deltaY = Math.abs(mLastY - y);
            float deltaZ = Math.abs(mLastZ - z);

            if (deltaX > .5 && myAutoFocus){
                myAutoFocus = false;
                myAutoFocus();
            }
            if (deltaY > .5 && myAutoFocus){
                myAutoFocus = false;
                Log.i("---====---->","");
                myAutoFocus();
            }
            if (deltaZ > .5 && myAutoFocus){
                myAutoFocus = false;
                Log.i("---====---->","");
                myAutoFocus();
            }
            mLastX = x;
            mLastY = y;
            mLastZ = z;
        }

        @Override
        public void onAccuracyChanged(Sensor sensor, int i) {
            //传感器精度变化时使用
        }
    }

    private File getOutputMediafile() {
        File picDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String path = picDir.getPath() + File.separator + "IMAGE_" + timeStamp + ".jpg";
        Log.i("------------>", "文件保存路径是：" + path);
        return new File("/sdcard/Pictures/Test" + "IMAGE_" + timeStamp + ".jpg");
    }

    @Override
    protected void onPause() {
        super.onPause();
        camera.stopPreview();
        //注销传感器监听事件，若不，后台仍继续运行
        sensorManager.unregisterListener(myListener);
    }

    @Override
    protected void onResume() {
        super.onResume();
        camera.startPreview();

        //注册传感器监听事件
        boolean result = sensorManager.registerListener(myListener,mySensor,SensorManager.SENSOR_DELAY_NORMAL);
        Log.i("----->",""+result);
    }

}

布局文件

<pre name="code" class="html"><?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.example.myapplication.MainActivity">

    <SurfaceView
        android:id="@+id/surfaceview"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
            android:layout_alignParentTop="true"/>
    <ImageView
        android:id="@+id/imageView"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true"/>

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@+id/stopPrievw"
        android:layout_marginBottom="10dp"
        android:text="拍摄照片"
        android:id="@+id/getPicture"/>
    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="停止预览"
        android:layout_alignParentBottom="true"
        android:id="@+id/stopPrievw"/>
</RelativeLayout>