Android仿最新微信相机功能

最近在开发即时通讯这个模块的时候使用到了自定义的相机，需求与微信一样，要求相机能长按和轻点，当时在网上找自定义相机的资源，很少，所以，我在这里把我的一些开发经验贴出来，供大家学习。

大致完成的功能如下：

• 长按拍摄视频，轻点拍照

• 前后摄像头的切换

• 闪光的的开启，关闭，自动

• 图片的压缩

• 自动聚焦，手动聚焦
  

效果图如下：

相关代码如下：

package com.ses.im.app.chat.newcamera;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.PointF;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.ses.im.app.chat.R;

import java.io.File;
import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Subscriber;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
*
* 拍摄界面
*/
public class CameraActivity extends AppCompatActivity implements View.OnClickListener {
/**
* 获取相册
*/
public static final int REQUEST_PHOTO = 1;
/**
* 获取视频
*/
public static final int REQUEST_VIDEO = 2;
/**
* 最小录制时间
*/
private static final int MIN_RECORD_TIME = 1 * 1000;
/**
* 最长录制时间
*/
private static final int MAX_RECORD_TIME = 15 * 1000;
/**
* 刷新进度的间隔时间
*/
private static final int PLUSH_PROGRESS = 100;

private Context mContext;
/**
* TextureView
*/
private TextureView mTextureView;
/**
* 带手势识别
*/
private CameraView mCameraView;
/**
* 录制按钮
*/
private CameraProgressBar mProgressbar;
/**
* 顶部像机设置
*/
private RelativeLayout rl_camera;
/**
* 关闭,选择,前后置
*/
private ImageView iv_close, iv_facing;
private RelativeLayout iv_choice;
private RelativeLayout cancel;
/**
* 闪光
*/
private TextView tv_flash;
/**
* camera manager
*/
private CameraManager cameraManager;
/**
* player manager
*/
private MediaPlayerManager playerManager;
/**
* true代表视频录制,否则拍照
*/
private boolean isSupportRecord;
/**
* 视频录制地址
*/
private String recorderPath;
/**
* 图片地址
*/
private String photoPath;
/**
* 录制视频的时间,毫秒
*/
private int recordSecond;
/**
* 获取照片订阅, 进度订阅
*/
private Subscription takePhotoSubscription, progressSubscription;
/**
* 是否正在录制
*/
private boolean isRecording;

/**
* 是否为点了拍摄状态(没有拍照预览的状态)
*/
private boolean isPhotoTakingState;

public static void lanuchForPhoto(Activity context) {
Intent intent = new Intent(context, CameraActivity.class);
context.startActivityForResult(intent, REQUEST_PHOTO);
}

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mContext = this;
setContentView(R.layout.activity_camera);
initView();
initDatas();
}

private void initView() {
mTextureView = (TextureView) findViewById(R.id.mTextureView);
mCameraView = (CameraView) findViewById(R.id.mCameraView);
mProgressbar = (CameraProgressBar) findViewById(R.id.mProgressbar);
rl_camera = (RelativeLayout) findViewById(R.id.rl_camera);
iv_close = (ImageView) findViewById(R.id.iv_close);
iv_close.setOnClickListener(this);
iv_choice = (RelativeLayout) findViewById(R.id.iv_choice);
iv_choice.setOnClickListener(this);
iv_close.setOnClickListener(this);
iv_facing = (ImageView) findViewById(R.id.iv_facing);
iv_facing.setOnClickListener(this);
iv_close.setOnClickListener(this);
tv_flash = (TextView) findViewById(R.id.tv_flash);
tv_flash.setOnClickListener(this);
cancel= (RelativeLayout) findViewById(R.id.cancel);
cancel.setOnClickListener(this);
}

protected void initDatas() {
cameraManager = CameraManager.getInstance(getApplication());
playerManager = MediaPlayerManager.getInstance(getApplication());
cameraManager.setCameraType(isSupportRecord ? 1 : 0);

tv_flash.setVisibility(cameraManager.isSupportFlashCamera() ? View.VISIBLE : View.GONE);
setCameraFlashState();
iv_facing.setVisibility(cameraManager.isSupportFrontCamera() ? View.VISIBLE : View.GONE);
rl_camera.setVisibility(cameraManager.isSupportFlashCamera()
 || cameraManager.isSupportFrontCamera() ? View.VISIBLE : View.GONE);

final int max = MAX_RECORD_TIME / PLUSH_PROGRESS;
mProgressbar.setMaxProgress(max);

/**
 * 拍照，拍摄按钮监听
 */
mProgressbar.setOnProgressTouchListener(new CameraProgressBar.OnProgressTouchListener() {
 @Override
 public void onClick(CameraProgressBar progressBar) {
 cameraManager.takePhoto(callback);
 isSupportRecord = false;
 }

@Override
 public void onLongClick(CameraProgressBar progressBar) {
 isSupportRecord = true;
 cameraManager.setCameraType(1);
 rl_camera.setVisibility(View.GONE);
 recorderPath = FileUtils.getUploadVideoFile(mContext);
 cameraManager.startMediaRecord1(recorderPath);
 isRecording = true;
 progressSubscription = Observable.interval(100, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread()).take(max).subscribe(new Subscriber<Long>() {
  @Override
  public void onCompleted() {
  stopRecorder(true);
  }

@Override
  public void onError(Throwable e) {

}

@Override
  public void onNext(Long aLong) {
  mProgressbar.setProgress(mProgressbar.getProgress() + 1);
  }
 });
 }

@Override
 public void onZoom(boolean zoom) {
 cameraManager.handleZoom(zoom);
 }

@Override
 public void onLongClickUp(CameraProgressBar progressBar) {
//  isSupportRecord = false;
 cameraManager.setCameraType(0);
 stopRecorder(true);
 if (progressSubscription != null) {
  progressSubscription.unsubscribe();
 }
 }

@Override
 public void onPointerDown(float rawX, float rawY) {
 if (mTextureView != null) {
  mCameraView.setFoucsPoint(new PointF(rawX, rawY));
 }
 }
});

/**
 *点击预览图聚焦
 */
mCameraView.setOnViewTouchListener(new CameraView.OnViewTouchListener() {
 @Override
 public void handleFocus(float x, float y) {
 cameraManager.handleFocusMetering(x, y);
 }

@Override
 public void handleZoom(boolean zoom) {
 cameraManager.handleZoom(zoom);
 }
});
}

