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

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持华域联盟。