Android 實現自定義相機

摘要: 基本上所有應用都會用到相機功能,上周嘗試了下自定義的相機功能實現。下面記錄下在學習嘗試中的一些心得。

相機的啟動方式有兩種:
1、利用隱式跳轉跳轉到系統的相機應用

         Intent intent = new Intent();  
         intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);  
         startActivity(intent);

2、利用camera類自定義相機界面
自定義相機的一般步驟:
1. 創建顯示相機畫面的布局，Android已經為我們選定好SurfaceView
2. 通過SurfaceView#getHolder()獲得鏈接Camera和SurfaceView的SurfaceHolder
3. Camame.open()打開相機
4. 通過SurfaceHolder鏈接Camera和SurfaceView實現預覽
5. 進行拍照或錄制

3、代碼演示

private void init() {
        TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.MovieRecorderView, defStyle, 0);
        mWidth = a.getInteger(R.styleable.MovieRecorderView_width, 320);// 默認320
        mHeight = a.getInteger(R.styleable.MovieRecorderView_height, 240);// 默認240

        isOpenCamera = a.getBoolean(
                R.styleable.MovieRecorderView_is_open_camera, true);// 默認打開
        mSurfaceView = (SurfaceView) findViewById(R.id.surfaceview);
        mSurfaceHolder = mSurfaceView.getHolder();
        mSurfaceHolder.addCallback(new CustomCallBack());
        mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}

    private class CustomCallBack implements Callback {

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            if (!isOpenCamera)
                return;
            try {
                initCamera();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height) {

        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            if (!isOpenCamera)
                return;
            freeCameraResource();
        }

    }

    /**
     * 初始化攝像頭同時開啟預覽
     */
    private void initCamera() throws IOException {
        if (mCamera != null) {
            freeCameraResource();
        }
        try {
            mCamera = Camera.open();
        } catch (Exception e) {
            e.printStackTrace();
            freeCameraResource();
        }
        if (mCamera == null)
            return;

//      setCameraParams();
        mCamera.setDisplayOrientation(90);
        mCamera.setPreviewDisplay(mSurfaceHolder);
        
        DisplayMetrics dm = new DisplayMetrics();    
        dm = getResources().getDisplayMetrics();  
        setCameraParams(mCamera,dm.widthPixels,dm.heightPixels);
        
        mCamera.startPreview();
        mCamera.unlock();
    }

    /**
     * 釋放攝像頭資源
     */
    private void freeCameraResource() {
        if (mCamera != null) {
            mCamera.setPreviewCallback(null);
            mCamera.stopPreview();
//          mCamera.lock();
            mCamera.release();
            mCamera = null;
            isOpenCamera = false;
        }
    }

    /**
     * 釋放資源
     */
    private void releaseRecord() {
        if (mMediaRecorder != null) {
            mMediaRecorder.setOnErrorListener(null);
            try {
                mMediaRecorder.release();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        mMediaRecorder = null;
    }

接下來時設置照片尺寸放置預覽時的圖像變形

    private void setCameraParams(Camera camera, int width, int height) {
        Log.i(TAG,"setCameraParams  width="+width+"  height="+height);
        Camera.Parameters parameters = mCamera.getParameters();
        // 獲取攝像頭支持的PictureSize列表
        List<Camera.Size> pictureSizeList = parameters.getSupportedPictureSizes();
//        for (Camera.Size size : pictureSizeList) {
//            Log.i(TAG, "pictureSizeList size.width=" + size.width + "  size.height=" + size.height);
//        }
        /**從列表中選取合適的分辨率*/
        Camera.Size picSize = getProperSize(pictureSizeList, ((float) height / width));
        if (null == picSize) {
            Log.i(TAG, "null == picSize");
            picSize = parameters.getPictureSize();
        }
        Log.i(TAG, "picSize.width=" + picSize.width + "  picSize.height=" + picSize.height);
         // 根據選出的PictureSize重新設置SurfaceView大小
        float w = picSize.width;
        float h = picSize.height;
        parameters.setPictureSize(picSize.width,picSize.height);
        this.setLayoutParams(new RelativeLayout.LayoutParams((int) (height*(h/w)), height));

        // 獲取攝像頭支持的PreviewSize列表
        List<Camera.Size> previewSizeList = parameters.getSupportedPreviewSizes();
        Camera.Size preSize = getProperSize(previewSizeList, ((float) height) / width);
        if (null != preSize) {
            Log.i(TAG, "preSize.width=" + preSize.width + "  preSize.height=" + preSize.height);
            parameters.setPreviewSize(preSize.width, preSize.height);
        }

        parameters.setJpegQuality(100); // 設置照片質量
        if (parameters.getSupportedFocusModes().contains(android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            parameters.setFocusMode(android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);// 連續對焦模式
        }

        parameters.set("orientation", "portrait");
        mCamera.cancelAutoFocus();//自動對焦。
        mCamera.setDisplayOrientation(90);// 設置PreviewDisplay的方向，效果就是將捕獲的畫面旋轉多少度顯示
        mCamera.setParameters(parameters);

    }

    /**
     * 從列表中選取合適的分辨率
     * 默認w:h = 4:3
     * <p>注意：這里的w對應屏幕的height
     *            h對應屏幕的width<p/>
     */
    private Camera.Size getProperSize(List<Camera.Size> pictureSizeList, float screenRatio) {
        Log.i(TAG, "screenRatio=" + screenRatio);
        Camera.Size result = null;
        for (Camera.Size size : pictureSizeList) {
            float currentRatio = ((float) size.width) / size.height;
            if (currentRatio - screenRatio == 0) {
                result = size;
                break;
            }
        }

        if (null == result) {
            for (Camera.Size size : pictureSizeList) {
                float curRatio = ((float) size.width) / size.height;
                if (curRatio == 4f / 3) {// 默認w:h = 4:3
                    result = size;
                    break;
                }
            }
        }

        return result;
    }

在完成預覽設置之后可以根據需求進行拍照或者拍攝的操作:
--首先時拍照操作:
拍照時我們需要設置三個回調函數

    // 拍照瞬間調用
    private Camera.ShutterCallback shutter = new Camera.ShutterCallback() {
        @Override
        public void onShutter() {

        }
    };

    // 獲得沒有壓縮過的圖片數據
    private Camera.PictureCallback raw = new Camera.PictureCallback() {

        @Override
        public void onPictureTaken(byte[] data, Camera Camera) {

        }
    };

    //圖像數據處理完成后的回調函數
    private Camera.PictureCallback jpeg = new Camera.PictureCallback() {

        @Override
        public void onPictureTaken(byte[] data, Camera Camera) {
            BufferedOutputStream bos = null;
            Bitmap bm = null;
            try {
                // 獲得圖片
                bm = BitmapFactory.decodeByteArray(data, 0, data.length);
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    Log.i(TAG, "Environment.getExternalStorageDirectory()="+Environment.getExternalStorageDirectory());
                    File file = new File(Environment.getExternalStorageDirectory()
                            + File.separator + "ysb/image/"+System.currentTimeMillis()+".jpg");//拍攝照片的保存地址
//                    String filePath = "/sdcard/dyk"+System.currentTimeMillis()+".jpg";//照片保存路徑
//                    File file = new File(filePath);
                    if (!file.exists()){
                        file.mkdirs();
                    }
                    bos = new BufferedOutputStream(new FileOutputStream(file));
                    bm.compress(Bitmap.CompressFormat.JPEG, 100, bos);//將圖片壓縮到流中

                }else{
                    Toast.makeText(getContext(),"沒有檢測到內存卡", Toast.LENGTH_SHORT).show();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bos.flush();//輸出
                    bos.close();//關閉
                    bm.recycle();// 回收bitmap空間
                    mCamera.stopPreview();// 關閉預覽
                    mCamera.startPreview();// 開啟預覽
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    };

然后調用camera.takePicture方法實現拍照

    /**
     * 拍照方法
     * @param onRecordFinishListener  拍照完成后的回調接口
     */
    public void takePicture(OnRecordFinishListener onRecordFinishListener) {
        this.mOnRecordFinishListener = onRecordFinishListener;
        pause();
            try {
                if (!isOpenCamera)
                initCamera();
                Log.e(TAG, ""+mCamera);
                this.mCamera.autoFocus(new AutoFocusCallback() {
                    @Override
                    public void onAutoFocus(boolean flag, Camera camera) {
                        camera.takePicture(shutter, raw, jpeg);
                    }
                });
//              mCamera.takePicture(null, null, jpeg);
                if (mOnRecordFinishListener != null) 
                    mOnRecordFinishListener.onRecordFinish();
            } catch (IOException e) {
                e.printStackTrace();
            }
        
        
    }

--或者進行拍攝操作
在拍照之前我們需要先初始化MediaRecorder:

    /**
     * 初始化
     * @throws IOException
     */
    @SuppressLint("NewApi")
    private void initRecord() throws IOException {
        mMediaRecorder = new MediaRecorder();
        mMediaRecorder.reset();
        if (mCamera != null)
            mMediaRecorder.setCamera(mCamera);
        mMediaRecorder.setOnErrorListener(this);
        mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
        mMediaRecorder.setVideoSource(VideoSource.CAMERA);// 視頻源
        mMediaRecorder.setAudioSource(AudioSource.MIC);// 音頻源
        mMediaRecorder.setOutputFormat(OutputFormat.MPEG_4);// 視頻輸出格式
        mMediaRecorder.setAudioEncoder(AudioEncoder.AMR_NB);// 音頻格式
        mMediaRecorder.setVideoSize(mWidth, mHeight);// 設置分辨率：
        // mMediaRecorder.setVideoFrameRate(16);// 這個我把它去掉了，感覺沒什么用
        mMediaRecorder.setVideoEncodingBitRate(1 * 1024 * 1024 * 100);// 設置幀頻率，然后就清晰了
        mMediaRecorder.setOrientationHint(90);// 輸出旋轉90度，保持豎屏錄制
        mMediaRecorder.setVideoEncoder(VideoEncoder.MPEG_4_SP);// 視頻錄制格式
        // mediaRecorder.setMaxDuration(Constant.MAXVEDIOTIME * 1000);
        mMediaRecorder.setOutputFile(mVecordFile.getAbsolutePath());
        mMediaRecorder.prepare();
        try {
            mMediaRecorder.start();//開始錄制
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (RuntimeException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

這里的錄制是限制了事件的長按錄制

    /**
     * 開始錄制視頻
     * @param fileName
     *            視頻儲存位置
     * @param onRecordFinishListener
     *            達到指定時間之后回調接口
     */
    public void record(final OnRecordFinishListener onRecordFinishListener) {
        this.mOnRecordFinishListener = onRecordFinishListener;
        createRecordDir();
        try {
            if (!isOpenCamera)// 如果未打開攝像頭，則打開
                initCamera();
            mTimeCount = 0;// 時間計數器重新賦值
            initRecord();
            mTimer = new Timer();
            mTimer.schedule(new TimerTask() {

                @Override
                public void run() {
                    mTimeCount++;
                        mProgressBar.setProgress(mTimeCount);// 設置進度條
                        if ((mTimeCount-1) == mRecordMaxTime) {// 達到指定時間，停止拍攝
                            stop();
                            if (mOnRecordFinishListener != null)
                                mOnRecordFinishListener.onRecordFinish();
                        }
                    }
                    
//              }
            }, 0, 1000);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

在拍攝完成后要記住關閉攝像頭釋放資源

    /**
     * 停止拍攝
     */
    public void stop() {
        stopRecord();
        releaseRecord();
        freeCameraResource();
    }

    /**
     * 停止錄制
     */
    public void stopRecord() {
        mProgressBar.setProgress(0);
        if (mTimer != null)
            mTimer.cancel();
        if (mMediaRecorder != null) {
            // 設置后不會崩
            mMediaRecorder.setOnErrorListener(null);
            mMediaRecorder.setPreviewDisplay(null);
            try {
                mMediaRecorder.stop();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (RuntimeException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 釋放資源
     */
    private void releaseRecord() {
        if (mMediaRecorder != null) {
            mMediaRecorder.setOnErrorListener(null);
            try {
                mMediaRecorder.release();
            } catch (IllegalStateException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        mMediaRecorder = null;
    }

    /**
     * 釋放攝像頭資源
     */
    private void freeCameraResource() {
        if (mCamera != null) {
            mCamera.setPreviewCallback(null);
            mCamera.stopPreview();
//          mCamera.lock();
            mCamera.release();
            mCamera = null;
            isOpenCamera = false;
        }
    }

最后要記得添加權限

<uses-permission android:name="android.permission.CAMERA" /><!-- 調用相機權限 -->
<uses-feature android:name="android.hardware.camera.autofocus" /><!-- 自動聚焦權限 -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /><!-- SD卡寫權限 -->

總結
Android自定義相機實現的主要問題在于實現預覽時圖像會旋轉不同的方向,我們需要根據不同的手機方向設置預覽圖像旋轉角度。
這里因為設置不可旋轉,所以只需要設置

mCamera.setDisplayOrientation(90);
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容