/**
* 设置闪光状态
*/
private void setCameraFlashState() {
int flashState = cameraManager.getCameraFlash();
switch (flashState) {
 case 0: //自动
 tv_flash.setSelected(true);
 tv_flash.setText("自动");
 break;
 case 1://open
 tv_flash.setSelected(true);
 tv_flash.setText("开启");
 break;
 case 2: //close
 tv_flash.setSelected(false);
 tv_flash.setText("关闭");
 break;
}
}

/**
* 是否显示录制按钮
* @param isShow
*/
private void setTakeButtonShow(boolean isShow) {
if (isShow) {
 mProgressbar.setVisibility(View.VISIBLE);
 rl_camera.setVisibility(cameraManager.isSupportFlashCamera()
  || cameraManager.isSupportFrontCamera() ? View.VISIBLE : View.GONE);
} else {
 mProgressbar.setVisibility(View.GONE);
 rl_camera.setVisibility(View.GONE);
}
}

/**
* 停止拍摄
*/
private void stopRecorder(boolean play) {
isRecording = false;
cameraManager.stopMediaRecord();
recordSecond = mProgressbar.getProgress() * PLUSH_PROGRESS;//录制多少毫秒
mProgressbar.reset();
if (recordSecond < MIN_RECORD_TIME) {//小于最小录制时间作废
 if (recorderPath != null) {
 FileUtils.delteFiles(new File(recorderPath));
 recorderPath = null;
 recordSecond = 0;
 }
 setTakeButtonShow(true);
} else if (play && mTextureView != null && mTextureView.isAvailable()){
 setTakeButtonShow(false);
 mProgressbar.setVisibility(View.GONE);
 iv_choice.setVisibility(View.VISIBLE);
 cancel.setVisibility(View.VISIBLE);
 iv_close.setVisibility(View.GONE);
 cameraManager.closeCamera();
 playerManager.playMedia(new Surface(mTextureView.getSurfaceTexture()), recorderPath);
}
}

@Override
protected void onResume() {
super.onResume();
if (mTextureView.isAvailable()) {
 if (recorderPath != null) {//优先播放视频
 iv_choice.setVisibility(View.VISIBLE);
 setTakeButtonShow(false);
 playerManager.playMedia(new Surface(mTextureView.getSurfaceTexture()), recorderPath);
 } else {
 iv_choice.setVisibility(View.GONE);
 setTakeButtonShow(true);
 cameraManager.openCamera(mTextureView.getSurfaceTexture(),
  mTextureView.getWidth(), mTextureView.getHeight());
 }
} else {
 mTextureView.setSurfaceTextureListener(listener);
}
}

@Override
protected void onPause() {
if (progressSubscription != null) {
 progressSubscription.unsubscribe();
}
if (takePhotoSubscription != null) {
 takePhotoSubscription.unsubscribe();
}
if (isRecording) {
 stopRecorder(false);
}
cameraManager.closeCamera();
playerManager.stopMedia();
super.onPause();
}

@Override
protected void onDestroy() {
mCameraView.removeOnZoomListener();
super.onDestroy();
}

@Override
public void onClick(View v) {
int i = v.getId();
if (i == R.id.iv_close) {
//  if (recorderPath != null) {//有拍摄好的正在播放,重新拍摄
//  FileUtils.delteFiles(new File(recorderPath));
//  recorderPath = null;
//  recordSecond = 0;
//  playerManager.stopMedia();
//  setTakeButtonShow(true);
//  iv_choice.setVisibility(View.GONE);
//  cameraManager.openCamera(mTextureView.getSurfaceTexture(), mTextureView.getWidth(), mTextureView.getHeight());
//  } else if (isPhotoTakingState) {
//  isPhotoTakingState = false;
//  iv_choice.setVisibility(View.GONE);
//  setTakeButtonShow(true);
//  cameraManager.restartPreview();
//  } else {
 finish();
//  }

} else if (i == R.id.iv_choice) {//拿到图片或视频路径
 Intent intent=new Intent();
 if(isSupportRecord){
 intent.putExtra("videopath", recorderPath);
 setResult(3, intent);
 finish();
 }else{
 intent.putExtra("videopath", photoPath);
 setResult(3, intent);
 finish();
 }

} else if (i == R.id.tv_flash) {
 cameraManager.changeCameraFlash(mTextureView.getSurfaceTexture(),
  mTextureView.getWidth(), mTextureView.getHeight());
 setCameraFlashState();

} else if (i == R.id.iv_facing) {
 cameraManager.changeCameraFacing(mTextureView.getSurfaceTexture(),
  mTextureView.getWidth(), mTextureView.getHeight());

}else if(i == R.id.cancel){
 if (recorderPath != null) {//有拍摄好的正在播放,重新拍摄
 FileUtils.delteFiles(new File(recorderPath));
 recorderPath = null;
 recordSecond = 0;
 playerManager.stopMedia();
 setTakeButtonShow(true);
 iv_choice.setVisibility(View.GONE);
 cancel.setVisibility(View.GONE);
 iv_close.setVisibility(View.VISIBLE);

cameraManager.openCamera(mTextureView.getSurfaceTexture(), mTextureView.getWidth(), mTextureView.getHeight());
 } else if (isPhotoTakingState) {
 isPhotoTakingState = false;
 iv_choice.setVisibility(View.GONE);
 cancel.setVisibility(View.GONE);
 iv_close.setVisibility(View.VISIBLE);
 setTakeButtonShow(true);
 cameraManager.restartPreview();
 }
}
}

