基于GLSurfaceView实现自定义Camera

Android中的Camera简介

这里主要将一些camera的一些简单用法，当然如果是用camera2的童鞋，可以参考：http://blog.csdn.net/vinicolor/article/details/50992692 。这里主要讲解：
* 如何利用camera开启相机实现预览
* 实现拍照功能，以及图片大小设定
* 切换前后置摄像头
* 闪光灯的开启
* 前置镜像
* 给拍照的图片加水印
* 自动对焦与手动对焦
* 相机的放大缩小
* 相机拍照的横竖方向的监听
好了，我们先来先看看预览的效果

在之前，我先定义了一个接口ICameraHelper，用于控制整个相机的功能：

/**
 * @CreadBy ：DramaScript
 * @date 2017/7/10
 */
public interface ICameraHelper {

    //打开相机
    boolean open(int cameraId);
    //设置相机宽高比  图片和预览大小
    void setConfig(Config config);
    //是否开启预览
    boolean preview();
    // 切换前后摄像头
    boolean switchTo(int cameraId);
    // 拍照
    void takePhoto(TakePhotoCallback callback,int nRotation);
    // 相机是否关闭
    boolean close();
    //设置预览的纹理
    void setPreviewTexture(SurfaceTexture texture);
    //获得预览大小
    Point getPreviewSize();
    //获得图片的大小
    Point getPictureSize();
    //设置预览时每一帧的回调
    void setOnPreviewFrameCallback(PreviewFrameCallback callback);

    void setFlash(int flashMode);

    class Config{
        float rate; //宽高比
        int minPreviewWidth;
        int minPictureWidth;
    }

    interface TakePhotoCallback{
        void onTakePhoto(Bitmap bitmap);
    }

    interface PreviewFrameCallback{
        void onPreviewFrame(byte[] bytes, int width, int height);
    }
}

下面我们定义CameraHelper实现ICameraHelper，然后来实现这些方法：

首先实现打开相机方法open(int cameraId)：

 @Override
    public boolean open(int cameraId) {
        mCamera = Camera.open(cameraId);
        this.cameraId = cameraId;
        if (mCamera != null) {
            Camera.Parameters param = mCamera.getParameters();
            picSize = getPropPictureSize(param.getSupportedPictureSizes(), mConfig.rate,
                    mConfig.minPictureWidth);
            preSize = getPropPreviewSize(param.getSupportedPreviewSizes(), mConfig.rate, mConfig
                    .minPreviewWidth);
            //设置照片生成的大小
            picWide = picSize.width;
            picHeight = picSize.height;
            param.setPictureSize(picWide, picHeight);
            //生成照片预览大小
            param.setPreviewSize(preSize.width, preSize.height);
            mCamera.setParameters(param);
            Camera.Size pre = param.getPreviewSize();
            Camera.Size pic = param.getPictureSize();
            mPicSize = new Point(pic.height, pic.width);
            mPreSize = new Point(pre.height, pre.width);
            Log.e("wuwang", "camera previewSize:" + mPreSize.x + "/" + mPreSize.y);

            return true;
        }
        return false;
    }

 /**
     * 获得生成照片的大小
     *
     * @param list
     * @param th
     * @param minWidth
     * @return
     */
    private Camera.Size getPropPictureSize(List<Camera.Size> list, float th, int minWidth) {
        Collections.sort(list, sizeComparator);

        int i = 0;
        for (Camera.Size s : list) {
            if ((s.height >= minWidth) && equalRate(s, th)) {
                break;
            }
            i++;
        }
        if (i == list.size()) {
            i = 0;
        }
        return list.get(i);

 /**
     * 获得预览大小
     *
     * @param list
     * @param th
     * @param minWidth
     * @return
     */
    private Camera.Size getPropPreviewSize(List<Camera.Size> list, float th, int minWidth) {
        Collections.sort(list, sizeComparator);

        int i = 0;
        for (Camera.Size s : list) {
            if ((s.height >= minWidth) && equalRate(s, th)) {
                break;
            }
            i++;
        }
        if (i == list.size()) {
            i = 0;
        }
        return list.get(i);
    }

这个方法，通过Camera.open(cameraId);来获取Camera对象，其中cameraId可以为0也可以为1，前者代表后置摄像头。然后通过Camera.Parameters来设置相机的一些参数，比如预览大小，图片生成大小，当然这里使根据手机找出了最合适的尺寸大小，可以根据自己的需求设定图片的大小，至于预览的大小，建议不要太大，容易造成机型不适配，我记得HTC的U的手机，最大支持720的。设置太大也容易消化GPU，造成手机的发烫。

接下来就是拍照方法实现：

@Override
    public void takePhoto(final TakePhotoCallback callback, final int nRotation) {
        mCamera.takePicture(null, null, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(byte[] data, Camera camera) {
                Log.e("tag", "拍照的角度：" + nRotation);
                Bitmap bm = null;
                if (nRotation==0){
                    bm = setTakePicktrueOrientation(cameraId, BitmapFactory.decodeByteArray(data, 0, data.length));
                }else {
                    bm  = BitmapFactory.decodeByteArray(data, 0, data.length);
                    if (isFrontCamera) {
                        bm = rotateBitmapByDegree(bm, 270 - nRotation, false);
                    } else {
                        bm = rotateBitmapByDegree(bm, nRotation + 90, false);
                    }
                }
                callback.onTakePhoto(bm);
            }
        });
    }

