Android自定義相機自動對焦、定點對焦

在解決項目中相機某些機型無法自動對焦的問題時，在網上找到了一些資料，寫下解決問題過程，以備查看。

Android相機實時自動對焦的完美實現
Android圖像濾鏡框架GPUImage從配置到應用
GPUImage for Android

Android Camera對焦相關

---

加速度控制器

當設備移動時，認定需要對焦，然後調用CameraFocusListener 接口的onFocus()方法。

/**
 * 加速度控制器  用來控制對焦
 * @author zuo
 * @date 2018/5/9 14:34
 */
public class SensorController implements SensorEventListener {
    private SensorManager mSensorManager;
    private Sensor mSensor;
    private static SensorController mInstance;
    private CameraFocusListener mCameraFocusListener;

    public static final int STATUS_NONE = 0;
    public static final int STATUS_STATIC = 1;
    public static final int STATUS_MOVE = 2;
    private int mX, mY, mZ;
    private int STATUE = STATUS_NONE;
    boolean canFocus = false;
    boolean canFocusIn = false;
    boolean isFocusing = false;
    Calendar mCalendar;
    private final double moveIs = 1.4;
    private long lastStaticStamp = 0;
    public static final int DELAY_DURATION = 500;

    private SensorController(Context context) {
        mSensorManager = (SensorManager) context.getSystemService(Activity.SENSOR_SERVICE);
        if (mSensorManager!=null){
            mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        }
        start();
    }

    public static SensorController getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new SensorController(context);
        }
        return mInstance;
    }

    public void setCameraFocusListener(CameraFocusListener mCameraFocusListener) {
        this.mCameraFocusListener = mCameraFocusListener;
    }

    public void start() {
        restParams();
        canFocus = true;
        mSensorManager.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_NORMAL);
    }

    public void stop() {
        mSensorManager.unregisterListener(this, mSensor);
        canFocus = false;
    }


    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor == null) {
            return;
        }

        if (isFocusing) {
            restParams();
            return;
        }

        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
            int x = (int) event.values[0];
            int y = (int) event.values[1];
            int z = (int) event.values[2];
            mCalendar = Calendar.getInstance();
            long stamp = mCalendar.getTimeInMillis();
            int second = mCalendar.get(Calendar.SECOND);
            if (STATUE != STATUS_NONE) {
                int px = Math.abs(mX - x);
                int py = Math.abs(mY - y);
                int pz = Math.abs(mZ - z);
                double value = Math.sqrt(px * px + py * py + pz * pz);

                if (value > moveIs) {
                    STATUE = STATUS_MOVE;
                } else {
                    if (STATUE == STATUS_MOVE) {
                        lastStaticStamp = stamp;
                        canFocusIn = true;
                    }

                    if (canFocusIn) {
                        if (stamp - lastStaticStamp > DELAY_DURATION) {
                            //移動後靜止一段時間，可以發生對焦行爲
                            if (!isFocusing) {
                                canFocusIn = false;
//                                onCameraFocus();
                                if (mCameraFocusListener != null) {
                                    mCameraFocusListener.onFocus();
                                }
                            }
                        }
                    }

                    STATUE = STATUS_STATIC;
                }
            } else {
                lastStaticStamp = stamp;
                STATUE = STATUS_STATIC;
            }

            mX = x;
            mY = y;
            mZ = z;
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

    private void restParams() {
        STATUE = STATUS_NONE;
        canFocusIn = false;
        mX = 0;
        mY = 0;
        mZ = 0;
    }

    /**
     * 對焦是否被鎖定
     * @return
     */
    public boolean isFocusLocked() {
        return canFocus && isFocusing;
    }

    /**
     * 鎖定對焦
     */
    public void lockFocus() {
        isFocusing = true;
    }

    /**
     * 解鎖對焦
     */
    public void unlockFocus() {
        isFocusing = false;
    }

    public void restFocus() {
        isFocusing = false;
    }

    public interface CameraFocusListener {
        /**
         * 相機對焦中
         */
        void onFocus();
    }
}

---

自定義相機

1、初始化相機時，進行加速度監聽

