版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/afei__/article/details/86603587
一、前言
假如你要使用 OpenGL ES 来渲染相机的话，使用 GLSurfaceView 将是一个很常用的选择。
这里介绍 GLSurfaceView + Camera 的组合。虽然从 Android 5.0 后推荐使用 Camera2 了，不过某些旧工程或者需要适配低版本的场景还是用得着旧的 Camer API 的。
为什么选择 GLSurfaceView ？
GLSurfaceView 继承自 SurfaceView。相比 SurfaceView，它加入了 EGL 的管理，并自带了渲染线程。另外它定义了用户需要实现的 Renderer 接口，客户端只需要将实现了渲染函数的 Renderer 的实现类设置给 GLSurfaceView 即可（策略模式）。
下面是该应用的简要截图：
二、相机开发步骤
我们选择将 Camera 和 View 分开，Camera 的相关操作由 CameraProxy 类完成，而 View 持有一个 CameraProxy 对象。这样 CameraProxy 也是可以重复利用的。
1. 打开相机
打开相机需要传入一个 cameraId，旧的 API 中只有 CAMERA_FACING_BACK 和 CAMERA_FACING_FRONT 两个值可以选择，返回一个 Camera 对象。
public void openCamera() {
mCamera = Camera.open(mCameraId); // 打开相机
Camera.getCameraInfo(mCameraId, mCameraInfo); // 获取相机信息
initConfig(); // 初始化相机配置
setDisplayOrientation(); // 设置相机显示方向
}
2. 初始化相机配置
在旧 Camera API 中，相机的配置都是通过 Parameters 类完成。
我们可以设置 闪光模式、聚焦模式、曝光强度、预览图片格式和大小、拍照图片格式和大小 等等信息。
private void initConfig() {
try {
mParameters = mCamera.getParameters();
// 如果摄像头不支持这些参数都会出错的，所以设置的时候一定要判断是否支持
List<String> supportedFlashModes = mParameters.getSupportedFlashModes();
if (supportedFlashModes != null && supportedFlashModes.contains(Parameters.FLASH_MODE_OFF)) {
mParameters.setFlashMode(Parameters.FLASH_MODE_OFF); // 设置闪光模式（关闭）
}
List<String> supportedFocusModes = mParameters.getSupportedFocusModes();
if (supportedFocusModes != null && supportedFocusModes.contains(Parameters.FOCUS_MODE_AUTO)) {
mParameters.setFocusMode(Parameters.FOCUS_MODE_AUTO); // 设置聚焦模式（自动）
}
mParameters.setPreviewFormat(ImageFormat.NV21); // 设置预览图片格式
mParameters.setPictureFormat(ImageFormat.JPEG); // 设置拍照图片格式
mParameters.setExposureCompensation(0); // 设置曝光强度
Size previewSize = getSuitableSize(mParameters.getSupportedPreviewSizes());
mPreviewWidth = previewSize.width;
mPreviewHeight = previewSize.height;
mParameters.setPreviewSize(mPreviewWidth, mPreviewHeight); // 设置预览图片大小
Log.d(TAG, "previewWidth: " + mPreviewWidth + ", previewHeight: " + mPreviewHeight);
Size pictureSize = getSuitableSize(mParameters.getSupportedPictureSizes());
mParameters.setPictureSize(pictureSize.width, pictureSize.height);
Log.d(TAG, "pictureWidth: " + pictureSize.width + ", pictureHeight: " + pictureSize.height);
mCamera.setParameters(mParameters); // 将设置好的parameters添加到相机里
} catch (Exception e) {
e.printStackTrace();
}
}
这里用到的一个 getSuitableSize 方法获取合数的 预览/拍照 尺寸。（后面贴完整代码）
3. 设置相机预览时的显示方向
这个方法很重要，关乎着你预览画面是否正常。其实相机底层的预览画面全都是宽度大于高度的，但是竖屏时画面要显示正常，都是通过这个方法设置了一定的显示方向。
private void setDisplayOrientation() {
int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
int result;
if (mCameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
result = (mCameraInfo.orientation + degrees) % 360;
result = (360 - result) % 360; // compensate the mirror
} else { // back-facing
result = (mCameraInfo.orientation - degrees + 360) % 360;
}
mCamera.setDisplayOrientation(result);
}
4. 开始预览、停止预览
我们需要自己新建一个 SurfaceTexture，这个创建过程后续介绍。
public void startPreview(SurfaceTexture surface) {
if (mCamera != null) {
try {
mCamera.setPreviewTexture(surface);
} catch (IOException e) {
e.printStackTrace();
}
mCamera.startPreview();
}
}
public void stopPreview() {
if (mCamera != null) {
mCamera.stopPreview(); // 停止预览
}
}
5. 释放相机
相机是很耗费系统资源的东西，用完一定要释放。对应于 openCamera 。
public void releaseCamera() {
if (mCamera != null) {
mCamera.setPreviewCallback(null);
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
}
6. 点击聚焦
简单的说，就是根据用户在 view 上的触摸点，使相机对该点进行一次对焦操作。
详细看我的这篇博客介绍的把：Android自定义相机定点聚焦
完整代码后面会贴的。
7. 双指放大缩小
我们也只实现放大缩小的逻辑，至于 View 的触摸交给 View 类去完成。
public void handleZoom(boolean isZoomIn) {
if (mParameters.isZoomSupported()) { // 首先还是要判断是否支持
int maxZoom = mParameters.getMaxZoom();
int zoom = mParameters.getZoom();
if (isZoomIn && zoom < maxZoom) {
zoom++;
} else if (zoom > 0) {
zoom--;
}
mParameters.setZoom(zoom); // 通过这个方法设置放大缩小
mCamera.setParameters(mParameters);
} else {
Log.w(TAG, "zoom not supported");
}
}
8. 拍照
拍照的逻辑我交给上层去完成了，后面再详细介绍把。这里我们只是简单的封装了一下元接口，一般常用的是 Camera.PictureCallback，会返回可用的 jpeg 给我们。
public void takePicture(Camera.PictureCallback pictureCallback) {
mCamera.takePicture(null, null, pictureCallback);
}
9. 其它
诸如设置预览回调、切换前后摄像头的操作等直接看下面的实现把。另外对于 聚焦模式、闪光灯模式 等没有详细去介绍了，感兴趣的可以另外搜索相关模块。毕竟相机要介绍完全的话还是一块很大的东西。
10. CameraProxy 类
下面代码还用到了 OrientationEventListener，这里之前没介绍，是通过传感器来获取当前手机的方向的，用于 拍照 的时候设置图片的选择使用，后面会介绍。
package com.afei.camerademo.camera;
import android.app.Activity;
import android.graphics.ImageFormat;
import android.graphics.Rect;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.PreviewCallback;
import android.hardware.Camera.Size;
import android.util.Log;
import android.view.OrientationEventListener;
import android.view.Surface;
import android.view.SurfaceHolder;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("deprecation")
public class CameraProxy implements Camera.AutoFocusCallback {
private static final String TAG = "CameraProxy";
private Activity mActivity;
private Camera mCamera;
private Parameters mParameters;
private CameraInfo mCameraInfo = new CameraInfo();
private int mCameraId = CameraInfo.CAMERA_FACING_BACK;
private int mPreviewWidth = 1440; // default 1440
private int mPreviewHeight = 1080; // default 1080
private float mPreviewScale = mPreviewHeight * 1f / mPreviewWidth;
private PreviewCallback mPreviewCallback; // 相机预览的数据回调
private OrientationEventListener mOrientationEventListener;
private int mLatestRotation = 0;
public byte[] mPreviewBuffer;
public CameraProxy(Activity activity) {
mActivity = activity;
mOrientationEventListener = new OrientationEventListener(mActivity) {
@Override
public void onOrientationChanged(int orientation) {
Log.d(TAG, "onOrientationChanged: orientation: " + orientation);
setPictureRotate(orientation);
}
};
}
public void openCamera() {
Log.d(TAG, "openCamera cameraId: " + mCameraId);
mCamera = Camera.open(mCameraId);
Camera.getCameraInfo(mCameraId, mCameraInfo);
initConfig();
setDisplayOrientation();
Log.d(TAG, "openCamera enable mOrientationEventListener");
mOrientationEventListener.enable();
}
public void releaseCamera() {
if (mCamera != null) {
Log.v(TAG, "releaseCamera");
mCamera.setPreviewCallback(null);
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
mOrientationEventListener.disable();
}
public void startPreview(SurfaceHolder holder) {
if (mCamera != null) {
Log.v(TAG, "startPreview");
try {
mCamera.setPreviewDisplay(holder);
} catch (IOException e) {
e.printStackTrace();
}
mCamera.startPreview();
}
}
public void startPreview(SurfaceTexture surface) {
if (mCamera != null) {
Log.v(TAG, "startPreview");
try {
mCamera.setPreviewTexture(surface);
} catch (IOException e) {
e.printStackTrace();
}
mCamera.startPreview();
}
}
public void stopPreview() {
if (mCamera != null) {
Log.v(TAG, "stopPreview");
mCamera.stopPreview();
}
}
public boolean isFrontCamera() {
return mCameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT;
}
private void initConfig() {
Log.v(TAG, "initConfig");
try {
mParameters = mCamera.getParameters();
// 如果摄像头不支持这些参数都会出错的，所以设置的时候一定要判断是否支持
List<String> supportedFlashModes = mParameters.getSupportedFlashModes();
if (supportedFlashModes != null && supportedFlashModes.contains(Parameters.FLASH_MODE_OFF)) {
mParameters.setFlashMode(Parameters.FLASH_MODE_OFF); // 设置闪光模式
}
List<String> supportedFocusModes = mParameters.getSupportedFocusModes();
if (supportedFocusModes != null && supportedFocusModes.contains(Parameters.FOCUS_MODE_AUTO)) {
mParameters.setFocusMode(Parameters.FOCUS_MODE_AUTO); // 设置聚焦模式
}
mParameters.setPreviewFormat(ImageFormat.NV21); // 设置预览图片格式
mParameters.setPictureFormat(ImageFormat.JPEG); // 设置拍照图片格式
mParameters.setExposureCompensation(0); // 设置曝光强度
Size previewSize = getSuitableSize(mParameters.getSupportedPreviewSizes());
mPreviewWidth = previewSize.width;
mPreviewHeight = previewSize.height;
mParameters.setPreviewSize(mPreviewWidth, mPreviewHeight); // 设置预览图片大小
Log.d(TAG, "previewWidth: " + mPreviewWidth + ", previewHeight: " + mPreviewHeight);
Size pictureSize = getSuitableSize(mParameters.getSupportedPictureSizes());
mParameters.setPictureSize(pictureSize.width, pictureSize.height);
Log.d(TAG, "pictureWidth: " + pictureSize.width + ", pictureHeight: " + pictureSize.height);
mCamera.setParameters(mParameters); // 将设置好的parameters添加到相机里
} catch (Exception e) {
e.printStackTrace();
}
}
private Size getSuitableSize(List<Size> sizes) {
int minDelta = Integer.MAX_VALUE; // 最小的差值，初始值应该设置大点保证之后的计算中会被重置
int index = 0; // 最小的差值对应的索引坐标
for (int i = 0; i < sizes.size(); i++) {
Size previewSize = sizes.get(i);
Log.v(TAG, "SupportedPreviewSize, width: " + previewSize.width + ", height: " + previewSize.height);
// 找到一个与设置的分辨率差值最小的相机支持的分辨率大小
if (previewSize.width * mPreviewScale == previewSize.height) {
int delta = Math.abs(mPreviewWidth - previewSize.width);
if (delta == 0) {
return previewSize;
}
if (minDelta > delta) {
minDelta = delta;
index = i;
}
}
}
return sizes.get(index); // 默认返回与设置的分辨率最接近的预览尺寸
}
/**
* 设置相机显示的方向，必须设置，否则显示的图像方向会错误
*/
private void setDisplayOrientation() {
int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation();
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
int result;
if (mCameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
result = (mCameraInfo.orientation + degrees) % 360;
result = (360 - result) % 360; // compensate the mirror
} else { // back-facing
result = (mCameraInfo.orientation - degrees + 360) % 360;
}
mCamera.setDisplayOrientation(result);
}
private void setPictureRotate(int orientation) {
if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) return;
orientation = (orientation + 45) / 90 * 90;
int rotation = 0;
if (mCameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) {
rotation = (mCameraInfo.orientation - orientation + 360) % 360;
} else { // back-facing camera
rotation = (mCameraInfo.orientation + orientation) % 360;
}
Log.d(TAG, "picture rotation: " + rotation);
mLatestRotation = rotation;
}
public int getLatestRotation() {
return mLatestRotation;
}
public void setPreviewCallback(PreviewCallback previewCallback) {
mPreviewCallback = previewCallback;
if (mPreviewBuffer == null) {
mPreviewBuffer = new byte[mPreviewWidth * mPreviewHeight * 3 / 2];
}
mCamera.addCallbackBuffer(mPreviewBuffer);
mCamera.setPreviewCallbackWithBuffer(mPreviewCallback); // 设置预览的回调
}
public void takePicture(Camera.PictureCallback pictureCallback) {
mCamera.takePicture(null, null, pictureCallback);
}
public void switchCamera() {
mCameraId ^= 1; // 先改变摄像头朝向
releaseCamera();
openCamera();
}
public void focusOnPoint(int x, int y, int width, int height) {
Log.v(TAG, "touch point (" + x + ", " + y + ")");
if (mCamera == null) {
return;
}
Parameters parameters = mCamera.getParameters();
// 1.先要判断是否支持设置聚焦区域
if (parameters.getMaxNumFocusAreas() > 0) {
// 2.以触摸点为中心点，view窄边的1/4为聚焦区域的默认边长
int length = Math.min(width, height) >> 3; // 1/8的长度
int left = x - length;
int top = y - length;
int right = x + length;
int bottom = y + length;
// 3.映射，因为相机聚焦的区域是一个(-1000,-1000)到(1000,1000)的坐标区域
left = left * 2000 / width - 1000;
top = top * 2000 / height - 1000;
right = right * 2000 / width - 1000;
bottom = bottom * 2000 / height - 1000;
// 4.判断上述矩形区域是否超过边界，若超过则设置为临界值
left = left < -1000 ? -1000 : left;
top = top < -1000 ? -1000 : top;
right = right > 1000 ? 1000 : right;
bottom = bottom > 1000 ? 1000 : bottom;
Log.d(TAG, "focus area (" + left + ", " + top + ", " + right + ", " + bottom + ")");
ArrayList<Camera.Area> areas = new ArrayList<>();
areas.add(new Camera.Area(new Rect(left, top, right, bottom), 600));
parameters.setFocusAreas(areas);
}
try {
mCamera.cancelAutoFocus(); // 先要取消掉进程中所有的聚焦功能
mCamera.setParameters(parameters);
mCamera.autoFocus(this); // 调用聚焦
} catch (Exception e) {
e.printStackTrace();
}
}
public void handleZoom(boolean isZoomIn) {
if (mParameters.isZoomSupported()) {
int maxZoom = mParameters.getMaxZoom();
int zoom = mParameters.getZoom();
if (isZoomIn && zoom < maxZoom) {
zoom++;
} else if (zoom > 0) {
zoom--;
}
Log.d(TAG, "handleZoom: zoom: " + zoom);
mParameters.setZoom(zoom);
mCamera.setParameters(mParameters);
} else {
Log.i(TAG, "zoom not supported");
}
}
public Camera getCamera() {
return mCamera;
}
public int getPreviewWidth() {
return mPreviewWidth;
}
public int getPreviewHeight() {
return mPreviewHeight;
}
@Override
public void onAutoFocus(boolean success, Camera camera) {
Log.d(TAG, "onAutoFocus: " + success);
}
}
三、CameraGLSurfaceView
通过上面的介绍，对于相机的操作应该有了一定的了解了，接下来完成 View 这部分。
需求分析：
CameraGLSurfaceView是要继承GLSurfaceView的。- 我们需要重写
onMeasure使得CameraGLSurfaceView的宽高可以和相机预览尺寸相匹配，这样就不会有画面被拉伸的感觉了。 - 我们需要在
CameraGLSurfaceView中完成对相机的打开、关闭等操作，值得庆幸的是我们可以通过上面的CameraProxy很容易的做到。 - 我们需要重写
onTouchEvent方法，来实现单点聚焦，双指放大缩小的功能。 - 我们要实现
GLSurfaceView.Renderer接口，并在其中完成相机的渲染。
实现：
CameraGLSurfaceView
主要是在 GLSurfaceView.Renderer 的几个回调方法中打开和释放相机，另外就是重写 onMeasure ，onTouchEvent 那几个方法。
package com.afei.camerademo.glsurfaceview;
import android.app.Activity;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import com.afei.camerademo.camera.CameraProxy;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
public class CameraGLSurfaceView extends GLSurfaceView implements GLSurfaceView.Renderer, SurfaceTexture.OnFrameAvailableListener {
private static final String TAG = "CameraGLSurfaceView";
private CameraProxy mCameraProxy;
private SurfaceTexture mSurfaceTexture;
private CameraDrawer mDrawer;
private int mRatioWidth = 0;
private int mRatioHeight = 0;
private float mOldDistance;
private int mTextureId = -1;
public CameraGLSurfaceView(Context context) {
this(context, null);
}
public CameraGLSurfaceView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context);
}
private void init(Context context) {
mCameraProxy = new CameraProxy((Activity) context);
setEGLContextClientVersion(2);
setRenderer(this);
setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}
@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
mTextureId = OpenGLUtils.getExternalOESTextureID();
mSurfaceTexture = new SurfaceTexture(mTextureId);
mSurfaceTexture.setOnFrameAvailableListener(this);
mCameraProxy.openCamera();
mDrawer = new CameraDrawer();
}
@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
Log.d(TAG, "onSurfaceChanged. thread: " + Thread.currentThread().getName());
Log.d(TAG, "onSurfaceChanged. width: " + width + ", height: " + height);
int previewWidth = mCameraProxy.getPreviewWidth();
int previewHeight = mCameraProxy.getPreviewHeight();
if (width > height) {
setAspectRatio(previewWidth, previewHeight);
} else {
setAspectRatio(previewHeight, previewWidth);
}
GLES20.glViewport(0, 0, width, height);
mCameraProxy.startPreview(mSurfaceTexture);
}
@Override
public void onDrawFrame(GL10 gl) {
GLES20.glClearColor(0, 0, 0, 0);
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
mSurfaceTexture.updateTexImage();
mDrawer.draw(mTextureId, mCameraProxy.isFrontCamera());
}
@Override
public void onFrameAvailable(SurfaceTexture surfaceTexture) {
requestRender();
}
public void setAspectRatio(int width, int height) {
if (width < 0 || height < 0) {
throw new IllegalArgumentException("Size cannot be negative.");
}
mRatioWidth = width;
mRatioHeight = height;
post(new Runnable() {
@Override
public void run() {
requestLayout(); // must run in UI thread
}
});
}
public CameraProxy getCameraProxy() {
return mCameraProxy;
}
public SurfaceTexture getSurfaceTexture() {
return mSurfaceTexture;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
if (0 == mRatioWidth || 0 == mRatioHeight) {
setMeasuredDimension(width, height);
} else {
if (width < height * mRatioWidth / mRatioHeight) {
setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
} else {
setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
}
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (event.getPointerCount() == 1) {
// 点击聚焦
mCameraProxy.focusOnPoint((int) event.getX(), (int) event.getY(), getWidth(), getHeight());
return true;
}
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_POINTER_DOWN:
mOldDistance = getFingerSpacing(event);
break;
case MotionEvent.ACTION_MOVE:
float newDistance = getFingerSpacing(event);
if (newDistance > mOldDistance) {
mCameraProxy.handleZoom(true);
} else if (newDistance < mOldDistance) {
mCameraProxy.handleZoom(false);
}
mOldDistance = newDistance;
break;
default:
break;
}
return super.onTouchEvent(event);
}
private static float getFingerSpacing(MotionEvent event) {
float x = event.getX(0) - event.getX(1);
float y = event.getY(0) - event.getY(1);
return (float) Math.sqrt(x * x + y * y);
}
}
CameraDrawer
自定义的一个类，将绘制的代码抽离出来了，主要是 draw() 方法。
涉及到很多关于 OpenGL ES 的知识，限于篇幅很难全部解释清楚，建议预备好这部分的相关知识或者自行搜索。
package com.afei.camerademo.glsurfaceview;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
public class CameraDrawer {
public final String VERTEX_SHADER = "" +
"attribute vec4 vPosition;" +
"attribute vec2 inputTextureCoordinate;" +
"varying vec2 textureCoordinate;" +
"void main()" +
"{"+
"gl_Position = vPosition;"+
"textureCoordinate = inputTextureCoordinate;" +
"}";
public final String FRAGMENT_SHADER = "" +
"#extension GL_OES_EGL_image_external : require\n"+
"precision mediump float;" +
"varying vec2 textureCoordinate;\n" +
"uniform samplerExternalOES s_texture;\n" +
"void main() {" +
" gl_FragColor = texture2D( s_texture, textureCoordinate );\n" +
"}";
private FloatBuffer mVertexBuffer;
private FloatBuffer mBackTextureBuffer;
private FloatBuffer mFrontTextureBuffer;
private ByteBuffer mDrawListBuffer;
private int mProgram;
private int mPositionHandle;
private int mTextureHandle;
private static final float VERTEXES[] = {
-1.0f, 1.0f,
-1.0f,-1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
};
// 后置摄像头使用的纹理坐标
private static final float TEXTURE_BACK[] = {
0.0f, 1.0f,
1.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
};
// 前置摄像头使用的纹理坐标
private static final float TEXTURE_FRONT[] = {
1.0f, 1.0f,
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
};
private static final byte VERTEX_ORDER[] = { 0, 1, 2, 3 }; // order to draw vertices
private final int VERTEX_SIZE = 2;
private final int VERTEX_STRIDE = VERTEX_SIZE * 4;
public CameraDrawer() {
// init float buffer for vertex coordinates
mVertexBuffer = ByteBuffer.allocateDirect(VERTEXES.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
mVertexBuffer.put(VERTEXES).position(0);
// init float buffer for texture coordinates
mBackTextureBuffer = ByteBuffer.allocateDirect(TEXTURE_BACK.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
mBackTextureBuffer.put(TEXTURE_BACK).position(0);
mFrontTextureBuffer = ByteBuffer.allocateDirect(TEXTURE_FRONT.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
mFrontTextureBuffer.put(TEXTURE_FRONT).position(0);
// init byte buffer for draw list
mDrawListBuffer = ByteBuffer.allocateDirect(VERTEX_ORDER.length).order(ByteOrder.nativeOrder());
mDrawListBuffer.put(VERTEX_ORDER).position(0);
mProgram = OpenGLUtils.createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
mTextureHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
}
public void draw(int texture, boolean isFrontCamera) {
GLES20.glUseProgram(mProgram); // 指定使用的program
GLES20.glEnable(GLES20.GL_CULL_FACE); // 启动剔除
GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture); // 绑定纹理
GLES20.glEnableVertexAttribArray(mPositionHandle);
GLES20.glVertexAttribPointer(mPositionHandle, VERTEX_SIZE, GLES20.GL_FLOAT, false, VERTEX_STRIDE, mVertexBuffer);
GLES20.glEnableVertexAttribArray(mTextureHandle);
if (isFrontCamera) {
GLES20.glVertexAttribPointer(mTextureHandle, VERTEX_SIZE, GLES20.GL_FLOAT, false, VERTEX_STRIDE, mFrontTextureBuffer);
} else {
GLES20.glVertexAttribPointer(mTextureHandle, VERTEX_SIZE, GLES20.GL_FLOAT, false, VERTEX_STRIDE, mBackTextureBuffer);
}
// 真正绘制的操作
GLES20.glDrawElements(GLES20.GL_TRIANGLE_FAN, VERTEX_ORDER.length, GLES20.GL_UNSIGNED_BYTE, mDrawListBuffer);
GLES20.glDisableVertexAttribArray(mPositionHandle);
GLES20.glDisableVertexAttribArray(mTextureHandle);
}
}
OpenGLUtils
上面还用到了一个 OpenGLUtils 类，这里简单的封装了一些创建程序，加载 shader 等公用操作。
package com.afei.camerademo.glsurfaceview;
import android.content.res.Resources;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.util.Log;
import java.io.IOException;
import java.io.InputStream;
import javax.microedition.khronos.opengles.GL10;
public class OpenGLUtils {
private static final String TAG = "OpenGLUtils";
public static int getExternalOESTextureID() {
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];
}
public static int loadShader(int type, String source) {
// 1. create shader
int shader = GLES20.glCreateShader(type);
if (shader == GLES20.GL_NONE) {
Log.e(TAG, "create shared failed! type: " + type);
return GLES20.GL_NONE;
}
// 2. load shader source
GLES20.glShaderSource(shader, source);
// 3. compile shared source
GLES20.glCompileShader(shader);
// 4. check compile status
int[] compiled = new int[1];
GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
if (compiled[0] == GLES20.GL_FALSE) { // compile failed
Log.e(TAG, "Error compiling shader. type: " + type + ":");
Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
GLES20.glDeleteShader(shader); // delete shader
shader = GLES20.GL_NONE;
}
return shader;
}
public static int createProgram(String vertexSource, String fragmentSource) {
// 1. load shader
int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
if (vertexShader == GLES20.GL_NONE) {
Log.e(TAG, "load vertex shader failed! ");
return GLES20.GL_NONE;
}
int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
if (fragmentShader == GLES20.GL_NONE) {
Log.e(TAG, "load fragment shader failed! ");
return GLES20.GL_NONE;
}
// 2. create gl program
int program = GLES20.glCreateProgram();
if (program == GLES20.GL_NONE) {
Log.e(TAG, "create program failed! ");
return GLES20.GL_NONE;
}
// 3. attach shader
GLES20.glAttachShader(program, vertexShader);
GLES20.glAttachShader(program, fragmentShader);
// we can delete shader after attach
GLES20.glDeleteShader(vertexShader);
GLES20.glDeleteShader(fragmentShader);
// 4. link program
GLES20.glLinkProgram(program);
// 5. check link status
int[] linkStatus = new int[1];
GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
if (linkStatus[0] == GLES20.GL_FALSE) { // link failed
Log.e(TAG, "Error link program: ");
Log.e(TAG, GLES20.glGetProgramInfoLog(program));
GLES20.glDeleteProgram(program); // delete program
return GLES20.GL_NONE;
}
return program;
}
public static String loadFromAssets(String fileName, Resources resources) {
String result = null;
try {
InputStream is = resources.getAssets().open(fileName);
int length = is.available();
byte[] data = new byte[length];
is.read(data);
is.close();
result = new String(data, "UTF-8");
result.replace("\\r\\n", "\\n");
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
}
四、CameraActivity
接下来，我们把写好的 CameraSurfaceView 放在 Activity 或者 Fragment 中使用就行了。
注意相机使用前，需要申请相关权限，以及权限的动态申请。
1. AndroidManifest.xml
相机相关权限如下，动态权限的申请代码很多，这里不详细介绍了，不清楚的可以看这篇博客：Android动态权限申请
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera"/>
<uses-feature android:name="android.hardware.camera.autofocus"/>
2. 拍照功能
之前只是预留了拍照的功能，并等待外面出传入一个接口回调，这里我们在拍照键点下的时候执行拍照操作就行。
保存图片是耗时操作，不要放在主线程中执行，当拍照完成时，会自动调用 onPictureTaken 方法，我们在这个回调中执行保存的操作。
package com.afei.camerademo.glsurfaceview;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Camera;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import com.afei.camerademo.ImageUtils;
import com.afei.camerademo.R;
import com.afei.camerademo.camera.CameraProxy;
public class GLSurfaceCameraActivity extends AppCompatActivity implements View.OnClickListener {
private static final String TAG = "SurfaceCameraActivity";
private ImageView mCloseIv;
private ImageView mSwitchCameraIv;
private ImageView mTakePictureIv;
private ImageView mPictureIv;
private CameraGLSurfaceView mCameraView;
private CameraProxy mCameraProxy;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_glsurface_camera);
initView();
}
private void initView() {
mCloseIv = findViewById(R.id.toolbar_close_iv);
mCloseIv.setOnClickListener(this);
mSwitchCameraIv = findViewById(R.id.toolbar_switch_iv);
mSwitchCameraIv.setOnClickListener(this);
mTakePictureIv = findViewById(R.id.take_picture_iv);
mTakePictureIv.setOnClickListener(this);
mPictureIv = findViewById(R.id.picture_iv);
mPictureIv.setOnClickListener(this);
mPictureIv.setImageBitmap(ImageUtils.getLatestThumbBitmap());
mCameraView = findViewById(R.id.camera_view);
mCameraProxy = mCameraView.getCameraProxy();
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.toolbar_close_iv:
finish();
break;
case R.id.toolbar_switch_iv:
mCameraProxy.switchCamera();
mCameraProxy.startPreview(mCameraView.getSurfaceTexture());
break;
case R.id.take_picture_iv:
mCameraProxy.takePicture(mPictureCallback);
break;
case R.id.picture_iv:
Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivity(intent);
break;
}
}
private final Camera.PictureCallback mPictureCallback = new Camera.PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera) {
Log.d(TAG, "onPictureTaken: callback");
mCameraProxy.startPreview(mCameraView.getSurfaceTexture());// 拍照结束后继续预览
new ImageSaveTask().execute(data); // 保存图片
}
};
private class ImageSaveTask extends AsyncTask<byte[], Void, Void> {
@Override
protected Void doInBackground(byte[]... bytes) {
long time = System.currentTimeMillis();
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes[0], 0, bytes[0].length);
Log.d(TAG, "BitmapFactory.decodeByteArray time: " + (System.currentTimeMillis() - time));
int rotation = mCameraProxy.getLatestRotation();
time = System.currentTimeMillis();
Bitmap rotateBitmap = ImageUtils.rotateBitmap(bitmap, rotation, mCameraProxy.isFrontCamera(), true);
Log.d(TAG, "rotateBitmap time: " + (System.currentTimeMillis() - time));
time = System.currentTimeMillis();
ImageUtils.saveBitmap(rotateBitmap);
Log.d(TAG, "saveBitmap time: " + (System.currentTimeMillis() - time));
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
mPictureIv.setImageBitmap(ImageUtils.getLatestThumbBitmap());
}
}
}
另外，我又尝试过通过 Camera.Parameters 类的 setRotation() 方法来设置拍照的旋转信息，但是没见有效果，不知道哪里有问题。
最后还是选择使用手动旋转 Bitmap 的方式来完成图片的旋转并保存。
附上 ImageUtils 代码：
package com.afei.camerademo;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.Log;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ImageUtils {
private static final String TAG = "ImageUtils";
private static final String GALLERY_PATH = Environment.getExternalStoragePublicDirectory(Environment
.DIRECTORY_DCIM) + File.separator + "Camera";
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMdd_HHmmss");
public static Bitmap rotateBitmap(Bitmap source, int degree, boolean flipHorizontal, boolean recycle) {
if (degree == 0) {
return source;
}
Matrix matrix = new Matrix();
matrix.postRotate(degree);
if (flipHorizontal) {
matrix.postScale(-1, 1); // 前置摄像头存在水平镜像的问题，所以有需要的话调用这个方法进行水平镜像
}
Bitmap rotateBitmap = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, false);
if (recycle) {
source.recycle();
}
return rotateBitmap;
}
public static void saveBitmap(Bitmap bitmap) {
String fileName = DATE_FORMAT.format(new Date(System.currentTimeMillis())) + ".jpg";
File outFile = new File(GALLERY_PATH, fileName);
Log.d(TAG, "saveImage. filepath: " + outFile.getAbsolutePath());
FileOutputStream os = null;
try {
os = new FileOutputStream(outFile);
boolean success = bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
if (success) {
insertToDB(outFile.getAbsolutePath());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void insertToDB(String picturePath) {
ContentValues values = new ContentValues();
ContentResolver resolver = MyApp.getInstance().getContentResolver();
values.put(MediaStore.Images.ImageColumns.DATA, picturePath);
values.put(MediaStore.Images.ImageColumns.TITLE, picturePath.substring(picturePath.lastIndexOf("/") + 1));
values.put(MediaStore.Images.ImageColumns.DATE_TAKEN, System.currentTimeMillis());
values.put(MediaStore.Images.ImageColumns.MIME_TYPE, "image/jpeg");
resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
}
}
五、项目地址
这个项目其实还没有完全写完，部分功能和 Camera2 等都还在开发中，不过应该不影响上述介绍的功能使用。
地址：
其它：