这里拍照方法，调用takePicture方法，实现Camera.PictureCallback接口，为了后面对bitmap操作，直接将byte数组转成bitmap返回。这里有一个问题，那就是拍照的图片并不是拍照时的样子，这里我们通过：

 private class AlbumOrientationEventListener extends OrientationEventListener {
        public AlbumOrientationEventListener(Context context) {
            super(context);
        }

        public AlbumOrientationEventListener(Context context, int rate) {
            super(context, rate);
        }

        @Override
        public void onOrientationChanged(int orientation) {
            if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) {
                return;
            }

            //保证只返回四个方向
            int newOrientation = ((orientation + 45) / 90 * 90) % 360;
            if (newOrientation != mOrientation) {
                mOrientation = newOrientation;
                Log.e("MJHTEST", "mOrientation = " + mOrientation);
                //返回的mOrientation就是手机方向，为0°、90°、180°和270°中的一个
            }
        }
    }

来监听手机的横竖变化，根据相应的角度进行调整。下面你是矫正角度的方法：

 /**
     * 将图片按照某个角度进行旋转
     *
     * @param bm     需要旋转的图片
     * @param degree 旋转角度
     * @return 旋转后的图片
     */
    public static Bitmap rotateBitmapByDegree(Bitmap bm, int degree, boolean bFlip) {

        if (degree >= 360)
            degree -= 360;
        if (degree < 0)
            degree += 360;
        Bitmap returnBm = null;

        // 根据旋转角度，生成旋转矩阵
        android.graphics.Matrix matrix = new android.graphics.Matrix();

        matrix.postRotate(degree);

        try {
            // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
            returnBm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(),
                    bm.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
        }
        if (returnBm == null) {
            returnBm = bm;
        }
        if (bm != returnBm) {
            bm.recycle();
        }
        return returnBm;
    }

至于切换摄像头，其实就是根据cameraId的变化，重新开启预览相机：

 @Override
    public boolean switchTo(int cameraId) {
        close();
        open(cameraId);
        if (cameraId == 1) {
            isFrontCamera = true;
        } else {
            isFrontCamera = false;
        }
        return false;
    }

然后开启闪光灯的操作，有三种模式：开启常亮的闪光灯，拍照时根据环境亮度开启闪光灯，关闭闪光灯三种模式：

  /**
     * 开启闪光灯
     */
    public void turnLightOn() {
        if (mCamera == null) {
            return;
        }
        Camera.Parameters parameters = mCamera.getParameters();
        if (parameters == null) {
            return;
        }
        List<String> flashModes = parameters.getSupportedFlashModes();
        // Check if camera flash exists
        if (flashModes == null) {
            // Use the screen as a flashlight (next best thing)
            return;
        }
        String flashMode = parameters.getFlashMode();
        if (!Camera.Parameters.FLASH_MODE_ON.equals(flashMode)) {
            // Turn on the flash
            if (flashModes.contains(Camera.Parameters.FLASH_MODE_ON)) {
                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_ON);
                mCamera.setParameters(parameters);
            } else {
            }
        }
    }

    //关闭闪光灯
    public void turnLightOff() {
        if (mCamera == null) {
            return;
        }
        Camera.Parameters parameters = mCamera.getParameters();
        if (parameters == null) {
            return;
        }
        List<String> flashModes = parameters.getSupportedFlashModes();
        String flashMode = parameters.getFlashMode();
        // Check if camera flash exists
        if (flashModes == null) {
            return;
        }
        if (!Camera.Parameters.FLASH_MODE_OFF.equals(flashMode)) {
            // Turn off the flash
            if (flashModes.contains(Camera.Parameters.FLASH_MODE_OFF)) {
                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
                mCamera.setParameters(parameters);
            } else {
            }
        }
    }

接下来就是前置摄像头镜像功能，意思就是我们的手机拍照，前置拍出来的照片都是左右反的，需要将图片进行相应的调整：