public Camera1(Activity activity, Callback callback, PreviewImpl preview) {
        super(callback, preview);
        this.mActivity = activity;
        preview.setCallback(new PreviewImpl.Callback() {

            @Override
            public void onSurfaceChanged() {
                if (mCamera != null) {
                    setUpPreview();
                    adjustCameraParameters();
                }
            }
        });
        sensorController = SensorController.getInstance(mActivity);
        sensorController.setCameraFocusListener(new SensorController.CameraFocusListener() {
            @Override
            public void onFocus() {
                if (mCamera != null) {
                    DisplayMetrics mDisplayMetrics = mActivity.getApplicationContext().getResources()
                            .getDisplayMetrics();
                    int mScreenWidth = mDisplayMetrics.widthPixels;
                    if (!sensorController.isFocusLocked()) {
                        if (newFocus(mScreenWidth / 2, mScreenWidth / 2)) {
                            sensorController.lockFocus();
                        }
                    }
                }
            }
        });
    }
      sensorController.start();

2、自動對焦代碼

    private boolean isFocusing;

    private boolean newFocus(int x, int y) {
        //正在對焦時返回
        if (mCamera == null || isFocusing) {
            return false;
        }
        isFocusing = true;
        setMeteringRect(x, y);
        mCameraParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
        mCamera.cancelAutoFocus(); // 先要取消掉進程中所有的聚焦功能
        try {
            mCamera.setParameters(mCameraParameters);
            mCamera.autoFocus(autoFocusCallback);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

設置感光區域，將手機屏幕點擊點對應的感光矩形範圍映射到相機的感光矩形座標系

 /**
     * 設置感光區域
     * 需要將屏幕座標映射到Rect對象對應的單元格矩形
     *
     * @param x
     * @param y
     */
    private void setMeteringRect(int x, int y) {
        if (mCameraParameters.getMaxNumMeteringAreas() > 0) {
            List<Camera.Area> areas = new ArrayList<Camera.Area>();
            Rect rect = new Rect(x - 100, y - 100, x + 100, y + 100);
            int left = rect.left * 2000 / CameraUtil.screenWidth - 1000;
            int top = rect.top * 2000 / CameraUtil.screenHeight - 1000;
            int right = rect.right * 2000 / CameraUtil.screenWidth - 1000;
            int bottom = rect.bottom * 2000 / CameraUtil.screenHeight - 1000;
            // 如果超出了(-1000,1000)到(1000, 1000)的範圍，則會導致相機崩潰
            left = left < -1000 ? -1000 : left;
            top = top < -1000 ? -1000 : top;
            right = right > 1000 ? 1000 : right;
            bottom = bottom > 1000 ? 1000 : bottom;
            Rect area1 = new Rect(left, top, right, bottom);
            //只有一個感光區，直接設置權重爲1000了
            areas.add(new Camera.Area(area1, 1000));
            mCameraParameters.setMeteringAreas(areas);
        }
    }

3、自動對焦回調事件

 private Handler mHandler = new Handler();
    private final Camera.AutoFocusCallback autoFocusCallback = new Camera.AutoFocusCallback() {

        @Override
        public void onAutoFocus(boolean success, Camera camera) {
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    //一秒之後才能再次對焦
                    isFocusing = false;
                    sensorController.unlockFocus();
                }
            }, 1000);
        }
    };

4、關閉監聽事件

    /**
     * 關閉攝像頭,關掉加速度監聽
     *
     */
    @Override
    public void stop(boolean stopAll) {
        sensorController.stop();
        stopPreview(); 
        releaseCamera();
    }

測光和調焦

在某些攝像情景中，自動調焦和測光可能不能達到設計結果。從Android4.0（API Level 14）開始，你的Camera應用程序能夠提供另外的控制允許應用程序或用戶指定圖像中特定區域用於進行調焦或光線級別的設置，並且把這些值傳遞給Camera硬件用於採集圖片或視頻。

測光和調焦區域的工作與其他Camera功能非常類似，你可以通過Camera.Parameters對象中的方法來控制它們。

1、給Camera設置兩個測光區域