/**
* camera回调监听
*/
private TextureView.SurfaceTextureListener listener = new TextureView.SurfaceTextureListener() {
@Override
public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
 if (recorderPath != null) {
 iv_choice.setVisibility(View.VISIBLE);
 setTakeButtonShow(false);
 playerManager.playMedia(new Surface(texture), recorderPath);
 } else {
 setTakeButtonShow(true);
 iv_choice.setVisibility(View.GONE);
 cameraManager.openCamera(texture, width, height);
 }
}

@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
}

@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
 return true;
}

@Override
public void onSurfaceTextureUpdated(SurfaceTexture texture) {
}
};

private Camera.PictureCallback callback = new Camera.PictureCallback() {
@Override
public void onPictureTaken(final byte[] data, Camera camera) {
 setTakeButtonShow(false);
 takePhotoSubscription = Observable.create(new Observable.OnSubscribe<Boolean>() {
 @Override
 public void call(Subscriber<? super Boolean> subscriber) {
  if (!subscriber.isUnsubscribed()) {
  photoPath = FileUtils.getUploadPhotoFile(mContext);
  isPhotoTakingState = FileUtils.savePhoto(photoPath, data, cameraManager.isCameraFrontFacing());
  subscriber.onNext(isPhotoTakingState);
  }
 }
 }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<Boolean>() {
 @Override
 public void onCompleted() {

}

@Override
 public void onError(Throwable e) {

}

@Override
 public void onNext(Boolean aBoolean) {
  if (aBoolean != null && aBoolean) {
  iv_choice.setVisibility(View.VISIBLE);
  cancel.setVisibility(View.VISIBLE);
  iv_close.setVisibility(View.GONE);
  } else {
  setTakeButtonShow(true);
  }
 }
 });
}
};

}

相机管理类：

package com.ses.im.app.chat.newcamera;

import android.app.Application;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.media.CamcorderProfile;
import android.media.MediaRecorder;
import android.util.Log;
import android.widget.Toast;

import com.ses.im.app.chat.util.AppConfig;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
*
* 相机管理类
*/

public final class CameraManager {

private Application context;
/**
* camera
*/
private Camera mCamera;
private Camera.Parameters mParameters;
/**
* 视频录制
*/
private MediaRecorder mMediaRecorder;
/**
* 相机闪光状态
*/
private int cameraFlash;
/**
* 前后置状态
*/
private int cameraFacing = Camera.CameraInfo.CAMERA_FACING_BACK;
/**
* 是否支持前置摄像,是否支持闪光
*/
private boolean isSupportFrontCamera, isSupportFlashCamera;
/**
* 录制视频的相关参数
*/
private CamcorderProfile mProfile;
/**
* 0为拍照, 1为录像
*/
private int cameraType;

private CameraManager(Application context) {
this.context = context;
isSupportFrontCamera = CameraUtils.isSupportFrontCamera();
isSupportFlashCamera = CameraUtils.isSupportFlashCamera(context);
if (isSupportFrontCamera) {
 cameraFacing = CameraUtils.getCameraFacing(context, Camera.CameraInfo.CAMERA_FACING_BACK);
}
if (isSupportFlashCamera) {
 cameraFlash = CameraUtils.getCameraFlash(context);
}
}

private static CameraManager INSTANCE;

public static CameraManager getInstance(Application context) {
if (INSTANCE == null) {
 synchronized (CameraManager.class) {
 if (INSTANCE == null) {
  INSTANCE = new CameraManager(context);
 }
 }
}
return INSTANCE;
}

/**
* 打开camera
*/
public void openCamera(SurfaceTexture surfaceTexture, int width, int height) {
if (mCamera == null) {
 mCamera = Camera.open(cameraFacing);//打开当前选中的摄像头
 mProfile = CamcorderProfile.get(cameraFacing, CamcorderProfile.QUALITY_HIGH);
 try {
 mCamera.setDisplayOrientation(90);//默认竖直拍照
 mCamera.setPreviewTexture(surfaceTexture);
 initCameraParameters(cameraFacing, width, height);
 mCamera.startPreview();
 } catch (Exception e) {
 LogUtils.i(e);
 if (mCamera != null) {
  mCamera.release();
  mCamera = null;
 }
 }
}
}

/**
* 开启预览,前提是camera初始化了
*/
public void restartPreview() {
if (mCamera == null) return;
try {
 Camera.Parameters parameters = mCamera.getParameters();
 int zoom = parameters.getZoom();
 if (zoom > 0) {
 parameters.setZoom(0);
 mCamera.setParameters(parameters);
 }
 mCamera.startPreview();
} catch (Exception e) {
 LogUtils.i(e);
 if (mCamera != null) {
 mCamera.release();
 mCamera = null;
 }
}
}

private void initCameraParameters(int cameraId, int width, int height) {
Camera.Parameters parameters = mCamera.getParameters();
if (cameraId == Camera.CameraInfo.CAMERA_FACING_BACK) {
 List<String> focusModes = parameters.getSupportedFocusModes();
 if (focusModes != null) {
 if (cameraType == 0) {
  if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
  parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
  }
 } else {
  if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
  parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
  }
 }
 }
}
parameters.setRotation(90);//设置旋转代码,
switch (cameraFlash) {
 case 0:
 parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
 break;
 case 1:
 parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
 break;
 case 2:
 parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
 break;
}
List<Camera.Size> pictureSizes = parameters.getSupportedPictureSizes();
List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
if (!isEmpty(pictureSizes) && !isEmpty(previewSizes)) {
 /**
 for (Camera.Size size : pictureSizes) {
 LogUtils.i("pictureSize " + size.width + " " + size.height);
 }
 for (Camera.Size size : pictureSizes) {
 LogUtils.i("previewSize " + size.width + " " + size.height);
 }*/
 Camera.Size optimalPicSize = getOptimalCameraSize(pictureSizes, width, height);
 Camera.Size optimalPreSize = getOptimalCameraSize(previewSizes, width, height);
//  Camera.Size optimalPicSize = getOptimalSize(pictureSizes, width, height);
//  Camera.Size optimalPreSize = getOptimalSize(previewSizes, width, height);
 LogUtils.i("TextureSize "+width+" "+height+" optimalSize pic " + optimalPicSize.width + " " + optimalPicSize.height + " pre " + optimalPreSize.width + " " + optimalPreSize.height);
 parameters.setPictureSize(optimalPicSize.width, optimalPicSize.height);
 parameters.setPreviewSize(optimalPreSize.width, optimalPreSize.height);
 mProfile.videoFrameWidth = optimalPreSize.width;
 mProfile.videoFrameHeight = optimalPreSize.height;
 mProfile.videoBitRate = 5000000;//此参数主要决定视频拍出大小
}
mCamera.setParameters(parameters);
}

