通常情況下，呼叫android系統相機基本上可以滿足拍照的需求，而自定義相機的需求一般來自於開發自己的相機應用，今天我們來簡單聊聊android自定義相機的實現，限於篇幅，我們上篇只討論android.hardware.Camera，下篇我會和大家一起討論一下android.hardware.Camera2

1. 基礎介紹

首先簡單看一下用到的類有哪些：

類名	介紹	註釋
android 5.0 之前控制相機硬體是通過這個Camera類實現的	deprecated in API level 21.
控制相機的引數，如對焦，閃光燈等	deprecated in API level 21.
專注於繪製應用層內嵌浮層的類，這裡我們用它來預覽鏡頭的取景	\
持有一個展示的surface的抽象介面。允許你控制surface的尺寸和格式，編輯surface中的畫素和監聽surface的改變。	\

2. demo實現

1. 新增許可權
2. 簡單佈局
3. 開啟相機
4. 設定預覽
5. 拍照及儲存
6. 釋放資源

新增許可權

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name
 
="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus" />

在camera的官方介面文件中，給出了控制camera的10個步驟，很詳細，我們這邊側重於實現。

簡單佈局

一個簡單的介面，一個拍照鍵Button，一個FrameLayout用於填充Surface

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
 

    android:id="@+id/camera_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".Camera.CameraActivity">

    <FrameLayout
        android:id="@+id/camera_preview"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"/>

    <LinearLayout
        android:id="@+id/control"
        android:layout_width="match_parent"
        android:layout_height="112dp"
        android:layout_alignParentBottom="true"
        android:background="@color/control_background"
        android:gravity="center"
        android:orientation="horizontal">

            <Button
                android:id="@+id/camera_take_photo"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:text="@string/picture" />
    </LinearLayout>
</RelativeLayout>

**開啟相機**

這裡包括了檢測系統相機狀態，指定開啟具體的相機裝置，處理異常等

/**
* 初始化相機
*/
private void initCamera() {
   if(!getPackageManager().hasSystemFeature(
       PackageManager.FEATURE_CAMERA)) {
     //TODO 未檢測到系統的相機
} else {
     //獲取cameraId ，在api8及以前，直接呼叫Camera.open()方法會開啟後置攝像頭
     //獲取系統後置攝像頭的id（工具方法，後面附程式碼）
     int cameraId = CameraUtil.findBackFacingCamera();
     if (!CameraUtil.isCameraIdValid(cameraId)) {
          //TODO 檢測camera id無效
     } else {
         //是否可以安全開啟相機
         if (safeCameraOpen(cameraId)) {
           mCamera.startPreview();  //開啟相機預覽
           mPreview.setCamera(mCamera);
         } else {             
             //TODO 無法安全開啟相機    
         }
     }
 }

//開啟相機的操作延遲到onResume()方法裡面去執行，這樣可以使得程式碼更容易重用，還能保持控制流程更為簡單。當然也可以另起執行緒處理
@Override
public void onResume() {
    super.onResume();
    initCamera();
}

附上獲取相機id的工具方法：

public final class CameraUtil {

    public static final int INVALID_CAMERA_ID = -1;

    /**
     * 獲取前置攝像頭id
     * @return
     */
    public static int findFrontFacingCamera() {
        int cameraId = INVALID_CAMERA_ID;
        // Search for the front facing camera
        int numberOfCameras = Camera.getNumberOfCameras();
        for (int i = 0; i < numberOfCameras; i++) {
            Camera.CameraInfo info = new Camera.CameraInfo();
            Camera.getCameraInfo(i, info);
            if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                Log.d("CameraUtil", "Camera found");
                cameraId = i;
                break;
            }
        }
        return cameraId;
    }

    /**
     * 獲取後置攝像頭id
     * @return
     */
    public static int findBackFacingCamera() {
        int cameraId = INVALID_CAMERA_ID;
        // Search for the front facing camera
        int numberOfCameras = Camera.getNumberOfCameras();
        for (int i = 0; i < numberOfCameras; i++) {
            Camera.CameraInfo info = new Camera.CameraInfo();
            Camera.getCameraInfo(i, info);
            if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                Log.d("CameraUtil", "Camera found");
                cameraId = i;
                break;
            }
        }
        return cameraId;
    }

    public static boolean isCameraIdValid(int cameraId) {
        return cameraId != INVALID_CAMERA_ID;
    }

}

