[Android] 實現簡單的相機程序

好久沒寫了，有些東西做過都快忘了，趕緊記一下。

現在來實現一個簡單的相機程序。

 原文地址http://www.cnblogs.com/rossoneri/p/4246134.html

當然需要的話可以直接調用系統的camera程序，但自己實現會使用更自由。

吶，既然要用實現相機，那就需要先了解一下調用camera的類android.hardware.camera

android.hardware.Camera

The Camera class is used to set image capture settings, start/stop preview, snap pictures, and retrieve frames for encoding for video. This class is a client for the Camera service, which manages the actual camera hardware.

To access the device camera, you must declare the android.Manifest.permission.CAMERA permission in your Android Manifest. Also be sure to include the <uses-feature> manifest element to declare camera features used by your application. For example, if you use the camera and auto-focus feature, your Manifest should include the following:

 <uses-permission android:name="android.permission.CAMERA" />
 <uses-feature android:name="android.hardware.camera" />
 <uses-feature android:name="android.hardware.camera.autofocus" />
To take pictures with this class, use the following steps:

Obtain an instance of Camera from open(int).
Get existing (default) settings with getParameters().
If necessary, modify the returned Camera.Parameters object and call setParameters(Camera.Parameters).
If desired, call setDisplayOrientation(int).
Important: Pass a fully initialized SurfaceHolder to setPreviewDisplay(SurfaceHolder). Without a surface, the camera will be unable to start the preview.
Important: Call startPreview() to start updating the preview surface. Preview must be started before you can take a picture.
When you want, call takePicture(Camera.ShutterCallback, Camera.PictureCallback, Camera.PictureCallback, Camera.PictureCallback) to capture a photo. Wait for the callbacks to provide the actual image data.
After taking a picture, preview display will have stopped. To take more photos, call startPreview() again first.
Call stopPreview() to stop updating the preview surface.
Important: Call release() to release the camera for use by other applications. Applications should release the camera immediately in android.app.Activity.onPause() (and re-open() it in android.app.Activity.onResume()).
To quickly switch to video recording mode, use these steps:

Obtain and initialize a Camera and start preview as described above.
Call unlock() to allow the media process to access the camera.
Pass the camera to android.media.MediaRecorder.setCamera(Camera). See android.media.MediaRecorder information about video recording.
When finished recording, call reconnect() to re-acquire and re-lock the camera.
If desired, restart preview and take more photos or videos.
Call stopPreview() and release() as described above.
This class is not thread-safe, and is meant for use from one event thread. Most long-running operations (preview, focus, photo capture, etc) happen asynchronously and invoke callbacks as necessary. Callbacks will be invoked on the event thread open(int) was called from. This class's methods must never be called from multiple threads at once.

Caution: Different Android-powered devices may have different hardware specifications, such as megapixel ratings and auto-focus capabilities. In order for your application to be compatible with more devices, you should not make assumptions about the device camera specifications.

另外補充一下，實現android的video也是使用的Camera API，用到相關的類為Camera，SurfaceView，MediaRecorder，Intent(MediaStore.ACTION_IMAGE_CAPTURE, MediaStore.ACTION_VEDIO_CAPTURE)

 

好，根據camera的說明，在開始編寫程序之前需要確認manifest中添加關於使用攝像設備的適當的權限聲明，如果使用camera API必須加上下段說明：

<uses-permission android:name="android.permission.CAMERA" />

當然，程序也需要聲明使用camera的特性：

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

我就不翻譯了，應該不難懂
<uses-feature android:name="android.hardware.camera" />
The application uses the device's camera. If the device supports multiple cameras, the application uses the camera that facing away from the screen.

<uses-feature android:name="android.hardware.camera.autofocus" />
Subfeature. The application uses the device camera's autofocus capability.

<uses-feature android:name="android.hardware.camera.flash" />
Subfeature. The application uses the device camera's flash.

<uses-feature android:name="android.hardware.camera.front" />
Subfeature. The application uses a front-facing camera on the device.

<uses-feature android:name="android.hardware.camera.any" />
The application uses at least one camera facing in any direction, or an external camera device if one is connected. Use this in preference to android.hardware.camera if a back-facing camera is not required.

