安卓相机自动对焦

Question

我在 android 中有一个相机应用程序。它是一个自定义相机。我想使用自动对焦。但我不能那样做。如何设置自动对焦以及我必须打电话的地方。我尝试了很多，但我无法修复它。请帮助我。

这是我的自定义相机 Activity :

public class CustomCameraActivity extends Activity implements
    SurfaceHolder.Callback {

Camera camera;
SurfaceView surfaceView;
SurfaceHolder surfaceHolder;
boolean previewing = false;
LayoutInflater controlInflater = null;
Context context;
 Button btn1;
 Button btn2;
ImageView imageView;
private Sensor mOrientaion1;
int cameraId = 0;
public final String TAG = "CustomCamera";
private OrientationEventListener orientationListener = null;

private SensorManager sensorManager;
float[] mGravs = new float[3];
float[] mGeoMags = new float[3];
float[] mRotationM = new float[16];
float[] mInclinationM = new float[16];
float[] mOrientation = new float[3];
float[] mOldOreintation = new float[3];
String[] mAccelerometer = new String[3];
String[] mMagnetic = new String[3];
String[] mRotation = new String[16];
String[] mInclination = new String[16];
String[] mOrientationString = new String[3];
String[] mOldOreintationString = new String[3];

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

    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

    setContentView(R.layout.main);
    context = this;

    sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    mOrientaion1 = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

    orientationListener = new OrientationEventListener(this) {
        public void onOrientationChanged(int orientation) {
            setCameraDisplayOrientation(CustomCameraActivity.this, cameraId, camera);
        }
    };

    // setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

    //imageView = (ImageView) findViewById(R.id.imgError);

    getWindow().setFormat(PixelFormat.UNKNOWN);
    surfaceView = (SurfaceView) findViewById(R.id.camerapreview);
    surfaceHolder = surfaceView.getHolder();
    surfaceHolder.addCallback(this);
    surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    controlInflater = LayoutInflater.from(getBaseContext());
    View viewControl = controlInflater.inflate(R.layout.custom, null);
    LayoutParams layoutParamsControl = new LayoutParams(
            LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);

    btn1 = (Button) viewControl.findViewById(R.id.Button01);
    btn2 = (Button) viewControl.findViewById(R.id.Button02);

    btn1.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View arg0) {
            // Toast.makeText(context, "1111111111111111111111111",
            // Toast.LENGTH_SHORT).show();

            camera.takePicture(null, null, mPicture);
            btn1.setVisibility(View.INVISIBLE);
            btn2.setVisibility(View.INVISIBLE);
            Constant.rotationValueForCamera = Constant.rotationValue;
        }
    });

    btn2.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View arg0) {
            // Toast.makeText(context, "22222222222222222222222222",
            // Toast.LENGTH_SHORT).show();
            Log.e("0 imagePickerStatus", Constant.imagePickerStatus + "");

            Constant.imagePickerStatus = 0;

            Log.e("0 imagePickerStatus", Constant.imagePickerStatus + "");

            finish();
        }
    });

    this.addContentView(viewControl, layoutParamsControl);

    int ot = getResources().getConfiguration().orientation;

    if (Configuration.ORIENTATION_LANDSCAPE == ot) {
        //imageView.setVisibility(View.GONE);
        Log.e("ori1111", "land");
    } else {
        //imageView.setVisibility(View.VISIBLE);
        Log.e("ori111", "port");
    }
}



public String getPollDeviceAttitude() {

    return Constant.rotationValueForCamera;
}

private SensorEventListener sensorEventListener = new SensorEventListener() {

    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER)
            mGravs = event.values.clone();// Fill gravityMatrix with accelerometer values
        else if(event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
            mGeoMags = event.values.clone();// Fill geomagneticMatrix with magnetic-field sensor values
        if(mGravs != null && mGeoMags != null){
            mRotationM = new float[16];
            mInclinationM = new float[16];

            SensorManager.getRotationMatrix(mRotationM, mInclinationM, mGravs, mGeoMags);// Retrieve RMatrix, necessary for the getOrientation method
            SensorManager.getOrientation(mRotationM, mOrientation);// Get the current orientation of the device

            float r2d = 180f/(float)Math.PI;

            DecimalFormat format = new DecimalFormat("#.##");

            float[] ang = { 0.0f, mOrientation[1]*r2d, mOrientation[2]*r2d };

            if ( ang[2] < 0.0f ) 
            {
                ang[2] = ang[2] + 90.0f;
            }
            else
            {
                ang[2] = 90 - ang[2];
                ang[1] = -ang[1];
            }

            String x = format.format(ang[2]); //format.format(mOrientation[0]*r2d);
            String y = format.format(ang[0]);
            String z = format.format(ang[1]);

            Constant.rotationValue =
                    x + " " +
                    y + " " +
                    z;
        }
    }

};

protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(sensorEventListener);
    orientationListener.disable();

}

@Override
public void onResume() {
    super.onResume();
    btn1.setVisibility(View.VISIBLE);
    btn2.setVisibility(View.VISIBLE);
    sensorManager.registerListener(sensorEventListener,
            sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
            SensorManager.SENSOR_DELAY_NORMAL);
    sensorManager.registerListener(sensorEventListener,
            sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
            SensorManager.SENSOR_DELAY_NORMAL);
    sensorManager.registerListener(sensorEventListener,
            sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
            SensorManager.SENSOR_DELAY_NORMAL);

    if (Constant.isCapturedOk) {
        Constant.isCapturedOk = false;

        finish();
    }

}

PictureCallback mPicture = new PictureCallback() {
    @Override
    public void onPictureTaken(byte[] data, Camera camera) {
        Constant.imageData1 = data;
        Log.e("Camrera", "22222222222222222");
        BitmapFactory.Options bfo = new BitmapFactory.Options();
        bfo.inDither = false;
        // bfo.inJustDecodeBounds = true;
        bfo.inPurgeable = true;
        bfo.inTempStorage = new byte[16 * 1024];

        Intent intent = new Intent(context, PreviewActivity.class);
        // intent.putExtra("data", data);
        Bitmap bitmapPicture = BitmapFactory.decodeByteArray(data, 0,
                data.length, bfo);
        Matrix matrix = new Matrix();
        if (Constant.result == 0) {
            matrix.postRotate(90);
        }
        if (Constant.result == 90) {
            matrix.postRotate(0);
        }
        if (Constant.result == 180) {
            matrix.postRotate(270);
        }
        if (Constant.result == 270) {
            matrix.postRotate(180);
        }
        int height = bitmapPicture.getHeight();
        int width = bitmapPicture.getWidth();
        //Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmapPicture,
                //height, width, true);
        Bitmap rotatedBitmap = Bitmap.createBitmap(bitmapPicture, 0, 0,
                bitmapPicture.getWidth(), bitmapPicture.getHeight(), matrix,
                true);
        ByteArrayOutputStream blob = new ByteArrayOutputStream();
        Log.e("Camrera1", "22222222222222222");
        rotatedBitmap.compress(CompressFormat.JPEG,
                50 /* ignored for PNG */, blob);
        byte[] bitmapdata = blob.toByteArray();
        Constant.imageData = bitmapdata;
        Log.e("Camrera2", "22222222222222222");
        startActivity(intent);
        overridePendingTransition(R.anim.slide_right, R.anim.slide_left);
    }
};