/**
     * 拍摄照片自动镜像
     * @param bmp
     * @return
     */
    public static Bitmap convertBmp(Bitmap bmp) {
        int w = bmp.getWidth();
        int h = bmp.getHeight();

        Matrix matrix = new Matrix();
        matrix.postScale(-1, 1); // 镜像水平翻转
        Bitmap convertBmp = Bitmap.createBitmap(bmp, 0, 0, w, h, matrix, true);

        return convertBmp;
    }

拍好照片，可能需要考虑给照片加个水印，这里不讨论实时的给相机每一帧加，因为没必要，又不是做贴纸，所以只是在拍照后加入水印操作：

 /**
     * 设置水印图片在右下角
     * @param src
     * @param watermark
     * @param paddingRight
     * @param paddingBottom
     * @return
     */
    public static Bitmap createWaterMaskRightBottom(
            Context context, Bitmap src, Bitmap watermark,
            int paddingRight, int paddingBottom) {
        return createWaterMaskBitmap(src, watermark,
                src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
                src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
    }

    private static Bitmap createWaterMaskBitmap(Bitmap src, Bitmap watermark,
                                                int paddingLeft, int paddingTop) {
        if (src == null) {
            return null;
        }
        int width = src.getWidth();
        int height = src.getHeight();
        //创建一个bitmap
        Bitmap newb = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);// 创建一个新的和SRC长度宽度一样的位图
        //将该图片作为画布
        Canvas canvas = new Canvas(newb);
        //在画布 0，0坐标上开始绘制原始图片
        canvas.drawBitmap(src, 0, 0, null);
        //在画布上绘制水印图片
        canvas.drawBitmap(watermark, paddingLeft, paddingTop, null);
        // 保存
        canvas.save(Canvas.ALL_SAVE_FLAG);
        // 存储
        canvas.restore();
        return newb;
    }

每个相机基本上都有自动对焦和手动对焦功能，自动对焦其实就是在初始化相机的设置参数：

 camera.cancelAutoFocus();//只有加上了这一句，才会自动对焦

手动对焦，需要获取屏幕收触控的点，根据点来设置对焦的地方：

 /**
     * 手动聚焦
     *
     * @param point 触屏坐标
     */
    protected boolean onFocus(Point point, Camera.AutoFocusCallback callback) {
        mCamera = manager.getmCamera();
        if (mCamera == null) {
            Log.e("tag","------------------------1");
            return false;
        }

        Camera.Parameters parameters = null;
        try {
            parameters = mCamera.getParameters();
        } catch (Exception e) {
            e.printStackTrace();
            Log.e("tag","------------------------2");
            return false;
        }
        //不支持设置自定义聚焦，则使用自动聚焦，返回

        if(Build.VERSION.SDK_INT >= 14) {

            if (parameters.getMaxNumFocusAreas() <= 0) {
                return focus(callback);
            }

            Log.i("tag", "onCameraFocus:" + point.x + "," + point.y);

            List<Camera.Area> areas = new ArrayList<Camera.Area>();
            int left = point.x - 300;
            int top = point.y - 300;
            int right = point.x + 300;
            int bottom = point.y + 300;
            left = left < -1000 ? -1000 : left;
            top = top < -1000 ? -1000 : top;
            right = right > 1000 ? 1000 : right;
            bottom = bottom > 1000 ? 1000 : bottom;
            areas.add(new Camera.Area(new Rect(left, top, right, bottom), 100));
            parameters.setFocusAreas(areas);
            try {
                //本人使用的小米手机在设置聚焦区域的时候经常会出异常，看日志发现是框架层的字符串转int的时候出错了，
                //目测是小米修改了框架层代码导致，在此try掉，对实际聚焦效果没影响
                mCamera.setParameters(parameters);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
                Log.e("tag","------------------------3");
                return false;
            }
        }


        return focus(callback);
    }

    private boolean focus(Camera.AutoFocusCallback callback) {
        try {
            mCamera.autoFocus(callback);
        } catch (Exception e) {
            e.printStackTrace();
            Log.e("tag","------------------------4");
            return false;
        }
        return true;
    }

最后就是相机的缩放了，直接上代码了：

 public void setZoom(int zoom) {
        if (mCamera == null) return;
        Camera.Parameters parameters;
        //注意此处为录像模式下的setZoom方式。在Camera.unlock之后，调用getParameters方法会引起android框架底层的异常
        //*上看到的解释是由于多线程同时访问Camera导致的冲突，所以在此使用录像前保存的mParameters。
        parameters = mCamera.getParameters();

        if (!parameters.isZoomSupported()) return;
        parameters.setZoom(zoom);
        mCamera.setParameters(parameters);
        mZoom = zoom;
    }