如果需要其他特性，在列表里選擇性添加就好，比如一會兒我還需要自動對焦就要添加相關代碼到manifest。添加特性代碼就是為了防止你的程序被安裝到沒有攝像頭或者不支持你要的功能的設備上去(prevent your application from being installed to devices that do not include a camera or do not support the camera features you specify. )

如果你的程序能通過適當的操作使用camera或一些特性，但並不特別需要它，可以增加required屬性為false：

<uses-feature android:name="android.hardware.camera" android:required="false" />

 

Ok，前面說的有點多，下面說下使用camera的流程：

• 整體流程

1. 檢測camera的存在並訪問camera
2. 繼承SurfaceView並添加SurfaceHolder接口以顯示預覽畫面
3. 為預覽畫面添加你需要的布局和控件
4. 增加對拍照事件的監聽
5. 使用拍照功能並保存照片
6. 最后要釋放camera

• 流程細節

1. 通過open(int)方法獲取camera的實例，int為camera的id
2. 使用getParameters()獲取相機當前的設置，包括預覽尺寸，拍照尺寸等等參數
3. 如果修改了相關設置，調用setParameters(Camera.Parameters)將更改的信息重新生效
4. 有需要的話使用setDisplayOrientation(int)來改變預覽畫面的方向
5. 使用setPreviewDisplay(SurfaceHolder)傳遞一個完整初始化的SurfaceHolder，沒有surface，就沒法啟動預覽畫面
6. 在拍照之前先調用startPreview()來更新預覽畫面
7. 調用takePicture(Camera.ShutterCallback, Camera.PictureCallback, Camera.PictureCallback, Camera.PictureCallback)進行拍照，在回調函數中獲得照片對象並做處理
8. 預覽畫面會在拍照后關閉，如果還需要拍照，記得先startPreview()
9. 用stopPreview()來關閉預覽畫面
10. camera使用之后一定要調用release()釋放掉

 

下面跟着流程，開始編碼

先在主界面添加一個按鈕，用來打開相機，效果如下：

<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"
    tools:context="com.example.demo_camera.MainActivity" >

    <Button
        android:id="@+id/main_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/main_btn_open_camera" />

    <include
        android:id="@+id/camera_layout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        layout="@layout/view_camera"
        android:visibility="gone" />

</RelativeLayout>

 

設計拍照界面，一個surfaceview用來顯示預覽畫面，兩個button進行拍照和返回

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/camera_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <SurfaceView
        android:id="@+id/cameraSurfaceView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center" />

    <RelativeLayout
        android:id="@+id/cameraButtonLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@android:color/transparent"
        android:orientation="horizontal" >

        <Button
            android:id="@+id/cameraTakePicCancle"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_alignParentEnd="true"
            android:layout_alignParentRight="true"
            android:background="@color/RoyalBlue"
            android:text="@string/camera_btn_back" />

        <Button
            android:id="@+id/cameraTakePic"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_marginEnd="10dp"
            android:layout_marginRight="10dp"
            android:layout_toLeftOf="@id/cameraTakePicCancle"
            android:layout_toStartOf="@id/cameraTakePicCancle"
            android:background="@color/RoyalBlue"
            android:text="@string/camera_btn_takephoto" />
    </RelativeLayout>

</FrameLayout>

 

編寫camera操作的代碼，增加了自動對焦，分辨前后攝像頭等內容，為了代碼看起來連貫，具體說明放在注釋里

package com.example.demo_camera;

import java.util.List;