@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
        int height) {
    Camera.Parameters parameters = camera.getParameters();
    Camera.Size size = getBestPreviewSize(width, height);    
    parameters.setPreviewSize(size.width, size.height); // preview size
    camera.setParameters(parameters);
    if (previewing) {
        camera.stopPreview();
        previewing = false;
    }

    if (camera != null) {
        try {
            camera.setPreviewDisplay(holder);
            camera.startPreview();
            setCameraDisplayOrientation(this, 1, camera);
            previewing = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


public static void setCameraDisplayOrientation(Activity activity,
        int cameraId, android.hardware.Camera camera) {
    android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
    android.hardware.Camera.getCameraInfo(cameraId, info);

    int rotation = activity.getWindowManager().getDefaultDisplay()
            .getRotation();
    int degrees = 0;
    switch (rotation) {
    case Surface.ROTATION_0:
        degrees = 0;
        Constant.result = 0;
        break;
    case Surface.ROTATION_90:
        degrees = 90;
        Constant.result = 90;
        break;
    case Surface.ROTATION_180:
        degrees = 180;
        Constant.result = 180;
        break;
    case Surface.ROTATION_270:
        degrees = 270;
        Constant.result = 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;
    }
    if(camera != null)
    camera.setDisplayOrientation(result);
}






private Camera.Size getBestPreviewSize(int width, int height)
{

            // Get For Photo Size
    Camera.Parameters camparams = camera.getParameters();

    // Find the Largest Possible Preview Sizes
    List<Size> sizes = camparams.getSupportedPreviewSizes();
    Camera.Size result=null;
    for (Size s : sizes) {

        if (s.width <= width && s.height <= height) {
                   if (result == null) {
                    result = s;
                   } else {
                    int resultArea=result.width*result.height; 
                    int newArea=s.width*s.height;

                    if (newArea>resultArea) {
                                        result=s;
                    }
                       } // end else (result=null)
            } // end if (width<width&&height<height)
    } // end for

        return result;

} // end function

@Override
public void surfaceCreated(SurfaceHolder holder) {
    orientationListener.enable();
    camera = Camera.open();
}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
    orientationListener.disable();
    camera.stopPreview();
    camera.release();
    camera = null;
    previewing = false;
}

@Override
protected void onStop() {
    super.onStop();

    Log.e("Tab", "Stoping");
}

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {

    if (keyCode == KeyEvent.KEYCODE_BACK) {

        return true;

    }
    return super.onKeyDown(keyCode, event);

}
}

Answer 1

public class CustomCameraActivity extends Activity {

Camera camera;
SurfaceView surfaceView;
SurfaceHolder surfaceHolder;
boolean previewing = false;
LayoutInflater controlInflater = null;
ProgressDialog dialog;
Bitmap bmp;
ImageView img;


@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    surfaceView = (SurfaceView)findViewById(R.id.camerapreview);
    surfaceHolder = surfaceView.getHolder();
    surfaceHolder.addCallback(surfaceCallback);
    surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    controlInflater = LayoutInflater.from(getBaseContext());
    View viewControl = controlInflater.inflate(R.layout.custom, null);
    LayoutParams layoutParamsControl = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
    this.addContentView(viewControl, layoutParamsControl);


}
@Override
public void onResume() {
    super.onResume();
    camera = Camera.open();
}

@Override
public void onPause() {
    if (previewing) {
        camera.stopPreview();
    }

    camera.release();
    camera = null;
    previewing = false;
    super.onPause();
}

SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try {
            camera.setPreviewDisplay(surfaceHolder);
        } catch (Throwable t) {
            Log.e("PreviewDemo-surfaceCallback","Exception in setPreviewDisplay()", t);
            Toast.makeText(CustomCameraActivity.this, t.getMessage(), Toast.LENGTH_LONG).show();
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        Camera.Parameters parameters = camera.getParameters();
        if (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);
       }

        parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
        parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
        List<Size> sizes = parameters.getSupportedPictureSizes();
        Camera.Size size = sizes.get(0);
        for(int i=0;i<sizes.size();i++)
        {
            if(sizes.get(i).width > size.width)
                size = sizes.get(i);
        }
        parameters.setPictureSize(size.width, size.height);
        camera.setParameters(parameters);
        camera.startPreview();
        previewing = true;
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
    }
};
Camera.AutoFocusCallback autoFocus=new AutoFocusCallback() {
    ShutterCallback shutterCallback =new ShutterCallback() {

        @Override
        public void onShutter() {
            AudioManager mgr = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
            mgr.playSoundEffect(AudioManager.FLAG_PLAY_SOUND);

        }
    };
    Camera.PictureCallback photoCallback = new Camera.PictureCallback() {
        @Override
        public void onPictureTaken(final byte[] data, final Camera camera) {
            dialog = ProgressDialog.show(CustomCameraActivity.this, "", "Saving Photo");
            new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception ex) {}
                    onPictureTake(data, camera);
                }
            }.start();
        }
    };

    @Override
    public void onAutoFocus(boolean success, Camera camera) {
        camera.takePicture(shutterCallback,null, null, photoCallback);
    }
};


Camera.PictureCallback photoCallback = new Camera.PictureCallback() {
    @Override
    public void onPictureTaken(final byte[] data, final Camera camera) {
        dialog = ProgressDialog.show(CustomCameraActivity.this, "", "Saving Photo");
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {}
                onPictureTake(data, camera);
            }
        }.start();
    }
};



public void onPictureTake(byte[] data, Camera camera) {

    bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
    dialog.dismiss();
}


public void AutoFocus(View v) {
        camera.autoFocus(autoFocus);
    }