好了，相机camera的基本操作都在这里。

基于GlSurfaceView自定义CamerView自定义相机

我们相机的数据有两种常用的方法来预览，第一种就是利用SurfaceView控件，设置SurfaceHolder句柄来预览，这种方式相对比较简单，但是却不能很好的满足我们一些需求，比如在自定义相机中设置自定义的滤镜，贴纸，甚至加上AR的效果。所以，我们选择第二种方式，利用Opengl来绘制摄像头的数据。这样方便后面的拓展，其中的流程如下图：

这里面的关键是生成的纹理id如何通过opengl来绑定在一起，然后通过纹理id来生成SurfaceTexture，然后将摄像数据与GLSurfaceView绑定在一起显示出来。下面我们通过代码来分析。首先如何生成纹理id：

private int createTextureID(){
        int[] texture = new int[1];
        GLES20.glGenTextures(1, texture, 0);
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture[0]);
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
                GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
        return texture[0];
    }

此时的纹理id是没有和opengl绑定相关的，这个时候需要在GLSurfaceView的Render中的onSurfaceCreated进行相应的绑定操作：

 @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        int texture = createTextureID();
        surfaceTexture=new SurfaceTexture(texture);
        mOesFilter.create();
        mOesFilter.setTextureId(texture);
    }

上面通过纹理id生成了一个SurfaceTexture对象，然后把这个对象交给相机的CameraHelper，通过一下方法设置：

@Override
    public void setPreviewTexture(SurfaceTexture texture) {
        if (mCamera != null) {
            try {
                mCamera.setPreviewTexture(texture);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

这是时候摄像头的数据就已经和GLSurfaceView完成一半的工作了，不了解GLSurfaceView的绘图方式的请参考：http://www.jianshu.com/p/442682fda917
接下来，就是需要通过opengl的一些操作将摄像头数据正常显示出来了，其实主要还是实现onDrawFrame方法：

/**
     * 启用顶点坐标和纹理坐标进行绘制
     */
    protected void onDraw(){
        GLES20.glEnableVertexAttribArray(mHPosition);
        GLES20.glVertexAttribPointer(mHPosition,2, GLES20.GL_FLOAT, false, 0,mVerBuffer);
        GLES20.glEnableVertexAttribArray(mHCoord);
        GLES20.glVertexAttribPointer(mHCoord, 2, GLES20.GL_FLOAT, false, 0, mTexBuffer);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP,0,4);
        GLES20.glDisableVertexAttribArray(mHPosition);
        GLES20.glDisableVertexAttribArray(mHCoord);
    }

这里的主要opengl指令相关的类在于CameraFilter：

/**
 * @CreadBy ：DramaScript
 * @date 2017/7/10
 */
public class CameraFilter extends BaseFilter {

    //连续矩阵句柄
    private int mHCoordMatrix;
    //连续矩阵值
    private float[] mCoordMatrix= Arrays.copyOf(OM,16);

    public CameraFilter(Resources mRes) {
        super(mRes);
    }

    @Override
    protected void onCreate() {
        //创建opengl2
        createProgramByAssetsFile("shader/oes_base_vertex.sh","shader/oes_base_fragment.sh");
        mHCoordMatrix= GLES20.glGetUniformLocation(mProgram,"vCoordMatrix");
    }

    public void setCoordMatrix(float[] matrix){
        this.mCoordMatrix=matrix;
    }

    @Override
    protected void onBindTexture() {
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0+getTextureType());
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,getTextureId());
        GLES20.glUniform1i(mHTexture,getTextureType());
    }

    @Override
    protected void onSetExpandData() {
        super.onSetExpandData();
        GLES20.glUniformMatrix4fv(mHCoordMatrix,1,false,mCoordMatrix,0);
    }

    @Override
    protected void onSizeChanged(int width, int height) {

    }
}

上面通过加载Assets目录下的sh文件来显示，sh写的是opengl相关的代码，其中的顶点着色器和片元着色器：

#extension GL_OES_EGL_image_external : require
precision mediump float;
varying vec2 textureCoordinate;
uniform samplerExternalOES vTexture;
void main() {
    gl_FragColor = texture2D( vTexture, textureCoordinate );
}

attribute vec4 vPosition;
attribute vec2 vCoordinate;
uniform mat4 vMatrix;

varying vec2 aCoordinate;

void main(){
    gl_Position=vMatrix*vPosition;
    aCoordinate=vCoordinate;
}

其实主要还是整个流程，以及对opengl的一些相关术语的理解，如果不明opengl的相关术语描述。就这样，代码下载：
项目源码