前言
Android5.0之前使用android.hardware包下的Camera类进行拍照、录视频等功能。5.0以后，新增了android.hardware.camera2包，利用新的机制、新的类进行拍照、录视频。
使用Camera
一、拍照
由于手机摄像头配置不同、摄像头摆放方向不同、位置不同等等因素，与摄像头相关参数如：摄像头个数、支持的像素、画面预览方向、闪光灯、对焦方式、帧率等等都不一样，必须根据当前手机的配置动态获取。获取方法如下：
Camera.Parameters p = mCamera.getParameters();
List<Camera.Size> preSizes = p.getSupportedPreviewSizes();
List<Camera.Size> preSizes = p.getSupportedPictureSizes();
......
......
获取其它参数就是getSupportedXXX，返回的都是list，手动遍历，选择最合适的参数。
拍照主要由两部分功能组成，一个是预览界面，一个是“获取正确的照片”。实现步骤如下：
1、初始化Camera
public boolean initCamera() {
mCamera = null;
try {
mCamera = Camera.open();
} catch (Exception e) {
}
return null != mCamera;
}
2、设置预览orientation
private void setPreviewOrientation(){
int result = 0;
// 计算Activity转动的角度degree。如果在manifest中设置为portrait，则degree总是为0
int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
int degree = 0;
switch (rotation) {
case Surface.ROTATION_0:
degree = 0;
break;
case Surface.ROTATION_90:
degree = 90;
break;
case Surface.ROTATION_180:
degree = 180;
break;
case Surface.ROTATION_270:
degree = 270;
break;
}
// 获取后置摄像头信息，获取方法见后面
Camera.CameraInfo info = getBackCameraInfo();
// 摄像头转动角度减去Activity转动角度，得到角度差，然后在设置预览画面角度时把这个角度差补偿回来
if (null != info) {
int offset = info.orientation - degree;
// 如果角度差为正值，result就等于offset；
// 如果角度差为-90度，result就转270度，刚好到-90度的位置；如果角度差为-180度....以此类推
result = (offset + 360) % 360;
}
// 设置预览画面转动角度
mCamera.setDisplayOrientation(result);
}
//遍历所有摄像头信息，根据info.facing判断该摄像头是前置还是后置
public static Camera.CameraInfo getBackCameraInfo() {
int cameraNums = Camera.getNumberOfCameras();
for (int i = 0; i < cameraNums; i++) {
// CameraInfo类只是存储了一些字段，刚new出来，这些字段都为null
Camera.CameraInfo info = new Camera.CameraInfo();
// 虽然方法名为getXXX，但实际上的作用是：获取第cameraId个摄像头，把这个摄像头的信息存储到info中
Camera.getCameraInfo(i, info);
if (Camera.CameraInfo.CAMERA_FACING_BACK == info.facing) {
return info;
}
}
return null;
}
3、设置预览画面大小、比例
// 获取该摄像头支持的预览尺寸sizes，遍历sizes，计算出最合适的尺寸bestSize。具体算法就不贴出了
private void setPreviewSize(){
Camera.Parameters p = mCamera.getParameters();
List<Camera.Size> preSizes = p.getSupportedPreviewSizes();
Camera.Size bestSize = KuCameraUtil.getBestSize(preSizes, minTotalPix, maxTotalPix, rate);
if (null != bestSize && bestSize.width > 0 && bestSize.height > 0) {
p.setPreviewSize(bestSize.width, bestSize.height);
// camera设置完previewSize后，负责显示预览的surfaceView/textureView也需要进行设置大小
mCamera.setParameters(p);
}
}
4、初始化显示预览画面的控件surfaceView或textureView
// 预览控件既可以用surfaceView，也可以用textureView，这两个类的详细介绍有空再整理，推荐使用textureView
private void initTextureView(){
mTextureView = (TextureView) findViewById(R.id.preview);
// 获取camera的previewSize，根据其设置mTextureView控件的大小、比例
Camera.Size size = mCamera.getPreviewSize();
if (null != size) {
// 宽度固定为屏幕宽度，按照previewSize的宽高比设置高度
float rate = (float) size.height / (float) size.width;
LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) mTextureView.getLayoutParams();
params.width = ScreenUtils.getScreenWidth(this);
params.height = (int) (rate >= 1 ? params.width * rate : params.width / rate);
mTextureView.setLayoutParams(params);
}
// mTextureView生命周期回调
mTextureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
// 开始预览
mKuCamera.startPreview(surface);
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
// 结束预览
mKuCamera.stopPreview();
return true;
}
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
});
}
5、执行拍照，获取拍照图片
// 拍照
private void takePhoto(){
mCamera.takePhoto(new Camera.PictureCallback() {
@Override
public void onPictureTaken(byte[] bytes, Camera camera) {
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
if (bitmap != null) {
try {
File file = new File(KuPathUtil.getImageDir(), KuPathUtil.getNowTimeStr() + "jpg");
OutputStream os = new FileOutputStream(file);
os.write(bytes);
os.flush();
os.close();
// 获取到的图片是摄像头捕获到的原始图片，也需要对其进行旋转，旋转方法见后面
PhotoUtil.setPicOrientation(file.getAbsolutePath(), mNeedOrientation);
} catch (Exception e) {
e.printStackTrace();
}
}
}
});
}
// 旋转图片
public static void setPicOrientation(String filePath, int degree) {
try {
ExifInterface exifInterface = new ExifInterface(filePath);
String orientation = String.valueOf(ExifInterface.ORIENTATION_NORMAL);
// 角度转换为对应的ORIENTATION_ROTATE值
if (90 == degree) {
orientation = String.valueOf(ExifInterface.ORIENTATION_ROTATE_90);
} else if (180 == degree) {
orientation = String.valueOf(ExifInterface.ORIENTATION_ROTATE_180);
} else if (270 == degree) {
orientation = String.valueOf(ExifInterface.ORIENTATION_ROTATE_270);
}
//设置选择角度
exifInterface.setAttribute(ExifInterface.TAG_ORIENTATION, orientation);
exifInterface.saveAttributes();
} catch (IOException e) {
e.printStackTrace();
}
}
6、停止预览、释放camera资源
private void release() {
if (null != mCamera) {
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
}
二、录视频
1、初始化camera、设置预览orientation、设置previewSize、初始化surfaceView/textureView与上面拍照的流程一模一样。其中，如果使用surfaceView，在MediaRecorder中也需要设置，使用textureView则不需要。
2、进行录制
private void startRecording(){
try {
// 初始化recorder
mRecorder = new MediaRecorder();
// 解锁摄像头，连接到摄像头
mCamera.unlock();
mRecorder.setCamera(mCamera);
// 设置音、视频源
mRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
// 设置文件输出格式、音视频编码格式。设置顺序必须按照下面的顺序来，否则会报错
// 关于音视频格式的优缺点，参考http://blog.csdn.net/wcl0715/article/details/676137和http://blog.csdn.net/androidzhaoxiaogang/article/details/6865644
mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
// 设置orientation，这个跟预览画面的角度一样，按照上面的代码获取角度
mRecorder.setOrientationHint(mNeedOrientation);
// 设置比特率，这个参数对视频文件的大小影响最大（格式相同情况下）
mRecorder.setVideoEncodingBitRate(800 * 800);
// 设置帧率。设置得过低会闪屏，设置高一点也不会增加文件大小，建议设置30左右
mRecorder.setVideoFrameRate(30);
// 设置视频size。通过camera.getParameters().getSupportedVideoSizes()获取到所有支持的sizes，选一个最合适的
if (size.width > 0 && size.height > 0) {
mRecorder.setVideoSize(size.width , size.height);
}
// 到时间后，可以通过MediaRecorder.OnInfoListener接收到回调；到时间后录制不会自动停止，但最终视频文件只截取前面10s
mRecorder.setMaxDuration(10000);
mRecorder.setOutputFile(videoPath);
// 准备、开始
mRecorder.prepare();
mRecorder.start();
return true;
} catch (IOException e) {
Log.i("wk", "record prepare failed,IOException:" + e.toString());
return false;
}
}
3、停止录制、释放MediaRecorder资源
private void stopRecording() {
if (null != mRecorder) {
mRecorder.stop();
mRecorder.release();
mRecorder = null;
}
}
4、锁定Camera、停止预览、释放Camera资源
使用Camera2
Camera2网上已经有很多介绍了，我写了一个使用Camera2录像的demo，使用方法、注意事项等就直接在代码注释中，就不单独用文字描述了，偷懒。
为了方便理清camera2使用的主逻辑，一些配置代码、计算代码放在各个helper类里。这种代码设计不是最优设计，实际开发中不要照搬。
先是使用的代码，各个helper类的代码放在后面。
/**
* 一、Camera2使用
* Camera2的操作都是基于管道的，就是发送请求、等待回应的过程，使用起来没有代码结构不如Camera那种线性调用清晰。通过下面四个回调就能说清楚使用过程：
*
* 1.等待surface创建成功的回调，即SurfaceTextureListener（或者是SurfaceView的listener，demo用的是TextureView）
* 做Camera开发就必须要预览，要预览就得有Surface，所以第一步就是等待Surface创建完成；
*
* 2.等待Camera启动完成的回调，即CameraDevice.StateCallback
* Camera的启动需要一个过程，只有Camera启动后才可进行各种操作
*
* 3.等待会话建立的回调，即CameraCaptureSession.StateCallback
* 要向Camera发送各种操作请求，就必须先建立会话通道
*
* 4.等待操作请求的回调，即CameraCaptureSession.CaptureCallback
* 向Camera发起了"拍照"请求后，Camera需要一定时间才能完成，等待完成后就可以对图像数据进行处理了
*
* 总结起来就是：创建surface、启动camera、创建camera会话、发起拍照请求
*
* 二、预览、拍照/录像中的方向问题
* 1.摄像头总是采集某个矩形范围内的图像，摄像头的方向决定了这个矩形的哪个边是底、哪个边是左/右；
*
* 2.摄像头会把采集到的图像按照摄像头的方向传输给屏幕，用于显示预览图，所以需要根据摄像头方向和屏幕方向，决定预览显示的旋转角度；
*
* 3.摄像头采集的图像就是最终的成像数据，所以需要根据摄像头方向和拍摄时的手机方向，决定最终成像需要旋转的角度
*/
public class VideoActivity extends Activity implements View.OnClickListener {
private static final String TAG = "VideoActivity";
private TextureView mTextureView;
private CameraDevice mCameraDevice;
// 方便理清camera2使用的主逻辑，一些配置代码、计算代码放在各个helper类里
private CameraHelper mCameraHelper;
private RecorderHelper mRecorderHelper;
private TextureHelper mTextureHelper;
// 一个device同一时间只能存在一个session，新的session启动时会关闭其它session；
// 一个session对应一个request、surfaceList，注意处理好一一对应关系
private CaptureRequest.Builder mRequest;
private List<Surface> mSurfaceList = new ArrayList<>();
private CameraCaptureSession mSession;
// camera2中用到的几个回调，通过指定handler，回调方法就会在该handler所在线程被调用
private HandlerThread mBackgroundThread;
private Handler mBackgroundHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_video);
mTextureView = findViewById(R.id.texture);
findViewById(R.id.video_record).setOnClickListener(this);
findViewById(R.id.video_stop).setOnClickListener(this);
mCameraHelper = new CameraHelper(this);
mRecorderHelper = new RecorderHelper(this);
mTextureHelper = new TextureHelper(this);
}
@Override
public void onResume() {
super.onResume();
// 启动后台线程，用于执行回调中的代码
startBackgroundThread();
// 如果Activity是从stop/pause回来，TextureView是OK的，只需要重新开启camera就行
if (mTextureView.isAvailable()) {
openCamera();
} else {
// Activity创建时，添加TextureView的监听，TextureView创建完成后就可以开启camera就行了
mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
}
}
@Override
public void onPause() {
// 关闭camera，关闭后台线程
closeCamera();
stopBackgroundThread();
super.onPause();
}
@Override
public void onClick(View view) {
switch (view.getId()) {
case R.id.video_record:
if (!mRecorderHelper.isRecording()) {
startRecord();
}
break;
case R.id.video_stop:
if (mRecorderHelper.isRecording()) {
stopRecord();
}
break;
}
}
private void startBackgroundThread() {
mBackgroundThread = new HandlerThread("CameraBackground");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
}
private void stopBackgroundThread() {
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
mBackgroundThread = null;
mBackgroundHandler = null;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void openCamera() {
// 设置预览大小、方向/角度
mTextureHelper.configPreview(mTextureView, mTextureView.getWidth(), mTextureView.getHeight());
// 开启后置摄像头
mCameraHelper.openCamera(mCameraHelper.getBackCameraId(), new CameraDevice.StateCallback() {
@Override
public void onOpened(@NonNull CameraDevice cameraDevice) {
// 如果openCamera()方法的第三个参数指定了handler，那么下面的代码就会在该handler所在线程中执行，如果不指定就在openCamera()方法所在线程执行
mCameraDevice = cameraDevice;
startPreviewSession();
if (null != mTextureView) {
mTextureHelper.configPreview(mTextureView, mTextureView.getWidth(), mTextureView.getHeight());
}
}
@Override
public void onDisconnected(@NonNull CameraDevice cameraDevice) {
cameraDevice.close();
mCameraDevice = null;
}
@Override
public void onError(@NonNull CameraDevice cameraDevice, int error) {
cameraDevice.close();
mCameraDevice = null;
finish();
}
}, null);
}
private void addTextureViewSurface() {
// 获取TextureView中的surface，添加到request中、添加到surfaceList中
Surface previewSurface = mTextureHelper.getSurface(mTextureView);
if (null != previewSurface) {
mRequest.addTarget(previewSurface);
mSurfaceList.add(previewSurface);
}
}
private void addRecorderSurface() {
// 获取MediaRecorder中的surface，添加到request中、添加到surfaceList中
Surface recorderSurface = mRecorderHelper.getSurface();
if (null != recorderSurface) {
mRequest.addTarget(recorderSurface);
mSurfaceList.add(recorderSurface);
}
}
private void closeCamera() {
// 关闭camera预览，关闭MediaRecorder
closePreviewSession();
if (null != mCameraDevice) {
mCameraDevice.close();
mCameraDevice = null;
}
mRecorderHelper.release();
}
private void startPreviewSession() {
if (null == mCameraDevice || !mTextureView.isAvailable()) {
return;
}
try {
// 创建新的会话前，关闭以前的会话
closePreviewSession();
// 创建预览会话请求
mSurfaceList.clear();
mRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
addTextureViewSurface();
// 启动会话
// 参数1：camera捕捉到的画面分别输出到surfaceList的各个surface中;
// 参数2：会话状态监听;
// 参数3：监听器中的方法会在指定的线程里调用，通过一个handler对象来指定线程;
mCameraDevice.createCaptureSession(mSurfaceList, new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
mSession = session;
updatePreview();
}
@Override
public void onConfigureFailed(@NonNull CameraCaptureSession session) {
}
@Override
public void onClosed(@NonNull CameraCaptureSession session) {
super.onClosed(session);
}
}, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
private void startRecordSession() {
if (null == mCameraDevice || !mTextureView.isAvailable()) {
return;
}
try {
closePreviewSession();
// 创建录像会话请求
mSurfaceList.clear();
mRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
addTextureViewSurface();
addRecorderSurface();
// 启动会话。可以看出跟上面的"预览session"是一样的，只是surfaceList多加了一个
mCameraDevice.createCaptureSession(mSurfaceList, new CameraCaptureSession.StateCallback() {
@Override
public void onConfigured(@NonNull CameraCaptureSession session) {
mSession = session;
updatePreview();
runOnUiThread(new Runnable() {
@Override
public void run() {
mRecorderHelper.start();
}
});
}
@Override
public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
Toast.makeText(VideoActivity.this, "Failed", Toast.LENGTH_SHORT).show();
}
}, mBackgroundHandler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
private void updatePreview() {
if (null == mCameraDevice) {
return;
}
try {
mRequest.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
// 这个接口是预览。作用是把camera捕捉到的画面输出到surfaceList中的各个surface上，每隔一定时间重复一次
mSession.setRepeatingRequest(mRequest.build(), null, mBackgroundHandler);
// 这个接口是拍照。由于拍照需要获得图像数据，所以这里需要实现CaptureCallback，在回调里获得图像数据
// mSession.capture(CaptureRequest request, CaptureCallback listener, Handler handler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
private void closePreviewSession() {
if (mSession != null) {
try {
mSession.stopRepeating();
mSession.abortCaptures();
mSession.close();
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
}
private void startRecord() {
// 设置Recorder配置，启动录像会话
int sensorOrientation = mCameraHelper.getSensorOrientation(mCameraHelper.getBackCameraId());
int displayRotation = getWindowManager().getDefaultDisplay().getRotation();
mRecorderHelper.configRecorder(sensorOrientation, displayRotation);
startRecordSession();
}
private void stopRecord() {
// 关闭录像会话，停止录像，重新进入预览
mRecorderHelper.stop();
startPreviewSession();
}
// TextureView状态监听
private TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener() {
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
openCamera();
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
mTextureHelper.configPreview(mTextureView, width, height);
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
return true;
}
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
}
};
}
接下来是三个helper类的代码，首先是TextureHelper类：
public class TextureHelper {
private Activity mActivity;
// 这里只是展示用法，实际开发中需要根据摄像头的支持size来取
private Size mPreviewSize = new Size(960, 720);
public TextureHelper(Activity activity) {
mActivity = activity;
}
// 配置预览图的大小、方向/角度
public void configPreview(TextureView textureView, int targetWidth, int targetHeight) {
int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation();
Matrix matrix = new Matrix();
RectF viewRect = new RectF(0, 0, targetWidth, targetHeight);
RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
float centerX = viewRect.centerX();
float centerY = viewRect.centerY();
if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
float scale = Math.max((float) targetHeight / mPreviewSize.getHeight(), (float) targetWidth / mPreviewSize.getWidth());
matrix.postScale(scale, scale, centerX, centerY);
matrix.postRotate(90 * (rotation - 2), centerX, centerY);
}
textureView.setTransform(matrix);
}
// 根据TextureView和预览size，获取surface
public Surface getSurface(TextureView textureView) {
SurfaceTexture texture = textureView.getSurfaceTexture();
assert texture != null;
texture.setDefaultBufferSize(960, 720);
return new Surface(texture);
}
}
然后是CameraHelper类：
public class CameraHelper {
private CameraManager mManager;
private String mBackCameraId;
public CameraHelper(Context context) {
mManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
}
public String getBackCameraId() {
if(!TextUtils.isEmpty(mBackCameraId)){
return mBackCameraId;
}
try {
String[] ids = mManager.getCameraIdList();
for (String cameraId : ids) {
CameraCharacteristics characteristics = mManager.getCameraCharacteristics(cameraId);
Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
// 根据摄像头的朝向判断是否是后置摄像头
if (null != facing && CameraMetadata.LENS_FACING_BACK == facing) {
mBackCameraId = cameraId;
return cameraId;
}
}
} catch (CameraAccessException e) {
e.printStackTrace();
}
return "";
}
public int getSensorOrientation(String cameraId) {
try {
CameraCharacteristics characteristics = mManager.getCameraCharacteristics(cameraId);
return characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
} catch (CameraAccessException e) {
e.printStackTrace();
}
return -1;
}
public Size[] getSupportSize(String cameraId, Class klass) {
try {
CameraCharacteristics characteristics = mManager.getCameraCharacteristics(cameraId);
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
if (null != map) {
return map.getOutputSizes(klass);
// map.getOutputSizes(MediaRecorder.class);// 支持的录像视频size
// map.getOutputSizes(MediaRecorder.class);// 支持的录像视频size
// map.getOutputSizes(ImageReader.class);// 支持的拍照照片size
}
} catch (CameraAccessException e) {
e.printStackTrace();
}
return null;
}
// 注意，camera、recorder权限都是隐私权限，6.0以后需要动态权限配置
@SuppressLint("MissingPermission")
public void openCamera(String cameraId, CameraDevice.StateCallback callback, Handler handler) {
try {
mManager.openCamera(cameraId,callback,handler);
} catch (CameraAccessException e) {
e.printStackTrace();
}
}
}
最后是RecorderHelper类：
public class RecorderHelper {
private Context mContext;
private MediaRecorder mRecorder;
private String mPath;
private boolean hasPrepared;
private static final int SENSOR_DEFAULT_DEGREES = 90;
private static final int SENSOR_INVERSE_DEGREES = 270;
private static final SparseIntArray DEFAULT_ORIENTATIONS = new SparseIntArray();
private static final SparseIntArray INVERSE_ORIENTATIONS = new SparseIntArray();
static {
DEFAULT_ORIENTATIONS.append(Surface.ROTATION_0, 90);
DEFAULT_ORIENTATIONS.append(Surface.ROTATION_90, 0);
DEFAULT_ORIENTATIONS.append(Surface.ROTATION_180, 270);
DEFAULT_ORIENTATIONS.append(Surface.ROTATION_270, 180);
}
static {
INVERSE_ORIENTATIONS.append(Surface.ROTATION_0, 270);
INVERSE_ORIENTATIONS.append(Surface.ROTATION_90, 180);
INVERSE_ORIENTATIONS.append(Surface.ROTATION_180, 90);
INVERSE_ORIENTATIONS.append(Surface.ROTATION_270, 0);
}
public RecorderHelper(Context context) {
mContext = context;
}
private void initIfNecessary() {
if (null == mRecorder) {
mRecorder = new MediaRecorder();
}
}
private void updatePath() {
final File dir = mContext.getExternalFilesDir(null);
if (null != dir) {
mPath = dir.getAbsolutePath() + "/" + System.currentTimeMillis() + ".mp4";
}
}
public void configRecorder(int sensorOrientation, int displayRotation) {
initIfNecessary();
// 设置存储路径
updatePath();
if (TextUtils.isEmpty(mPath)) {
return;
}
mRecorder.setOutputFile(mPath);
// 设置音、视频采集源
mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
// 设置音、视频编码格式，以及文件封装格式。设置顺序必须跟下面一模一样，否则报错
mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
// 设置比特率、帧率和分辨率
mRecorder.setVideoEncodingBitRate(800 * 800);
mRecorder.setVideoFrameRate(30);
// 这里只是展示用法，实际开发中需要根据摄像头的支持size来取
mRecorder.setVideoSize(960, 720);
// 根据camera方向和屏幕角度，设置录制视频的角度补偿
if (SENSOR_DEFAULT_DEGREES == sensorOrientation) {
mRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(displayRotation));
} else if (SENSOR_INVERSE_DEGREES == sensorOrientation) {
mRecorder.setOrientationHint(INVERSE_ORIENTATIONS.get(displayRotation));
}
try {
mRecorder.prepare();
} catch (IOException e) {
e.printStackTrace();
}
hasPrepared = true;
}
public void start() {
if (hasPrepared) {
mRecorder.start();
}
}
// 停止之后，MediaRecorder不需要置空，下次使用时需要重新配置
public void stop() {
if (hasPrepared) {
mRecorder.stop();
mRecorder.reset();
hasPrepared = false;
}
}
public void release() {
if (null != mRecorder) {
mRecorder.release();
hasPrepared = false;
mRecorder = null;
}
}
public Surface getSurface() {
return hasPrepared ? mRecorder.getSurface() : null;
}
public boolean isRecording() {
return hasPrepared;
}
}
