package cn.jiguang.imui.chatinput.camera; /** * Reference from google sample: android-Camera2Basic */ import android.Manifest; import android.app.Activity; import android.content.Context; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.ImageFormat; import android.graphics.Matrix; import android.graphics.Point; import android.graphics.RectF; import android.graphics.SurfaceTexture; import android.hardware.camera2.CameraAccessException; import android.hardware.camera2.CameraCaptureSession; import android.hardware.camera2.CameraCharacteristics; import android.hardware.camera2.CameraDevice; import android.hardware.camera2.CameraManager; import android.hardware.camera2.CameraMetadata; import android.hardware.camera2.CaptureRequest; import android.hardware.camera2.CaptureResult; import android.hardware.camera2.TotalCaptureResult; import android.hardware.camera2.params.StreamConfigurationMap; import android.media.Image; import android.media.ImageReader; import android.media.MediaRecorder; import android.os.Build; import android.os.Environment; import android.os.Handler; import android.os.HandlerThread; import android.support.annotation.NonNull; import android.support.annotation.RequiresApi; import android.support.v4.app.ActivityCompat; import android.util.DisplayMetrics; import android.util.Log; import android.util.Size; import android.util.SparseIntArray; import android.view.Gravity; import android.view.Surface; import android.view.TextureView; import android.view.ViewGroup; import android.widget.FrameLayout; import android.widget.Toast; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.List; import java.util.Locale; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import cn.jiguang.imui.messagelist.R; import cn.jiguang.imui.chatinput.listener.CameraEventListener; import cn.jiguang.imui.chatinput.listener.OnCameraCallbackListener; @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) public class CameraNew implements CameraSupport { private static final String TAG = "CameraNew"; /** * Camera state: Showing camera preview. */ private static final int STATE_PREVIEW = 0; /** * Camera state: Waiting for the focus to be locked. */ private static final int STATE_WAITING_LOCK = 1; /** * Camera state: Waiting for the exposure to be precapture state. */ private static final int STATE_WAITING_PRECAPTURE = 2; /** * Camera state: Waiting for the exposure state to be something other than precapture. */ private static final int STATE_WAITING_NON_PRECAPTURE = 3; /** * Camera state: Picture was taken. */ private static final int STATE_PICTURE_TAKEN = 4; /** * Max preview width that is guaranteed by Camera2 API */ private static final int MAX_PREVIEW_WIDTH = 1920; /** * Max preview height that is guaranteed by Camera2 API */ private static final int MAX_PREVIEW_HEIGHT = 1080; private Context mContext; private CameraDevice mCamera; private CameraManager mManager; private boolean mSupportAutoFocus = false; /** * Output file of picture */ private File mPhoto; /** * Output directory of picture */ private static File mDir; /** * An {@link TextureView} for camera preview. */ private TextureView mTextureView; private String mCameraId; private Size mPreviewSize; /** * A {@link CameraCaptureSession } for camera preview. */ private CameraCaptureSession mCaptureSession; /** * {@link CaptureRequest.Builder} for the camera preview */ private CaptureRequest.Builder mPreviewRequestBuilder; /** * {@link CaptureRequest} generated by {@link #mPreviewRequestBuilder} */ private CaptureRequest mPreviewRequest; /** * The current state of camera state for taking pictures. * * @see #mCaptureCallback */ private int mState = STATE_PREVIEW; /** * A {@link Semaphore} to prevent the app from exiting before closing the camera. */ private Semaphore mCameraOpenCloseLock = new Semaphore(1); /** * Whether the current camera device supports Flash or not. */ private boolean mFlashSupported; private HandlerThread mBackgroundThread; private Handler mBackgroundHandler; private int mWidth; private int mHeight; private float mCameraQuality; private static SparseIntArray ORIENTATIONS = new SparseIntArray(); private static SparseIntArray INVERSE_ORIENTATIONS = new SparseIntArray(); private static boolean mIsTakingPicture = false; /** * An {@link ImageReader} that handles still image capture. */ private ImageReader mImageReader; /** * This a callback object for the {@link ImageReader}. "onImageAvailable" will be called when a * still image is ready to be saved. */ private final ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() { @Override public void onImageAvailable(ImageReader reader) { mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage())); } }; static { ORIENTATIONS.append(Surface.ROTATION_0, 0); ORIENTATIONS.append(Surface.ROTATION_90, 90); ORIENTATIONS.append(Surface.ROTATION_180, 180); ORIENTATIONS.append(Surface.ROTATION_270, 270); } static { INVERSE_ORIENTATIONS.append(Surface.ROTATION_0, 270); INVERSE_ORIENTATIONS.append(Surface.ROTATION_90, 180); INVERSE_ORIENTATIONS.append(Surface.ROTATION_180, 90); INVERSE_ORIENTATIONS.append(Surface.ROTATION_270, 0); } private static OnCameraCallbackListener mOnCameraCallbackListener; private static CameraEventListener mCameraEventListener; private Size mVideoSize; private MediaRecorder mMediaRecorder; private String mNextVideoAbsolutePath; private Integer mSensorOrientation; private static boolean mIsFacingBack = true; /** * A {@link CameraCaptureSession.CaptureCallback} that handles events related to JPEG capture. */ private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() { private void process(CaptureResult result) { switch (mState) { case STATE_PREVIEW: { // We have nothing to do when the camera preview is working normally. break; } case STATE_WAITING_LOCK: { Integer afState = result.get(CaptureResult.CONTROL_AF_STATE); if (afState == null) { captureStillPicture(); } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED == afState || CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) { // CONTROL_AE_STATE can be null on some devices Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) { mState = STATE_PICTURE_TAKEN; captureStillPicture(); } else { runPrecaptureSequence(); } // 前置摄像头并且不支持自动对焦 } else if (!mIsFacingBack && afState == CaptureResult.CONTROL_AF_STATE_INACTIVE) { mState = STATE_PICTURE_TAKEN; captureStillPicture(); } break; } case STATE_WAITING_PRECAPTURE: { // CONTROL_AE_STATE can be null on some devices Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE || aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) { mState = STATE_WAITING_NON_PRECAPTURE; } break; } case STATE_WAITING_NON_PRECAPTURE: { // CONTROL_AE_STATE can be null on some devices Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) { mState = STATE_PICTURE_TAKEN; captureStillPicture(); } break; } } } @Override public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) { process(partialResult); } @Override public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) { process(result); } }; public CameraNew(final Context context, TextureView textureView) { this.mContext = context; this.mManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE); this.mTextureView = textureView; initPhotoDir(); } private void initPhotoDir() { String path = mContext.getFilesDir().getAbsolutePath() + "/photo"; mDir = new File(path); if (!mDir.exists()) { mDir.mkdirs(); } } @Override public void setCameraCallbackListener(OnCameraCallbackListener listener) { mOnCameraCallbackListener = listener; } @Override public void setCameraEventListener(CameraEventListener listener) { mCameraEventListener = listener; } @Override public CameraSupport open(final int cameraId, int width, int height, boolean isFacingBack,float cameraQuality) { if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(mContext, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { Log.e("CameraNew", "Lacking privileges to access aurora_menuitem_camera service, please request permission first."); return null; } mWidth = width; mHeight = height; mIsFacingBack = isFacingBack; mCameraId = cameraId + ""; mCameraQuality = cameraQuality; startBackgroundThread(); setUpCameraOutputs(width, height); configureTransform(width, height); try { if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { throw new RuntimeException("Time out waiting to lock camera opening."); } mManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler); } catch (Exception e) { // TODO handle e.printStackTrace(); } return this; } /** * {@link CameraDevice.StateCallback} is called when {@link CameraDevice} changes its state. */ CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() { @Override public void onOpened(@NonNull CameraDevice camera) { // This method is called when the camera is opened. We start camera preview here. mCameraOpenCloseLock.release(); mCamera = camera; createCameraPreviewSession(); } @Override public void onDisconnected(@NonNull CameraDevice camera) { mCameraOpenCloseLock.release(); mCamera.close(); mCamera = null; } @Override public void onError(@NonNull CameraDevice camera, int error) { mCameraOpenCloseLock.release(); if (mCamera != null) { mCamera.close(); mCamera = null; } } }; private Surface mSurface; /** * Creates a new {@link CameraCaptureSession} for camera preview. */ private void createCameraPreviewSession() { try { SurfaceTexture texture = mTextureView.getSurfaceTexture(); assert texture != null; // We configure the size of default buffer to be the size of camera preview we want. texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); // This is the output Surface we need to start preview. if(mSurface != null){ mSurface.release(); } mSurface = new Surface(texture); // We set up a CaptureRequest.Builder with the output Surface. mPreviewRequestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); mPreviewRequestBuilder.addTarget(mSurface); // Here, we create a CameraCaptureSession for camera preview. mCamera.createCaptureSession(Arrays.asList(mSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) { // The camera is already closed if (null == mCamera) { return; } // When the session is ready, we start displaying the preview. mCaptureSession = cameraCaptureSession; updatePreview(); } @Override public void onConfigureFailed( @NonNull CameraCaptureSession cameraCaptureSession) { Toast.makeText(mContext, "Camera configuration change", Toast.LENGTH_SHORT).show(); } }, null ); } catch (CameraAccessException e) { e.printStackTrace(); } } private Size chooseVideoSize(Size[] choices) { for (Size option : choices) { if (option.getWidth() == option.getHeight() * 4 / 3 && option.getWidth() <= 1080) { return option; } } Log.e(TAG, "Can't find any suitable video size"); return choices[choices.length - 1]; } /** * Given {@code choices} of {@code Size}s supported by a camera, choose the smallest one that * is at least as large as the respective texture view size, and that is at most as large as the * respective max size, and whose aspect ratio matches with the specified value. If such size * doesn't exist, choose the largest one that is at most as large as the respective max size, * and whose aspect ratio matches with the specified value. * * @param sizes The list of sizes that the camera supports for the intended output * class * @param w The width of the texture view relative to sensor coordinate * @param h The height of the texture view relative to sensor coordinate * @return The optimal {@code Size}, or an arbitrary one if none were big enough */ private static Size chooseOptimalSize(Size[] sizes, int w, int h) { // List collectorSizes = new ArrayList<>(); // for (Size option : sizes) { // if (option.getWidth() == width && option.getHeight() == height) { // return option; // } // if (width > height) { // if (option.getWidth() > width && option.getHeight() > height) { // collectorSizes.add(option); // } // } else { // if (option.getHeight() > width && option.getWidth() > height) { // collectorSizes.add(option); // } // } // } // if (collectorSizes.size() > 0) { // return Collections.min(collectorSizes, new Comparator() { // @Override // public int compare(Size s1, Size s2) { // return Long.signum(s1.getWidth() * s1.getHeight() - s2.getWidth() * s2.getHeight()); // } // }); // } // return sizes[0]; final double ASPECT_TOLERANCE = 0.1; double targetRatio = (double) w / h; if (sizes == null) return null; Size optimalSize = null; double minDiff = Double.MAX_VALUE; int targetHeight = h; // Try to find an size match aspect ratio and size for (Size size : sizes) { double ratio = (double) size.getWidth() / size.getHeight(); if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue; if (Math.abs(size.getHeight() - targetHeight) < minDiff) { optimalSize = size; minDiff = Math.abs(size.getHeight() - targetHeight); } } // Cannot find the one match the aspect ratio, ignore the requirement if (optimalSize == null) { minDiff = Double.MAX_VALUE; for (Size size : sizes) { if (Math.abs(size.getHeight() - targetHeight) < minDiff) { optimalSize = size; minDiff = Math.abs(size.getHeight() - targetHeight); } } } return optimalSize; } private void updatePreview() { if (null == mCamera) { Log.e("CameraNew", "Update preview error, return"); } try { // Auto focus should be continuous for camera preview. mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); // Flash is automatically enabled when necessary. setAutoFlash(mPreviewRequestBuilder); // Finally, we start displaying the camera preview. mPreviewRequest = mPreviewRequestBuilder.build(); mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } public void startBackgroundThread() { mBackgroundThread = new HandlerThread("Camera Background"); mBackgroundThread.start(); mBackgroundHandler = new Handler(mBackgroundThread.getLooper()); } public void stopBackgroundThread() { if (mBackgroundThread != null) { mBackgroundThread.quitSafely(); try { mBackgroundThread.join(); mBackgroundThread = null; mBackgroundHandler = null; } catch (InterruptedException e) { e.printStackTrace(); } } } private int sensorToDeviceRotation(CameraCharacteristics characteristics, int deviceOrientation) { mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); deviceOrientation = ORIENTATIONS.get(deviceOrientation); return (mSensorOrientation + deviceOrientation + 360) % 360; } @Override public void release() { try { mCameraOpenCloseLock.acquire(); closePreviewSession(); if (mCamera != null) { mCamera.close(); mCamera = null; } if (mMediaRecorder != null) { mMediaRecorder.release(); mMediaRecorder = null; } if (null != mImageReader) { mImageReader.close(); mImageReader = null; } if(mSurface != null){ mSurface.release(); mSurface = null ; } } catch (InterruptedException e) { e.printStackTrace(); throw new RuntimeException("Interrupted while trying to lock camera closing.", e); } finally { mCameraOpenCloseLock.release(); } stopBackgroundThread(); } private void setUpCameraOutputs(int width, int height) { try { Activity activity = (Activity) mContext; final String[] ids = mManager.getCameraIdList(); if (ids.length == 0) { // No camera throw new RuntimeException("No camera available."); } CameraCharacteristics mCameraCharacteristic = mManager.getCameraCharacteristics(mCameraId); StreamConfigurationMap map = mCameraCharacteristic.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); assert map != null; mVideoSize = chooseVideoSize(map.getOutputSizes(MediaRecorder.class)); // For still image captures, we use the largest available size. Size largest = Collections.max( Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea()); mImageReader = ImageReader.newInstance((int)(largest.getWidth()*mCameraQuality), (int)(largest.getHeight()*mCameraQuality), ImageFormat.JPEG, /*maxImages*/1); mImageReader.setOnImageAvailableListener( mOnImageAvailableListener, mBackgroundHandler); // Find out if we need to swap dimension to get the preview size relative to sensor // coordinate. int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation(); //noinspection ConstantConditions mSensorOrientation = mCameraCharacteristic.get(CameraCharacteristics.SENSOR_ORIENTATION); boolean swappedDimensions = false; switch (displayRotation) { case Surface.ROTATION_0: case Surface.ROTATION_180: if (mSensorOrientation == 90 || mSensorOrientation == 270) { swappedDimensions = true; } break; case Surface.ROTATION_90: case Surface.ROTATION_270: if (mSensorOrientation == 0 || mSensorOrientation == 180) { swappedDimensions = true; } break; default: Log.e(TAG, "Display rotation is invalid: " + displayRotation); } Point displaySize = new Point(); activity.getWindowManager().getDefaultDisplay().getSize(displaySize); int rotatedPreviewWidth = width; int rotatedPreviewHeight = height; if (swappedDimensions) { rotatedPreviewWidth = height; rotatedPreviewHeight = width; } // Danger, W.R.! Attempting to use too large a preview size could exceed the camera // bus' bandwidth limitation, resulting in gorgeous previews but the storage of // garbage capture data. mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), rotatedPreviewWidth, rotatedPreviewHeight); // TODO // We fit the aspect ratio of TextureView to the size of preview we picked. // float w; // float h; // int orientation = activity.getResources().getConfiguration().orientation; // if (orientation == Configuration.ORIENTATION_LANDSCAPE) { // w = mPreviewSize.getWidth(); // h = mPreviewSize.getHeight(); // } else { // w = mPreviewSize.getHeight(); // h = mPreviewSize.getWidth(); // } // // FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams((int) (height * (w / h)), height); // layoutParams.gravity = Gravity.CENTER; // mTextureView.setLayoutParams(layoutParams); // Check if the flash is supported. Boolean available = mCameraCharacteristic.get(CameraCharacteristics.FLASH_INFO_AVAILABLE); mFlashSupported = available == null ? false : available; } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Compares two {@code Size}s based on their areas. */ static class CompareSizesByArea implements Comparator { @Override public int compare(Size lhs, Size rhs) { // We cast here to ensure the multiplications won't overflow return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight()); } } private void configureTransform(int viewWidth, int viewHeight) { Activity activity = (Activity) mContext; if (null == mTextureView || null == mPreviewSize || null == activity) { return; } int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); Matrix matrix = new Matrix(); RectF viewRect = new RectF(0, 0, viewWidth, viewHeight); RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth()); float centerX = viewRect.centerX(); float centerY = viewRect.centerY(); if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) { bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY()); matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL); float scale = Math.max( (float) viewHeight / mPreviewSize.getHeight(), (float) viewWidth / mPreviewSize.getWidth()); matrix.postScale(scale, scale, centerX, centerY); matrix.postRotate(90 * (rotation - 2), centerX, centerY); } else if (Surface.ROTATION_180 == rotation) { matrix.postRotate(180, centerX, centerY); } mTextureView.setTransform(matrix); } @Override public void takePicture() { if(mIsTakingPicture){ Log.i(TAG,"Is taking picture now,please wait."); return; } mIsTakingPicture = true; lockFocus(); } /** * Lock the focus as the first step for a still image capture. */ private void lockFocus() { try { // This is how to tell the camera to lock focus. mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START); // Tell #mCaptureCallback to wait for the lock. mState = STATE_WAITING_LOCK; mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Run the precapture sequence for capturing a still image. This method should be called when * we get a response in {@link #mCaptureCallback} from {@link #lockFocus()}. */ private void runPrecaptureSequence() { try { // This is how to tell the camera to trigger. mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START); // Tell #mCaptureCallback to wait for the precapture sequence to be set. mState = STATE_WAITING_PRECAPTURE; mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Capture a still picture. This method should be called when we get a response in * {@link #mCaptureCallback} from both {@link #lockFocus()}. */ private void captureStillPicture() { try { final Activity activity = (Activity) mContext; if (null == activity || null == mCamera) { return; } // This is the CaptureRequest.Builder that we use to take a picture. final CaptureRequest.Builder captureBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE); captureBuilder.addTarget(mImageReader.getSurface()); // Use the same AE and AF modes as the preview. captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); setAutoFlash(captureBuilder); // Orientation // captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, // mCameraCharacteristic.get(CameraCharacteristics.SENSOR_ORIENTATION)); CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() { @Override public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) { unlockFocus(); } }; mCaptureSession.stopRepeating(); mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null); } catch (CameraAccessException e) { e.printStackTrace(); } } /** * Unlock the focus. This method should be called when still image capture sequence is * finished. */ private void unlockFocus() { try { // Reset the auto-focus trigger mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL); setAutoFlash(mPreviewRequestBuilder); if(mCaptureSession != null ){ boolean reprocessable = true; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { reprocessable = mCaptureSession.isReprocessable(); } if(!reprocessable){ return; } mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler); // After this, the camera will go back to the normal state of preview. mState = STATE_PREVIEW; mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, mBackgroundHandler); } } catch (CameraAccessException e) { e.printStackTrace(); } } private void setAutoFlash(CaptureRequest.Builder requestBuilder) { if (mFlashSupported) { requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH); } } /** * Saves a JPEG {@link Image} into the specified {@link File}. */ private static class ImageSaver implements Runnable { /** * The JPEG image */ private final Image mImage; /** * The file we save the image into. */ private File mPhoto, mLastPhoto; public ImageSaver(Image image) { mImage = image; } @Override public void run() { ByteBuffer buffer = mImage.getPlanes()[0].getBuffer(); byte[] bytes = new byte[buffer.remaining()]; buffer.get(bytes); FileOutputStream output = null; try { mPhoto = new File(mDir, new SimpleDateFormat("yyyy-MM-dd-HHmmss", Locale.getDefault()).format(new Date()) + ".jpg"); output = new FileOutputStream(mPhoto); // 前置摄像头水平翻转照片 Matrix matrix = new Matrix(); Bitmap rotateBmp; Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length); int w = bmp.getWidth(); int h = bmp.getHeight(); if (!mIsFacingBack) { matrix.postScale(-1, 1); matrix.postRotate(90); rotateBmp = Bitmap.createBitmap(bmp, 0, 0, w, h, matrix, true); } else { matrix.postRotate(90); rotateBmp = Bitmap.createBitmap(bmp, 0, 0, w, h, matrix, true); } rotateBmp.compress(Bitmap.CompressFormat.JPEG, 100, output); if (mOnCameraCallbackListener != null) { if(mLastPhoto != null && mLastPhoto.getAbsolutePath().equals(mPhoto.getAbsolutePath())) // Forbid repeat return; Log.i(TAG,"Saved capture into "+ mPhoto.getAbsolutePath()); mOnCameraCallbackListener.onTakePictureCompleted(mPhoto.getAbsolutePath()); mLastPhoto = mPhoto; mIsTakingPicture = false; } if (mCameraEventListener != null) { mCameraEventListener.onFinishTakePicture(); } } catch (IOException e) { e.printStackTrace(); } finally { mImage.close(); if (null != output) { try { output.close(); } catch (IOException e) { e.printStackTrace(); } } } } } public void setUpMediaRecorder() { if (null == mContext) { return; } Activity activity = (Activity) mContext; mMediaRecorder = new MediaRecorder(); mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE); mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264); mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight()); mMediaRecorder.setVideoFrameRate(30); mNextVideoAbsolutePath = getVideoFilePath(activity); mMediaRecorder.setOutputFile(mNextVideoAbsolutePath); mMediaRecorder.setVideoEncodingBitRate(10000000); int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); DisplayMetrics dm = new DisplayMetrics(); activity.getWindowManager().getDefaultDisplay().getMetrics(dm); int width = dm.widthPixels; int height = dm.heightPixels; // if the device's natural orientation is portrait: if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && height > width || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && width > height) { switch (rotation) { case Surface.ROTATION_0: Log.e(TAG, "Rotation 0"); if (mIsFacingBack) { mMediaRecorder.setOrientationHint(90); } else { mMediaRecorder.setOrientationHint(270); } break; case Surface.ROTATION_90: Log.e(TAG, "Rotation 90"); if (mIsFacingBack) { mMediaRecorder.setOrientationHint(0); } else { mMediaRecorder.setOrientationHint(180); } break; case Surface.ROTATION_180: Log.e(TAG, "Rotation 180"); if (mIsFacingBack) { mMediaRecorder.setOrientationHint(270); } else { mMediaRecorder.setOrientationHint(90); } break; case Surface.ROTATION_270: Log.e(TAG, "Rotation 270"); if (mIsFacingBack) { mMediaRecorder.setOrientationHint(180); } else { mMediaRecorder.setOrientationHint(0); } break; default: Log.e(TAG, "Unknown screen orientation. Defaulting to " + "portrait."); if (mIsFacingBack) { mMediaRecorder.setOrientationHint(90); } else { mMediaRecorder.setOrientationHint(270); } break; } } try { mMediaRecorder.prepare(); } catch (IOException e) { e.printStackTrace(); } } @Override public void startRecordingVideo() { if (null == mCamera || !mTextureView.isAvailable() || mPreviewSize == null) { return; } try { if (mOnCameraCallbackListener != null) { mOnCameraCallbackListener.onStartVideoRecord(); } closePreviewSession(); setUpMediaRecorder(); SurfaceTexture texture = mTextureView.getSurfaceTexture(); assert texture != null; texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); mPreviewRequestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_RECORD); List surfaces = new ArrayList<>(); // Set up Surface for aurora_menuitem_camera preview Surface previewSurface = new Surface(texture); surfaces.add(previewSurface); mPreviewRequestBuilder.addTarget(previewSurface); // set up Surface for MediaRecorder Surface recorderSurface = mMediaRecorder.getSurface(); surfaces.add(recorderSurface); mPreviewRequestBuilder.addTarget(recorderSurface); mCamera.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() { @Override public void onConfigured(CameraCaptureSession cameraCaptureSession) { mCaptureSession = cameraCaptureSession; updatePreview(); mMediaRecorder.start(); } @Override public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) { Toast.makeText(mContext, mContext.getString(R.string.record_video_failed), Toast.LENGTH_SHORT).show(); } }, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } @Override public void cancelRecordingVideo() { resetRecordState(); startPreview(); if (mNextVideoAbsolutePath != null) { File file = new File(mNextVideoAbsolutePath); if (file.exists() && file.isFile()) { file.delete(); } } if (mOnCameraCallbackListener != null) { mOnCameraCallbackListener.onCancelVideoRecord(); } } @Override public String finishRecordingVideo() { resetRecordState(); if (mOnCameraCallbackListener != null) { mOnCameraCallbackListener.onFinishVideoRecord(mNextVideoAbsolutePath); } return mNextVideoAbsolutePath; } private void resetRecordState() { try { if (mCaptureSession != null) { mCaptureSession.stopRepeating(); mCaptureSession.abortCaptures(); } if (mMediaRecorder != null) { mMediaRecorder.stop(); mMediaRecorder.reset(); } } catch (CameraAccessException e) { e.printStackTrace(); } catch (IllegalStateException e) { e.printStackTrace(); } catch (RuntimeException e) { e.printStackTrace(); Toast.makeText(mContext, mContext.getString(R.string.record_video_failed), Toast.LENGTH_SHORT).show(); } } private String getVideoFilePath(Context context) { String fileDir = Environment.getExternalStorageDirectory() + "/video"; File destDir = new File(fileDir); if (!destDir.exists()) { destDir.mkdirs(); } return destDir.getAbsolutePath() + "/" + System.currentTimeMillis() + ".mp4"; } private void closePreviewSession() { if (mCaptureSession != null) { mCaptureSession.close(); mCaptureSession = null; } } private void startPreview() { if (null == mCamera || !mTextureView.isAvailable() || null == mPreviewSize) { return; } try { SurfaceTexture texture = mTextureView.getSurfaceTexture(); assert texture != null; texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); mPreviewRequestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); Surface previewSurface = new Surface(texture); mPreviewRequestBuilder.addTarget(previewSurface); mCamera.createCaptureSession(Arrays.asList(previewSurface), new CameraCaptureSession.StateCallback() { @Override public void onConfigured(CameraCaptureSession cameraCaptureSession) { mCaptureSession = cameraCaptureSession; updatePreview(); } @Override public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) { Log.e(TAG, "Preview failed"); } }, mBackgroundHandler); } catch (CameraAccessException e) { e.printStackTrace(); } } }