/**
* 释放摄像头
*/
public void closeCamera() {
this.cameraType = 0;
if (mCamera != null) {
 try {
 mCamera.stopPreview();
 mCamera.release();
 mCamera = null;
 } catch (Exception e) {
 LogUtils.i(e);
 if (mCamera != null) {
  mCamera.release();
  mCamera = null;
 }
 }
}
}

/**
* 集合不为空
*
* @param list
* @param <E>
* @return
*/
private <E> boolean isEmpty(List<E> list) {
return list == null || list.isEmpty();
}

/**
*
* @param sizes 相机support参数
* @param w
* @param h
* @return 最佳Camera size
*/
private Camera.Size getOptimalCameraSize(List<Camera.Size> sizes, int w, int h){
sortCameraSize(sizes);
int position = binarySearch(sizes, w*h);
return sizes.get(position);
}

/**
*
* @param sizes
* @param targetNum 要比较的数
* @return
*/
private int binarySearch(List<Camera.Size> sizes,int targetNum){
int targetIndex;
int left = 0,right;
int length = sizes.size();
for (right = length-1;left != right;){
 int midIndex = (right + left)/2;
 int mid = right - left;
 Camera.Size size = sizes.get(midIndex);
 int midValue = size.width * size.height;
 if (targetNum == midValue){
 return midIndex;
 }
 if (targetNum > midValue){
 left = midIndex;
 }else {
 right = midIndex;
 }

if (mid <= 1){
 break;
 }
}
Camera.Size rightSize = sizes.get(right);
Camera.Size leftSize = sizes.get(left);
int rightNum = rightSize.width * rightSize.height;
int leftNum = leftSize.width * leftSize.height;
targetIndex = Math.abs((rightNum - leftNum)/2) > Math.abs(rightNum - targetNum) ? right : left;
return targetIndex;
}

/**
* 排序
* @param previewSizes
*/
private void sortCameraSize(List<Camera.Size> previewSizes){
Collections.sort(previewSizes, new Comparator<Camera.Size>() {
 @Override
 public int compare(Camera.Size size1, Camera.Size size2) {
 int compareHeight = size1.height - size2.height;
 if (compareHeight == 0){
  return (size1.width == size2.width ? 0 :(size1.width > size2.width ? 1:-1));
 }
 return compareHeight;
 }
});
}

/**
* 获取最佳预览相机Size参数
*
* @return
*/
private Camera.Size getOptimalSize(List<Camera.Size> sizes, int w, int h) {
Camera.Size optimalSize = null;
float targetRadio = h / (float) w;
float optimalDif = Float.MAX_VALUE; //最匹配的比例
int optimalMaxDif = Integer.MAX_VALUE;//最优的最大值差距
for (Camera.Size size : sizes) {
 float newOptimal = size.width / (float) size.height;
 float newDiff = Math.abs(newOptimal - targetRadio);
 if (newDiff < optimalDif) { //更好的尺寸
 optimalDif = newDiff;
 optimalSize = size;
 optimalMaxDif = Math.abs(h - size.width);
 } else if (newDiff == optimalDif) {//更好的尺寸
 int newOptimalMaxDif = Math.abs(h - size.width);
 if (newOptimalMaxDif < optimalMaxDif) {
  optimalDif = newDiff;
  optimalSize = size;
  optimalMaxDif = newOptimalMaxDif;
 }
 }
}
return optimalSize;
}

/**
* 缩放
* @param isZoomIn
*/
public void handleZoom(boolean isZoomIn) {
if (mCamera == null) return;
Camera.Parameters params = mCamera.getParameters();
if (params == null) return;
if (params.isZoomSupported()) {
 int maxZoom = params.getMaxZoom();
 int zoom = params.getZoom();
 if (isZoomIn && zoom < maxZoom) {
 zoom++;
 } else if (zoom > 0) {
 zoom--;
 }
 params.setZoom(zoom);
 mCamera.setParameters(params);
} else {
 LogUtils.i("zoom not supported");
}
}

