Camera对焦的几种方式

自动对焦

1、通过Camera的AutoFocusCallback

camera.cancelAutoFocus();  //每次对焦前取消自动对焦
final String currentFocusMode = params.getFocusMode();
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
camera.setParameters(params);
camera.autoFocus(new Camera.AutoFocusCallback() {
                @Override
                public void onAutoFocus(boolean success, Camera camera) {
                    if (success) {
                        focusImageView.onFocusSuccess(); //对焦完成可以进行一些操作，比如对焦框显示对焦成功的动画
                    } else {
                        Camera.Parameters params = camera.getParameters(); //有时对焦失败重新设置对焦模式
                        params.setFocusMode(currentFocusMode);
                        camera.setParameters(params);
                    }
                }
            });

这种方式发现在一些设备根本无法对上焦，当无法对上焦时，但是这种方式对焦会有回调可以知道啥时候相机对好焦了

2、设置对焦模式为 FOCUS_MODE_CONTINUOUS_PICTURE 这种方式用于拍照的连续自动对焦模式,但是记得加上camera.cancelAutoFocus()。

3、自动触发手动对焦（对于扫码这种应用，每隔一段两秒中心点手动对焦一次，效果也非常的好）

    public void timerFocuse(int x,int y){
        long downTime = SystemClock.uptimeMillis();
        final MotionEvent downEvent = MotionEvent.obtain(downTime, downTime,
                MotionEvent.ACTION_DOWN, x, y, 0);
        downTime += 1000;
        final MotionEvent upEvent = MotionEvent.obtain(downTime, downTime,
                MotionEvent.ACTION_UP,x, y, 0);
        onManualEvent(downEvent);       //调用手动对焦
        downEvent.recycle();
        upEvent.recycle();
    }

手动对焦

    public static final int FOCUS_METERING_AREA_WEIGHT_DEFAULT = 1000;
    public static final int FOCUS_AREA_SIZE_DEFAULT = 300;
    
    private boolean manualFocuse( MotionEvent event) {
        if (camera != null) {
            Camera.Parameters parameters = camera.getParameters();
            String focusMode = parameters.getFocusMode();
            Rect rect = calculateFocusArea(event.getX(), event.getY());
            List meteringAreas = new ArrayList<>();
            meteringAreas.add(new Camera.Area(rect, FOCUS_METERING_AREA_WEIGHT_DEFAULT));

            if (parameters.getMaxNumFocusAreas() != 0 && focusMode != null &&
                    (focusMode.equals(Camera.Parameters.FOCUS_MODE_AUTO) ||
                            focusMode.equals(Camera.Parameters.FOCUS_MODE_MACRO) ||
                            focusMode.equals(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE) ||
                            focusMode.equals(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO))
                    ) {
                if(!parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
                    return false; //cannot autoFocus
                }
                parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
                parameters.setFocusAreas(meteringAreas);
                if (parameters.getMaxNumMeteringAreas() > 0) {
                    parameters.setMeteringAreas(meteringAreas);
                }
                camera.setParameters(parameters);
            } else if (parameters.getMaxNumMeteringAreas() > 0) {
                if(!parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
                    return false; //cannot autoFocus
                }
                camera.setParameters(parameters);

            } else {
            }
        }
        return false;
    }
    
 private Rect calculateFocusArea(float x, float y) {
        int buffer = FOCUS_AREA_SIZE_DEFAULT / 2;
        int centerX = calculateCenter(x, surfaceView.getWidth(), buffer);
        int centerY = calculateCenter(y, surfaceView.getHeight(), buffer);
        return new Rect(
                centerX - buffer,
                centerY - buffer,
                centerX + buffer,
                centerY + buffer
        );
    }

 private static int calculateCenter(float coord, int dimen, int buffer) {
        int normalized = (int) ((coord / dimen) * 2000 - 1000);
        if (Math.abs(normalized) + buffer > 1000) {
            if (normalized > 0) {
                return 1000 - buffer;
            } else {
                return -1000 + buffer;
            }
        } else {
            return normalized;
        }
    }