處理開啟相機時可能出現的異常：

    /**
     * 獲取Camera，並加入開啟檢測
     *
     * @param id 相機id
     * @return
     */
    private boolean safeCameraOpen(int id) {
        boolean qOpened = false;
        try {
            releaseCameraAndPreview();
            mCamera = Camera.open(id);
            qOpened = (mCamera != null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return qOpened;
    }

這樣不出意外，我們成功的打開了相機 —

**設定取景的預覽**

這裡包括了設定相機引數，設定相機方向，初始化SurfaceHolder從而來setPreviewDisplay(SurfaceHolder) ，完成這一步，即可實現取景的預覽。

一般的，我們可以在佈局中放置一個預設的SurfaceView，也可以通過addView()方法將SurfaceView例項新增到指定的容器中。
這裡我們通過繼承SurfaceView，派生一個自定義的CameraPreview，同時實現SurfaceHolder.Callback介面便於我們對surface進行控制。

public class CameraPreview extends SurfaceView implements           SurfaceHolder.Callback {

    private static final String TAG = "TAG";

    /**
     * 控制相機方向
     */
    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

    static {
        ORIENTATIONS.append(Surface.ROTATION_0, 90);
        ORIENTATIONS.append(Surface.ROTATION_90, 0);
        ORIENTATIONS.append(Surface.ROTATION_180, 270);
        ORIENTATIONS.append(Surface.ROTATION_270, 180);
    }

    private SurfaceHolder mHolder;
    private Camera mCamera;

    //持有Activity引用，為了獲取螢幕方向，改成內部類會比較好
    private Activity mActivity;

    public CameraPreview(Activity activity) {
        super(activity);
        mActivity = activity;
        mHolder = getHolder();
        mHolder.addCallback(this);
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
            //API 11及以後廢棄，需要時自動配置
           mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        }
    }

    public void setCamera(Camera camera) {
        mCamera = camera;
    }

    /**
     * 重新整理相機
     */
    private void refreshCamera() {
        if (mCamera != null) {
            requestLayout();
            //獲取當前手機螢幕方向
            int rotation = mActivity.getWindowManager()
                .getDefaultDisplay().getRotation();
            //調整相機方向            
            mCamera.setDisplayOrientation(
            ORIENTATIONS.get(rotation));
            // 設定相機引數
            mCamera.setParameters(settingParameters());
        }
    }

    /**
     * 配置相機引數
     * @return
     */
    private Camera.Parameters settingParameters() {
        // 獲取相機引數
        Camera.Parameters params = mCamera.getParameters();
        List<String> focusModes = params.getSupportedFocusModes();
        //設定持續的對焦模式
        if (focusModes.contains(
        Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        }

        //設定閃光燈自動開啟
        if (focusModes.contains(Camera.Parameters.FLASH_MODE_AUTO)) {
            params.setFocusMode(Camera.Parameters.FLASH_MODE_AUTO);
        }

        return params;
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // The Surface has been created, now tell the camera where to draw the preview.
        try {
            if(mCamera != null) {
                //surface建立，設定預覽SurfaceHolder
                mCamera.setPreviewDisplay(holder);
                //開啟預覽
                mCamera.startPreview();
            }
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // empty. Take care of releasing the Camera preview in your activity.
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.

        if (mHolder.getSurface() == null) {
            // preview surface does not exist
            return;
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview();
        } catch (Exception e) {
            // ignore: tried to stop a non-existent preview
        }

        // set preview size and make any resize, rotate or
        // reformatting changes here
        refreshCamera();
        // start preview with new settings
        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

        } catch (Exception e) {
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }
    }
}

CameraPreview裡面涉及到預覽主要的邏輯，一些如對焦模式或閃光燈模式等相機引數，大家可以自己參照API文件。接下來只要在onCreate()方法裡，將我們的SurfaceView加入我們設定好的佈局容器中即可。

mPreview = new CameraPreview(this);
FrameLayout vPreview = (FrameLayout) findViewById(R.id.camera_preview);
vPreview.addView(mPreview);

實現拍照

設定按鈕的點選事件的程式碼就不貼出來了，主要說說如何拍照，以及將照片儲存在檔案中。

後面兩個回撥分別發生在原始的照片資料/壓縮的jpeg照片資料可用時，api5之後，額外提供了一個4個回撥引數的方法，大家自己看文件就好。這裡我們簡化處理，只提供最後一個回撥：

//觸發一個非同步的圖片捕獲回撥
mCamera.takePicture(null, null, this);
...
@Override
public void onPictureTaken(final byte[] data, Camera camera) {
    File pictureFile = ...; //自行建立一個file檔案用於儲存照片
    OutputStream output = null;
    try {
        output = new FileOutputStream(pictureFile);
        output.write(data);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (output != null) {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //儲存成功後的處理
    resetCamera();
}

其實很簡單，只需要將位元組資料寫進檔案裡即可，如果儲存完圖片後想繼續拍照，這時候就需要重置一下相機，因為拍照完，取景預覽預設定格在取景頁，提供一下resetCamera()方法，供大家參考

/**
* 重置相機
*/
private void resetCamera() {
   mCamera.startPreview();
   mPreview.setCamera(mCamera);
}

相機資源的釋放

/**
* 釋放相機和預覽
*/
private void releaseCameraAndPreview() {
   mPreview.setCamera(null);
   if (mCamera != null) {
       mCamera.release();
       mCamera = null;
   }
}

如果我們開啟相機是activity的onResume()方法中，那麼我們可以在onPause()方法中釋放相機和預覽資源

@Override
protected void onPause() {
   super.onPause();
   releaseCameraAndPreview();
}

補充

（1）. 一般情況下，我們無需自己實現拍照。不過有些特殊的需求還必須自己控制拍照過程。
例如，我們想獲取照片拍攝的精準時間，一般我們只能拿到照片的updateTime。即使通過解析照片檔案的方式獲取到createTime，也和照片實際的拍攝時間有誤差。原因很簡單，大家看第三步
takePicture (Camera.ShutterCallback shutter, Camera.PictureCallback raw, Camera.PictureCallback jpeg)方法的回撥，createTime實際上是位元組資料寫入file中的時刻。舉個例子，我們設定微信頭像，選擇拍照，微信會調取系統相機，這時，我們點選拍照，成功，進入系統提示是否儲存的頁面，如圖：

大家看，這時圖片還是以位元組的形式存在，只有當用戶點選儲存，系統才會儲存圖片。所以檔案的建立時間其實並不是拍照的那一刻（雖然也差不多）。所以自己控制camera拍照的話就可以拿到相對精準的照片拍攝時間。

留個坑：android中如何獲取照片（檔案）的建立時間？

目測：基於linux的android也只能拿到lastModified time

（2）. SurfaceView 生命週期的控制
還是上一個圖，例如我們拍照後進入圖中狀態，這時鎖屏或者進入後臺（觸發Activity的onPause()方法），然後我們再返回應用，此時我們會發現，SurfaceView原本固定的取景完全恢復了。首先我們想到的處理方法是設定狀態機，
定義整個拍照過程的不同狀態，如：

    /**
     * 預覽中
     */
    private static final int STATE_PREVIEW = 0;
    /**
     * 等待儲存
     */
    private static final int STATE_WAITING_SAVE = 1;
    /**
     * 儲存中
     */
    private static final int STATE_SAVING = 2;

在onResume()和onPause()方法中，針對不同的狀態，控制初始化/釋放的過程。
但是，SurfaceView預設的生命週期和activity也是相關的，所以如果希望在上述操作中保持SurfaceView的狀態，需要額外一些操作。
再留一個坑：SurfaceView生命週期與Activity的生命週期

（3）. 拍照方向
android相機感測器預設是橫向的，當豎屏拍照時，照片預設是旋轉90度的
第三個坑：照片旋轉了如何處理？