/**
* 更换前后置摄像
*/
public void changeCameraFacing(SurfaceTexture surfaceTexture, int width, int height) {
if(isSupportFrontCamera) {
 Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
 int cameraCount = Camera.getNumberOfCameras();//得到摄像头的个数
 for(int i = 0; i < cameraCount; i++) {
 Camera.getCameraInfo(i, cameraInfo);//得到每一个摄像头的信息
 if(cameraFacing == Camera.CameraInfo.CAMERA_FACING_FRONT) { //现在是后置，变更为前置
  if(cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {//代表摄像头的方位为前置
  closeCamera();
  cameraFacing = Camera.CameraInfo.CAMERA_FACING_BACK;
  CameraUtils.setCameraFacing(context, cameraFacing);
  openCamera(surfaceTexture, width, height);
  break;
  }
 } else {//现在是前置， 变更为后置
  if(cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {//代表摄像头的方位
  closeCamera();
  cameraFacing = Camera.CameraInfo.CAMERA_FACING_FRONT;
  CameraUtils.setCameraFacing(context, cameraFacing);
  openCamera(surfaceTexture, width, height);
  break;
  }
 }
 }
} else { //不支持摄像机
 Toast.makeText(context, "您的手机不支持前置摄像", Toast.LENGTH_SHORT).show();
}
}

/**
* 改变闪光状态
*/
public void changeCameraFlash(SurfaceTexture surfaceTexture, int width, int height) {
if (!isSupportFlashCamera) {
 Toast.makeText(context, "您的手机不支闪光", Toast.LENGTH_SHORT).show();
 return;
}
if(mCamera != null) {
 Camera.Parameters parameters = mCamera.getParameters();
 if(parameters != null) {
 int newState = cameraFlash;
 switch (cameraFlash) {
  case 0: //自动
  parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
  newState = 1;
  break;
  case 1://open
  parameters.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
  newState = 2;
  break;
  case 2: //close
  parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
  newState = 0;
  break;
 }
 cameraFlash = newState;
 CameraUtils.setCameraFlash(context, newState);
 mCamera.setParameters(parameters);
 }
}
}

/**
* 拍照
*/
public void takePhoto(Camera.PictureCallback callback) {
if (mCamera != null) {
 try {
 mCamera.takePicture(null, null, callback);
 } catch(Exception e) {
 Toast.makeText(context, "拍摄失败", Toast.LENGTH_SHORT).show();
 }
}
}

/**
* 开始录制视频
*/
// public void startMediaRecord(String savePath) {
// if (mCamera == null || mProfile == null) return;
// mCamera.unlock();
// if (mMediaRecorder == null) {
//  mMediaRecorder = new MediaRecorder();
// }
// if (isCameraFrontFacing()) {
//  mMediaRecorder.setOrientationHint(270);
//  Log.i("wujie","front");
// }else
// {
//  Log.i("wujie","back");
//  mMediaRecorder.setOrientationHint(90);
// }
// mMediaRecorder.reset();
// mMediaRecorder.setCamera(mCamera);
// mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
// mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
// mMediaRecorder.setProfile(mProfile);
// mMediaRecorder.setOutputFile(savePath);
// try {
//  mMediaRecorder.prepare();
//  mMediaRecorder.start();
// } catch (Exception e) {
//  e.printStackTrace();
//
// }
// }
/**
* 开始录制视频
*/
public void startMediaRecord1(String savePath) {
if (mCamera == null) {
 return;
}
if (mMediaRecorder == null) {
 mMediaRecorder = new MediaRecorder();
} else {
 mMediaRecorder.reset();
}

if (isCameraFrontFacing()) {
 mMediaRecorder.setOrientationHint(270);
 Log.i("wujie","front");
}else
{
 Log.i("wujie","back");
 mMediaRecorder.setOrientationHint(90);
}
mParameters = mCamera.getParameters();
mCamera.unlock();
mMediaRecorder.setCamera(mCamera);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
// 设置录像参数
mMediaRecorder.setProfile(CamcorderProfile.get(AppConfig.VIDEOSIZE));
try {
 mMediaRecorder.setOutputFile(savePath);
 mMediaRecorder.prepare();
 mMediaRecorder.start();
} catch (Exception e) {

}

}

/**
* 停止录制
*/
public void stopMediaRecord() {
this.cameraType = 0;
stopRecorder();
releaseMediaRecorder();
}

private void releaseMediaRecorder() {
if (mMediaRecorder != null) {
 try {
 mMediaRecorder.reset();
 mMediaRecorder.release();
 mMediaRecorder = null;
 mCamera.lock();
 } catch (Exception e) {
 e.printStackTrace();
 LogUtils.i(e);
 }
}
}

private void stopRecorder() {
if (mMediaRecorder != null) {
 try {
 mMediaRecorder.stop();
 } catch (Exception e) {
 e.printStackTrace();
 LogUtils.i(e);
 }

}
}

public boolean isSupportFrontCamera() {
return isSupportFrontCamera;
}

public boolean isSupportFlashCamera() {
return isSupportFlashCamera;
}

public boolean isCameraFrontFacing() {
return cameraFacing == Camera.CameraInfo.CAMERA_FACING_FRONT;
}

/**
* 设置对焦类型
* @param cameraType
*/
public void setCameraType(int cameraType) {
this.cameraType = cameraType;
if (mCamera != null) {//拍摄视频时
 if (cameraFacing == Camera.CameraInfo.CAMERA_FACING_BACK) {
 Camera.Parameters parameters = mCamera.getParameters();
 List<String> focusModes = parameters.getSupportedFocusModes();
 if (focusModes != null) {
  if (cameraType == 0) {
  if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
   parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
  }
  } else {
  if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
   parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
  }
  }
 }
 }
}
}

public int getCameraFlash() {
return cameraFlash;
}