import android.app.Activity;
import android.graphics.PixelFormat;
import android.hardware.Camera;
import android.hardware.Camera.AutoFocusCallback;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.Size;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class CameraView {
    // Private Constants ///////////////////////////////////////////////////////

    // Public Variables ////////////////////////////////////////////////////////

    // Member Variables ////////////////////////////////////////////////////////
    private ViewGroup            mView;
    private Activity            mActivity;

    private Button                mBtnTakePhoto;
    private Button                mBtnBack;
    private SurfaceView            mSurfaceView;

    private Camera                mCamera;
    private Camera.Parameters    mParameters;
    private CameraInfo            mCameraInfo;

    private int                    mDegree;
    private int                    mScreenWidth;
    private int                    mScreenHeight;

    // Constructors ////////////////////////////////////////////////////////////
    public CameraView(Activity mActivity, ViewGroup mView) {
        this.mActivity = mActivity;
        this.mView = mView;
        initCameraView();
        initCameraEvent();
    }

    // Class Methods ///////////////////////////////////////////////////////////

    // Private Methods /////////////////////////////////////////////////////////
    private void initCameraView() {
        mBtnTakePhoto = (Button) mView.findViewById(R.id.cameraTakePic);
        mBtnBack = (Button) mView.findViewById(R.id.cameraTakePicCancle);
        mSurfaceView = (SurfaceView) mView.findViewById(R.id.cameraSurfaceView);

    }

    private void initCameraEvent() {

        mSurfaceView.getHolder().setKeepScreenOn(true);// 屏幕常亮
        mSurfaceView.getHolder().addCallback(new SurfaceCallback());// 為surfaceHolder添加回調
        mSurfaceView.getHolder().setFormat(PixelFormat.TRANSPARENT);

        mBtnTakePhoto.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                // if (mCamera != null) {
            }
        });

        mBtnBack.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

            }
        });
    }

    private final class SurfaceCallback implements SurfaceHolder.Callback { // 回調中包含三個重寫方法，看方法名即可知道是干什么的

        @Override
        public void surfaceCreated(SurfaceHolder holder) { // 創建預覽畫面處理
            // TODO Auto-generated method stub
            int nNum = Camera.getNumberOfCameras(); // 根據攝像頭的id找前后攝像頭
            if (nNum == 0) {
                // 沒有攝像頭
                return;
            }

            for (int i = 0; i < nNum; i++) {
                CameraInfo info = new CameraInfo(); // camera information 對象
                Camera.getCameraInfo(i, info);// 獲取information
                if (info.facing == CameraInfo.CAMERA_FACING_BACK) { // 后攝像頭
                    startPreview(info, i, holder); // 設置preview的顯示屬性
                    return;
                }
            }

        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height) { // 預覽畫面有變化時進行如下處理
            // TODO Auto-generated method stub
            if (mCamera == null) {
                return;
            }

            mCamera.autoFocus(new AutoFocusCallback() { // 增加自動對焦
                @Override
                public void onAutoFocus(boolean success, Camera camera) {
                    // TODO Auto-generated method stub
                    if (success) { // 如果自動對焦成功
                        mCamera.cancelAutoFocus(); // 關閉自動對焦，下次有變化時再重新打開自動對焦,這句不能少
                    }
                }
            });
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) { // surfaceView關閉處理以下方法
            // TODO Auto-generated method stub
            if (mCamera != null) {
                mCamera.stopPreview();
                mCamera.release(); // 釋放照相機 不能少
                mCamera = null;
                mCameraInfo = null;
            }
        }

    }

    private Size getOptimalSize(int nDisplayWidth, int nDisplayHeight,
            List<Size> sizes, double targetRatio) { // 這里是我的一個計算顯示尺寸的方法，可以自己去設計
        final double ASPECT_TOLERANCE = 0.001;
        if (sizes == null)
            return null;

        Size optimalSize = null;
        double minDiff = Double.MAX_VALUE;

        int targetHeight = Math.min(nDisplayWidth, nDisplayHeight);
        for (Size size : sizes) {
            double ratio = (double) size.width / size.height;
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
                continue;
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }
        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }
        return optimalSize;
    }

    // Public Methods //////////////////////////////////////////////////////////
    public void show() {
        mView.setVisibility(View.VISIBLE);
        mSurfaceView.setVisibility(View.VISIBLE); //
    }

    public void hideCamera() {
        mView.setVisibility(View.GONE);
        mSurfaceView.setVisibility(View.GONE); //
    }

    public final ViewGroup getViewGroup() {
        return mView;
    }

    public void initScreenSize(int nWidth, int nHeight) { // 設置屏幕的寬與高
        ViewGroup.LayoutParams lp = mSurfaceView.getLayoutParams();
        lp.width = nWidth;
        lp.height = nHeight;
        mSurfaceView.setLayoutParams(lp);

        mScreenWidth = nWidth;
        mScreenHeight = nHeight;
    }

    public void startPreview(CameraInfo info, int cameraId, SurfaceHolder holder) {// 在回調中調用設置預覽的屬性
        try {

            mCameraInfo = info;

            mCamera = Camera.open(cameraId);

            mCamera.setPreviewDisplay(holder); // 設置用於顯示拍照影像的SurfaceHolder對象
            mCamera.setDisplayOrientation(90); // 設置顯示的方向，這里手機是豎直為正向90度，可以自己寫個方法來根據屏幕旋轉情況獲取到相應的角度

            {
                mParameters = mCamera.getParameters();

                // PictureSize 獲取支持顯示的尺寸 因為支持的顯示尺寸是和設備有關，所以需要獲取設備支持的尺寸列表
                // 另外因為是預覽畫面是全屏顯示，所以顯示效果也和屏幕的分辨率也有關系，為了最好的適應屏幕，建議選取
                // 與屏幕最接近的寬高比的尺寸
                List<Size> listPictureSizes = mParameters
                        .getSupportedPictureSizes();

                Size sizeOptimalPicture = getOptimalSize(mScreenWidth,
                        mScreenHeight, listPictureSizes, (double) mScreenWidth
                                / mScreenHeight);
                mParameters.setPictureSize(sizeOptimalPicture.width,
                        sizeOptimalPicture.height);

                // PreviewSize
                List<Camera.Size> ListPreviewSizes = mParameters
                        .getSupportedPreviewSizes();

                Size sizeOptimalPreview = getOptimalSize(
                        sizeOptimalPicture.width, sizeOptimalPicture.height,
                        ListPreviewSizes, (double) sizeOptimalPicture.width
                                / sizeOptimalPicture.height);
                mParameters.setPreviewSize(sizeOptimalPreview.width,
                        sizeOptimalPreview.height);

                // 這里就是有的設備不支持Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE連續自動對焦這個字段，所以做個判斷
                List<String> lstFocusModels = mParameters
                        .getSupportedFocusModes();
                for (String str : lstFocusModels) {
                    if (str.equals(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
                        mParameters
                                .setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
                        break;
                    }
                }

                mCamera.setParameters(mParameters);
            }

            mCamera.startPreview(); // 開始預覽

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

在MainActivity中添加下面主要代碼

package com.example.demo_camera;

import android.app.Activity;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.Button;

public class MainActivity extends Activity {

    Button        mBtnCamera;
    ViewGroup    mVgCamera;
    CameraView    mCameraView;

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

        // 全屏顯示要隱藏標題欄狀態欄
        // hide title bar
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // hide status bar
        int flag = WindowManager.LayoutParams.FLAG_FULLSCREEN;
        Window window = this.getWindow();
        window.setFlags(flag, flag);

        setContentView(R.layout.activity_main);

        mBtnCamera = (Button) findViewById(R.id.main_btn);
        mVgCamera = (ViewGroup) findViewById(R.id.camera_layout);
        mCameraView = new CameraView(this, mVgCamera);

        mBtnCamera.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                mBtnCamera.setVisibility(View.GONE);
                mVgCamera.setVisibility(View.VISIBLE);

                setCameraSize();

            }
        });
    }

    private void setCameraSize() {

        ViewGroup.LayoutParams params = mCameraView.getViewGroup()
                .getLayoutParams();
        DisplayMetrics dm = new DisplayMetrics();
        this.getWindowManager().getDefaultDisplay().getMetrics(dm);// 獲得屏幕尺寸
        params.width = dm.widthPixels;
        params.height = dm.heightPixels;

        mCameraView.getViewGroup().setLayoutParams(params);
        mCameraView.initScreenSize(params.width, params.height);
        mCameraView.show();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

 

在Manifest加入：

<uses-permission android:name="android.permission.CAMERA" />

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

 

最后一些資源文件string和color

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name">Demo_camera</string>
    <string name="hello_world">Hello world!</string>
    <string name="action_settings">Settings</string>
    <string name="camera_btn_back">Back</string>
    <string name="camera_btn_takephoto">TakePic</string>
    <string name="main_btn_open_camera">Open Camera</string>

    <color name="RoyalBlue">#4169E1</color>
</resources>

 

經過以上步驟，我們的設備就可以用攝像頭進行預覽了，預覽時隨意移動設備還可以自動對焦，效果如下圖：

 

不過，這個是用DDMS截的圖，如果是拍照，實際畫面尺寸會與看到的稍有差別，原因在代碼里也有寫。

關於拍照takePicture(Camera.ShutterCallback, Camera.PictureCallback, Camera.PictureCallback, Camera.PictureCallback)的使用也很簡單，在回調PictureCallback中重寫public void onPictureTaken(byte[] data, Camera camera) {}方法，data就是圖片數據，用bitmapfactory來decode一下，再處理一下顯示的旋轉方向與尺寸就ok了，這部分代碼有空再補吧。

好了，又復習一遍這個過程發現還是蠻簡單的。多看看官方的文檔就好。ok，收工睡覺。

 

參考資料：

如何實現android手機攝像頭的的自動對焦

android sdk docs

 

 

---

Feb.2nd

快放假了，年底略忙，項目需要年前趕個版本出來。

把上次的拍照過程補一下：

主要是拍照的回調方法，也就對拍照得到的數據按自己的需求處理一下，簡單地decode成Bitmap就可以，然后加你想要的動畫，另外加一些濾鏡啊什么的效果，也就是一些數字圖像處理算法，這個不在拍照范疇之內。下面的方法我僅僅對照片方向做了處理，然后縮放0.8倍在主界面顯示（懶得再寫個view放照片了，就用imageview顯示，為了有點差別就縮小圖片了

    private final class MyPictureCallback implements PictureCallback {

        @Override
        public void onPictureTaken(byte[] data, Camera camera) {
            // TODO Auto-generated method stub

            try {

                Bitmap bitmapRotate = BitmapFactory.decodeByteArray(data, 0, data.length);

                Bitmap mBmp = bitmapRotate;
                int nDegree = getPictureDegree(mActivity, mCameraInfo);
                if (nDegree != 0) {
                    Matrix matrix = new Matrix();
                    matrix.preRotate(nDegree);
                    mBmp = Bitmap.createBitmap(bitmapRotate, 0, 0, bitmapRotate.getWidth(), bitmapRotate.getHeight(), matrix, true);
                }


                Bitmap bmpScale = Bitmap.createScaledBitmap(mBmp, (int) (mScreenWidth * 0.8), (int) (mScreenHeight * 0.8), true);

                if (mListener != null)
                    mListener.onTakePic(bmpScale);
                closeCamera();

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

寫好回調后在takePhoto按鈕事件下補充：

if (mCamera != null) 
      mCamera.takePicture(null, null, new MyPictureCallback());

在back按鈕下補充：

takePicCancle();

cameraView最后補充代碼:

　　public void closeCamera() {
        if (mCamera != null) {
            mCamera.stopPreview();
            mCamera.release(); // 釋放照相機
            mCamera = null;
            mCameraInfo = null;
        }
    }

    public void takePicCancle() {
        closeCamera();
        // sigCameraCancle.emit();
        if (mListener != null)
            mListener.onBack();
    }

為了讓mainActivity能得到在camera里的按鈕事件反饋，在cameraView中加兩個接口：

public interface CameraViewListener {
    public void onTakePic(Bitmap bmp);
    public void onBack();
}

private CameraViewListener    mListener;

public void setListener(CameraViewListener listener) {
    mListener = listener;
}

然后在MainActivity添加以下代碼：

implements CameraViewListener

implements CameraViewListener

mCameraView.setListener(this);

@Override
public void onTakePic(Bitmap bmp) {
    // TODO Auto-generated method stub
    mVgCamera.setVisibility(View.GONE);
    mPhoto.setVisibility(View.VISIBLE);
    mPhoto.setImageBitmap(bmp);
}

@Override
public void onBack() {
    // TODO Auto-generated method stub
    mBtnCamera.setVisibility(View.VISIBLE);

    mVgCamera.setVisibility(View.GONE);
}

 

mPhoto是一個ImageView

<ImageView
    android:id="@+id/main_photo"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerHorizontal="true"
    android:layout_centerVertical="true"
    android:visibility="gone" />

 

以上，按下拍照即可在主界面看到拍照得到的畫面：

 

 如果還需要完整代碼請持續關注，我有空把Github整理好了會發出github的地址～～