Camera.Area對象，包含兩個參數：
- Rect對象，它用於指定Camera預覽窗口一塊矩形區域（測光區域）
- 一個權重值（weight），它告訴Camera這塊指定區域應該給予的測光或調焦計算的重要性等級，權重大的優先級高，權重最高爲1000

//獲取相機實例
Camera.Parameters params = mCamera.getParameters();
//檢查是否支持測光區域
if (params.getMaxNumMeteringAreas() > 0){ 

   List<Camera.Area> meteringAreas = new ArrayList<Camera.Area>();
    //在圖像的中心指定一個測光區域
   Rect areaRect1 = new Rect(-100, -100, 100, 100);    
    //設置權重爲600，最高1000
   meteringAreas.add(new Camera.Area(areaRect1, 600));  
    //圖像右上方的測光區域
   Rect areaRect2 = new Rect(800, -1000, 1000, -800);   
    //設置權重爲400
   meteringAreas.add(new Camera.Area(areaRect2, 400));  
    //將測光區域設置給相機屬性
   params.setMeteringAreas(meteringAreas);
}
mCamera.setParameters(params);

Rect對象，代表了一個2000x2000的單元格矩形，它的座標對應Camera圖像的位置關係可以參考下圖，座標（-1000，-1000）代表Camera圖像的左上角，（1000,1000）代表Camera圖像的右下角。

2、感光區的計算

在上面設置感光區的setMeteringRect()方法中，爲什麼從手機屏幕座標系映射到相機的感光矩形座標系需要這樣計算？

 Rect rect = new Rect(x - 100, y - 100, x + 100, y + 100);
 int left = rect.left * 2000 / CameraUtil.screenWidth - 1000;
 int top = rect.top * 2000 / CameraUtil.screenHeight - 1000;
 int right = rect.right * 2000 / CameraUtil.screenWidth - 1000;
 int bottom = rect.bottom * 2000 / CameraUtil.screenHeight - 1000;

• 首先，我們把手機的屏幕座標和Camera的感光矩陣座標對應起來
  如圖，我用黑色線條繪製了手機的屏幕座標系，用紅色線條繪製了Camera的感光矩陣座標系，Camera的感光矩陣座標系是一個2000x2000的單元格矩形，(0,0)單元格在中心，（-1000，-1000）代表Camera圖像的左上角，（1000,1000）代表Camera圖像的右下角。
  現在，我們點擊了手機屏幕上的（x,y）這個點，並取這個點上下左右各100個單位的矩形作爲要映射到Camera感光矩陣座標系上的感光（對焦）區域，就是上面代碼中的Rect rect = new Rect(x - 100, y - 100, x + 100, y + 100);，好了，我們要開始計算了。

• 計算，將手機屏幕座標系上的矩形映射到Camera感光矩陣座標系上
  矩形Rect對象入參的定義：Rect(int left, int top, int right, int bottom)，下面我們就用rect.left、rect.top、rect.right、rect.bottom來表示該矩形在手機屏幕座標上的數據，用△left 、△top 、△right 、△bottom表示該矩形在Camera感光矩陣座標上的距離（長度），用left 、top 、right 、bottom表示該矩形在Camera感光矩陣座標上的座標，進行計算，

//1、建立等價式
rect.left / width =  △left / 2000  ，距離在兩個座標系上的長度比相同
left = △left - 1000 ，不管在第幾象限-1000之後的數據都是他的座標值

計算可得

△left = rect.left * 2000 / width 
left = △left - 1000 = rect.left * 2000 / width -1000

也就是該矩形在Camera感光矩陣座標系上的 left 數值就等於 rect.left * 2000 / width -1000 ，width 就是手機屏幕的寬度，也就是上面代碼中的 int left = rect.left * 2000 / CameraUtil.screenWidth - 1000;

同理：

 int top = rect.top * 2000 / CameraUtil.screenHeight - 1000;
 int right = rect.right * 2000 / CameraUtil.screenWidth - 1000;
 int bottom = rect.bottom * 2000 / CameraUtil.screenHeight - 1000;

好了，感光區的計算就是這樣了！