/**
* 对焦
* @param x
* @param y
*/
public void handleFocusMetering(float x, float y) {
if(mCamera!=null){
 Camera.Parameters params = mCamera.getParameters();
 Camera.Size previewSize = params.getPreviewSize();
 Rect focusRect = calculateTapArea(x, y, 1f, previewSize);
 Rect meteringRect = calculateTapArea(x, y, 1.5f, previewSize);
 mCamera.cancelAutoFocus();

if (params.getMaxNumFocusAreas() > 0) {
 List<Camera.Area> focusAreas = new ArrayList<>();
 focusAreas.add(new Camera.Area(focusRect, 1000));
 params.setFocusAreas(focusAreas);
 } else {
 LogUtils.i("focus areas not supported");
 }
 if (params.getMaxNumMeteringAreas() > 0) {
 List<Camera.Area> meteringAreas = new ArrayList<>();
 meteringAreas.add(new Camera.Area(meteringRect, 1000));
 params.setMeteringAreas(meteringAreas);
 } else {
 LogUtils.i("metering areas not supported");
 }
 final String currentFocusMode = params.getFocusMode();
 params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
 mCamera.setParameters(params);

mCamera.autoFocus(new Camera.AutoFocusCallback() {
 @Override
 public void onAutoFocus(boolean success, Camera camera) {
  Camera.Parameters params = camera.getParameters();
  params.setFocusMode(currentFocusMode);
  camera.setParameters(params);
 }
 });
}

}

private Rect calculateTapArea(float x, float y, float coefficient, Camera.Size previewSize) {
float focusAreaSize = 300;
int areaSize = Float.valueOf(focusAreaSize * coefficient).intValue();
int centerX = (int) (x / previewSize.width - 1000);
int centerY = (int) (y / previewSize.height - 1000);
int left = clamp(centerX - areaSize / 2, -1000, 1000);
int top = clamp(centerY - areaSize / 2, -1000, 1000);
RectF rectF = new RectF(left, top, left + areaSize, top + areaSize);
return new Rect(Math.round(rectF.left), Math.round(rectF.top), Math.round(rectF.right), Math.round(rectF.bottom));
}

private int clamp(int x, int min, int max) {
if (x > max) {
 return max;
}
if (x < min) {
 return min;
}
return x;
}

}

自定义拍摄，拍照按钮：

package com.ses.im.app.chat.newcamera;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.os.Bundle;
import android.os.Parcelable;
import android.support.v4.view.GestureDetectorCompat;
import android.support.v4.view.MotionEventCompat;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;

import com.ses.im.app.chat.R;

/**
* 自定义拍照，拍摄按钮
*/

public class CameraProgressBar extends View {
/**
* 默认缩小值
*/
public static final float DEF_SCALE = 0.75F;
/**
* 默认缩小值
*/
private float scale = DEF_SCALE;

/**
* 内圆颜色
*/
private int innerColor = Color.GRAY;
/**
* 背景颜色
*/
private int backgroundColor = Color.WHITE;
/**
* 外圆颜色
*/
private int outerColor = Color.parseColor("#e9e9e9");
/**
* 进度颜色
*/
private int progressColor = Color.parseColor("#0ebffa");
/**
* 进度宽
*/
private int progressWidth = 15;
/**
* 内圆宽度
*/
private int innerRadio = 10;
/**
* 进度
*/
private int progress;
/**
* 最大进度
*/
private int maxProgress = 100;
/**
* paint
*/
private Paint backgroundPaint, progressPaint, innerPaint;
/**
* 圆的中心坐标点, 进度百分比
*/
private float sweepAngle;
/**
* 手识识别
*/
private GestureDetectorCompat mDetector;
/**
* 是否为长按录制
*/
private boolean isLongClick;
/**
* 是否产生滑动
*/
private boolean isBeingDrag;
/**
* 滑动单位
*/
private int mTouchSlop;
/**
* 记录上一次Y轴坐标点
*/
private float mLastY;
/**
* 是否长按放大
*/
private boolean isLongScale;

public CameraProgressBar(Context context) {
super(context);
init(context, null);
}

public CameraProgressBar(Context context, AttributeSet attrs) {
super(context, attrs);
init(context, attrs);
}

public CameraProgressBar(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context, attrs);
}

private void init(Context context, AttributeSet attrs) {
mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
if (attrs != null) {
 TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CameraProgressBar);
 innerColor = a.getColor(R.styleable.CameraProgressBar_innerColor, innerColor);
 outerColor = a.getColor(R.styleable.CameraProgressBar_outerColor, outerColor);
 progressColor = a.getColor(R.styleable.CameraProgressBar_progressColor, progressColor);
 innerRadio = a.getDimensionPixelOffset(R.styleable.CameraProgressBar_innerRadio, innerRadio);
 progressWidth = a.getDimensionPixelOffset(R.styleable.CameraProgressBar_progressWidth, progressWidth);
 progress = a.getInt(R.styleable.CameraProgressBar_progresscamera, progress);
 scale = a.getFloat(R.styleable.CameraProgressBar_scale, scale);
 isLongScale = a.getBoolean(R.styleable.CameraProgressBar_isLongScale, isLongScale);
 maxProgress = a.getInt(R.styleable.CameraProgressBar_maxProgress, maxProgress);
 a.recycle();
}
backgroundPaint = new Paint();
backgroundPaint.setAntiAlias(true);
backgroundPaint.setColor(backgroundColor);

progressPaint = new Paint();
progressPaint.setAntiAlias(true);
progressPaint.setStrokeWidth(progressWidth);
progressPaint.setStyle(Paint.Style.STROKE);

innerPaint = new Paint();
innerPaint.setAntiAlias(true);
innerPaint.setStrokeWidth(innerRadio);
innerPaint.setStyle(Paint.Style.STROKE);

sweepAngle = ((float) progress / maxProgress) * 360;

