正文

Android仿最新微信相机功能

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0707

这篇文章主要为大家详细介绍了Android仿最新微信相机功能，长按拍摄，轻点拍照功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

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

大致完成的功能如下：

  • 长按拍摄视频，轻点拍照
  • 前后摄像头的切换
  • 闪光的的开启，关闭，自动
  • 图片的压缩
  • 自动聚焦，手动聚焦

效果图如下：

Android仿最新微信相机功能

相关代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
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);
   }
  }
  });
 }
 };
 
}

相机管理类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
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;
 }
 
}

自定义拍摄，拍照按钮：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
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);
 }
 
}

预览试图页：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
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);
 
 }
 
}

视频管理类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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