mDetector = new GestureDetectorCompat(context, new GestureDetector.SimpleOnGestureListener() {
 @Override
 public boolean onSingleTapConfirmed(MotionEvent e) {
 isLongClick = false;
 if (CameraProgressBar.this.listener != null) {
  CameraProgressBar.this.listener.onClick(CameraProgressBar.this);
 }
 return super.onSingleTapConfirmed(e);
 }

@Override
 public void onLongPress(MotionEvent e) {
 isLongClick = true;
 postInvalidate();
 mLastY = e.getY();
 if (CameraProgressBar.this.listener != null) {
  CameraProgressBar.this.listener.onLongClick(CameraProgressBar.this);
 }
 }
});
mDetector.setIsLongpressEnabled(true);
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
if (width > height) {
 setMeasuredDimension(height, height);
} else {
 setMeasuredDimension(width, width);
}
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
int width = getWidth();
float circle = width / 2.0f;

if (/*isLongScale && */!isLongClick) {
 canvas.scale(scale, scale, circle, circle);
}

//画内圆
float backgroundRadio = circle - progressWidth - innerRadio;
canvas.drawCircle(circle, circle, backgroundRadio, backgroundPaint);

//画内外环
float halfInnerWidth = innerRadio / 2.0f + progressWidth;
RectF innerRectF = new RectF(halfInnerWidth, halfInnerWidth, width - halfInnerWidth, width - halfInnerWidth);
canvas.drawArc(innerRectF, -90, 360, true, innerPaint);

progressPaint.setColor(outerColor);
float halfOuterWidth = progressWidth / 2.0f;
RectF outerRectF = new RectF(halfOuterWidth, halfOuterWidth, getWidth() - halfOuterWidth, getWidth() - halfOuterWidth);
canvas.drawArc(outerRectF, -90, 360, true, progressPaint);

progressPaint.setColor(progressColor);
canvas.drawArc(outerRectF, -90, sweepAngle, false, progressPaint);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
if (!isLongScale) {
 return super.onTouchEvent(event);
}
this.mDetector.onTouchEvent(event);
switch(MotionEventCompat.getActionMasked(event)) {
 case MotionEvent.ACTION_DOWN:
 isLongClick = false;
 isBeingDrag = false;
 break;
 case MotionEvent.ACTION_MOVE:
 if (isLongClick) {
  float y = event.getY();
  if (isBeingDrag) {
  boolean isUpScroll = y < mLastY;
  mLastY = y;
  if (this.listener != null) {
   this.listener.onZoom(isUpScroll);
  }
  } else {
  isBeingDrag = Math.abs(y - mLastY) > mTouchSlop;
  }
 }
 break;
 case MotionEvent.ACTION_UP:
 case MotionEvent.ACTION_CANCEL:
 isBeingDrag = false;
 if (isLongClick) {
  isLongClick = false;
  postInvalidate();
  if (this.listener != null) {
  this.listener.onLongClickUp(this);
  }
 }
 break;
 case MotionEvent.ACTION_POINTER_DOWN:
 if (isLongClick) {
  if (this.listener != null) {
  this.listener.onPointerDown(event.getRawX(), event.getRawY());
  }
 }
 break;
}
return true;
}

@Override
protected Parcelable onSaveInstanceState() {
Bundle bundle = new Bundle();
Parcelable superData = super.onSaveInstanceState();
bundle.putParcelable("superData", superData);
bundle.putInt("progress", progress);
bundle.putInt("maxProgress", maxProgress);
return bundle;
}

@Override
protected void onRestoreInstanceState(Parcelable state) {
Bundle bundle = (Bundle) state;
Parcelable superData = bundle.getParcelable("superData");
progress = bundle.getInt("progress");
maxProgress = bundle.getInt("maxProgress");
super.onRestoreInstanceState(superData);
}

/**
* 设置进度
* @param progress
*/
public void setProgress(int progress) {
if (progress <= 0) progress = 0;
if (progress >= maxProgress) progress = maxProgress;
if (progress == this.progress) return;
this.progress = progress;
this.sweepAngle = ((float) progress / maxProgress) * 360;
postInvalidate();
}

/**
* 还原到初始状态
*/
public void reset() {
isLongClick = false;
this.progress = 0;
this.sweepAngle = 0;
postInvalidate();
}

public int getProgress() {
return progress;
}

public void setLongScale(boolean longScale) {
isLongScale = longScale;
}

public void setMaxProgress(int maxProgress) {
this.maxProgress = maxProgress;
}

private OnProgressTouchListener listener;

public void setOnProgressTouchListener(OnProgressTouchListener listener) {
this.listener = listener;
}

/**
* 进度触摸监听
*/
public interface OnProgressTouchListener {
/**
 * 单击
 * @param progressBar
 */
void onClick(CameraProgressBar progressBar);

/**
 * 长按
 * @param progressBar
 */
void onLongClick(CameraProgressBar progressBar);

/**
 * 移动
 * @param zoom true放大
 */
void onZoom(boolean zoom);

/**
 * 长按抬起
 * @param progressBar
 */
void onLongClickUp(CameraProgressBar progressBar);

/**
 * 触摸对焦
 * @param rawX
 * @param rawY
 */

void onPointerDown(float rawX, float rawY);
}

}

预览试图页：

package com.ses.im.app.chat.newcamera;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.support.v4.view.MotionEventCompat;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewParent;

import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Subscriber;
import rx.Subscription;

/**
* 相机预览页
*/

public class CameraView extends View {
/**
* 动画时长
*/
private static final int ANIM_MILS = 600;
/**
* 动画每多久刷新一次
*/
private static final int ANIM_UPDATE = 30;
/**
* focus paint
*/
private Paint paint, clearPaint;

private int paintColor = Color.GREEN;
/**
* 进度订阅
*/
private Subscription subscription;
/**
* focus rectf
*/
private RectF rectF = new RectF();
/**
* focus size
*/
private int focusSize = 120;

private int lineSize = focusSize / 4;
/**
* 上一次两指距离
*/
private float oldDist = 1f;
/**
* 画笔宽
*/
private float paintWidth = 6.0f;
/**
* s
*/
private float scale;

public CameraView(Context context) {
super(context);
init();
}

public CameraView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}

public CameraView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}

private void init() {
paint = new Paint();
paint.setColor(paintColor);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(paintWidth);

clearPaint = new Paint();
clearPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
}

@Override
public boolean onTouchEvent(MotionEvent event) {
int action = MotionEventCompat.getActionMasked(event);
if (event.getPointerCount() == 1 && action == MotionEvent.ACTION_DOWN) {
 float x = event.getX();
 float y = event.getY();
 setFoucsPoint(x, y);
 if (listener != null) {
 listener.handleFocus(x, y);
 }
} else if (event.getPointerCount() >= 2){
 switch (event.getAction() & MotionEvent.ACTION_MASK) {
 case MotionEvent.ACTION_POINTER_DOWN:
  oldDist = getFingerSpacing(event);
  break;
 case MotionEvent.ACTION_MOVE:
  float newDist = getFingerSpacing(event);
  if (newDist > oldDist) {
  if (this.listener != null) {
   this.listener.handleZoom(true);
  }
  } else if (newDist < oldDist) {
  if (this.listener != null) {
   this.listener.handleZoom(false);
  }
  }
  oldDist = newDist;
  break;
 }
}
return true;
}

/**
* 计算两点触控距离
* @param event
* @return
*/
private 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);
}

/**
* 设置坐标点(坐标为rawX, rawY)
*/
public void setFoucsPoint(PointF pointF) {
PointF transPointF = transPointF(pointF, this);
setFoucsPoint(transPointF.x, transPointF.y);
}

/**
* 设置当前触摸点
* @param x
* @param y
*/
private void setFoucsPoint(float x, float y) {
if (subscription != null) {
 subscription.unsubscribe();
}
rectF.set(x - focusSize, y - focusSize, x + focusSize, y + focusSize);
final int count = ANIM_MILS / ANIM_UPDATE;
subscription = Observable.interval(ANIM_UPDATE, TimeUnit.MILLISECONDS).take(count).subscribe(new Subscriber<Long>() {
 @Override
 public void onCompleted() {
 scale = 0;
 postInvalidate();
 }

@Override
 public void onError(Throwable e) {
 scale = 0;
 postInvalidate();
 }

@Override
 public void onNext(Long aLong) {
 float current = aLong== null ? 0 : aLong.longValue();
 scale = 1 - current / count;
 if (scale <= 0.5f) {
  scale = 0.5f;
 }
 postInvalidate();
 }
});
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (scale != 0) {
 float centerX = rectF.centerX();
 float centerY = rectF.centerY();
 canvas.scale(scale, scale, centerX, centerY);
 canvas.drawRect(rectF, paint);
 canvas.drawLine(rectF.left, centerY, rectF.left + lineSize, centerY, paint);
 canvas.drawLine(rectF.right, centerY, rectF.right - lineSize, centerY, paint);
 canvas.drawLine(centerX, rectF.top, centerX, rectF.top + lineSize, paint);
 canvas.drawLine(centerX, rectF.bottom, centerX, rectF.bottom - lineSize, paint);
}
}

@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (subscription != null) {
 subscription.unsubscribe();
}
}

/**
* 根据raw坐标转换成屏幕中所在的坐标
* @param pointF
* @return
*/
private PointF transPointF(PointF pointF, View view) {
pointF.x -= view.getX();
pointF.y -= view.getY();
ViewParent parent = view.getParent();
if (parent instanceof View) {
 return transPointF(pointF, (View) parent);
} else {
 return pointF;
}
}

private OnViewTouchListener listener;

public void setOnViewTouchListener(OnViewTouchListener listener) {
this.listener = listener;
}

public void removeOnZoomListener() {
this.listener = null;
}

public interface OnViewTouchListener {
/**
 * 对焦
 * @param x
 * @param y
 */
void handleFocus(float x, float y);

/**
 * 缩放
 * @param zoom true放大反之
 */
void handleZoom(boolean zoom);

}

}

视频管理类：

package com.ses.im.app.chat.newcamera;

import android.app.Application;
import android.media.MediaPlayer;
import android.view.Surface;

/**
* Created by you on 2016/10/24.
* 由于拍摄跟播放都关联TextureView,停止播放时要释放mediaplayer
*/

public class MediaPlayerManager {

private Application app;

private MediaPlayer mPlayer;

private MediaPlayerManager(Application app) {
this.app = app;
}

private static MediaPlayerManager INSTANCE;

public static MediaPlayerManager getInstance(Application app) {
if (INSTANCE == null) {
synchronized (CameraManager.class) {
 if (INSTANCE == null) {
 INSTANCE = new MediaPlayerManager(app);
 }
}
}
return INSTANCE;
}

/**
* 播放Media
*/
public void playMedia(Surface surface, String mediaPath) {
try {
if (mPlayer == null) {
 mPlayer = new MediaPlayer();
 mPlayer.setDataSource(mediaPath);
} else {
 if (mPlayer.isPlaying()) {
 mPlayer.stop();
 }
 mPlayer.reset();
 mPlayer.setDataSource(mediaPath);
}
mPlayer.setSurface(surface);
mPlayer.setLooping(true);
mPlayer.prepareAsync();
mPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
 @Override
 public void onPrepared(MediaPlayer mp) {
 mp.start();
 }
});
} catch (Exception e) {
LogUtils.i(e);
}
}

/**
* 停止播放Media
*/
public void stopMedia() {
try {
if (mPlayer != null) {
 if (mPlayer.isPlaying()) {
 mPlayer.stop();
 }
 mPlayer.release();
 mPlayer = null;
}
} catch (Exception e) {
LogUtils.i(e);
}
}

}

由于本人上传的demo被csdn弄丢了，想要做微信相机的可以参考陈嘉桐的demo

来源：https://blog.csdn.net/Banboofly/article/details/70159549