Java tutorial
package org.odk.collect.android.fragments; /* * Copyright 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import android.Manifest; import android.annotation.TargetApi; import android.app.Activity; import android.app.AlertDialog; import android.app.Dialog; import android.app.DialogFragment; import android.app.Fragment; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.pm.PackageManager; import android.graphics.Matrix; 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.params.StreamConfigurationMap; import android.media.MediaRecorder; import android.net.Uri; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.HandlerThread; import android.support.annotation.NonNull; import android.support.v13.app.FragmentCompat; import android.support.v4.app.ActivityCompat; import android.util.Size; import android.util.SparseIntArray; import android.view.LayoutInflater; import android.view.Surface; import android.view.TextureView; import android.view.View; import android.view.ViewGroup; import org.odk.collect.android.R; import org.odk.collect.android.fragments.dialogs.ErrorDialog; import org.odk.collect.android.utilities.ToastUtils; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import timber.log.Timber; /*https://github.com/googlesamples/android-Camera2Video/blob/master/Application/src/main/java/com/ example/android/camera2video/Camera2VideoFragment.java*/ @TargetApi(Build.VERSION_CODES.LOLLIPOP) public class Camera2VideoFragment extends Fragment implements View.OnClickListener, FragmentCompat.OnRequestPermissionsResultCallback { private static final int SENSOR_ORIENTATION_DEFAULT_DEGREES = 90; private static final int SENSOR_ORIENTATION_INVERSE_DEGREES = 270; private static final SparseIntArray DEFAULT_ORIENTATIONS = new SparseIntArray(); private static final SparseIntArray INVERSE_ORIENTATIONS = new SparseIntArray(); private static final int REQUEST_VIDEO_PERMISSIONS = 1; private static final String FRAGMENT_DIALOG = "dialog"; private static final String[] VIDEO_PERMISSIONS = { Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO, }; static { DEFAULT_ORIENTATIONS.append(Surface.ROTATION_0, 90); DEFAULT_ORIENTATIONS.append(Surface.ROTATION_90, 0); DEFAULT_ORIENTATIONS.append(Surface.ROTATION_180, 270); DEFAULT_ORIENTATIONS.append(Surface.ROTATION_270, 180); } static { INVERSE_ORIENTATIONS.append(Surface.ROTATION_0, 270); INVERSE_ORIENTATIONS.append(Surface.ROTATION_90, 180); INVERSE_ORIENTATIONS.append(Surface.ROTATION_180, 90); INVERSE_ORIENTATIONS.append(Surface.ROTATION_270, 0); } /** * An {@link TextureView} for camera preview. */ private TextureView textureView; /** * A reference to the opened {@link android.hardware.camera2.CameraDevice}. */ private CameraDevice cameraDevice; /** * A reference to the current {@link android.hardware.camera2.CameraCaptureSession} for * preview. */ private CameraCaptureSession previewSession; /** * {@link TextureView.SurfaceTextureListener} handles several lifecycle events on a * {@link TextureView}. */ private TextureView.SurfaceTextureListener surfaceTextureListener = new TextureView.SurfaceTextureListener() { @Override public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) { openCamera(width, height); } @Override public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) { configureTransform(width, height); } @Override public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) { return true; } @Override public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) { } }; /** * The {@link android.util.Size} of camera preview. */ private Size previewSize; /** * The {@link android.util.Size} of video recording. */ private Size videoSize; /** * MediaRecorder */ private MediaRecorder mediaRecorder; /** * Whether the app is recording video now */ private boolean isRecordingVideo; /** * An additional thread for running tasks that shouldn't block the UI. */ private HandlerThread backgroundThread; /** * A {@link Handler} for running tasks in the background. */ private Handler backgroundHandler; /** * A {@link Semaphore} to prevent the app from exiting before closing the camera. */ private Semaphore cameraOpenCloseLock = new Semaphore(1); /** * {@link CameraDevice.StateCallback} is called when {@link CameraDevice} changes its status. */ private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() { @Override public void onOpened(@NonNull CameraDevice cameraDevice) { Camera2VideoFragment.this.cameraDevice = cameraDevice; startPreview(); cameraOpenCloseLock.release(); if (null != textureView) { configureTransform(textureView.getWidth(), textureView.getHeight()); } } @Override public void onDisconnected(@NonNull CameraDevice cameraDevice) { cameraOpenCloseLock.release(); cameraDevice.close(); Camera2VideoFragment.this.cameraDevice = null; } @Override public void onError(@NonNull CameraDevice cameraDevice, int error) { cameraOpenCloseLock.release(); cameraDevice.close(); Camera2VideoFragment.this.cameraDevice = null; Activity activity = getActivity(); if (null != activity) { activity.finish(); } } }; private Integer sensorOrientation; private String nextVideoAbsolutePath; private CaptureRequest.Builder previewBuilder; public static Camera2VideoFragment newInstance() { return new Camera2VideoFragment(); } /** * In this sample, we choose a video size with 3x4 aspect ratio. Also, we don't use sizes * larger than 1080p, since MediaRecorder cannot handle such a high-resolution video. * * @param choices The list of available sizes * @return The video size */ private static Size chooseVideoSize(Size[] choices) { for (Size size : choices) { if (size.getWidth() == size.getHeight() * 4 / 3 && size.getWidth() <= 1080) { return size; } } Timber.e("Couldn't find any suitable video size"); return choices[choices.length - 1]; } /** * Given {@code choices} of {@code Size}s supported by a camera, chooses the smallest one whose * width and height are at least as large as the respective requested values, and whose aspect * ratio matches with the specified value. * * @param choices The list of sizes that the camera supports for the intended output class * @param width The minimum desired width * @param height The minimum desired height * @param aspectRatio The aspect ratio * @return The optimal {@code Size}, or an arbitrary one if none were big enough */ private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) { // Collect the supported resolutions that are at least as big as the preview Surface List<Size> bigEnough = new ArrayList<>(); int w = aspectRatio.getWidth(); int h = aspectRatio.getHeight(); for (Size option : choices) { if (option.getHeight() == option.getWidth() * h / w && option.getWidth() >= width && option.getHeight() >= height) { bigEnough.add(option); } } // Pick the smallest of those, assuming we found any if (bigEnough.size() > 0) { return Collections.min(bigEnough, new Camera2Fragment.CompareSizesByArea()); } else { Timber.e("Couldn't find any suitable preview size"); return choices[0]; } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return inflater.inflate(R.layout.fragment_camera2video, container, false); } @Override public void onViewCreated(final View view, Bundle savedInstanceState) { textureView = view.findViewById(R.id.texture); textureView.setOnClickListener(this); } @Override public void onResume() { super.onResume(); startBackgroundThread(); if (textureView.isAvailable()) { openCamera(textureView.getWidth(), textureView.getHeight()); } else { textureView.setSurfaceTextureListener(surfaceTextureListener); } } @Override public void onPause() { closeCamera(); stopBackgroundThread(); super.onPause(); } @Override public void onClick(View view) { if (view.getId() == R.id.texture) { if (isRecordingVideo) { stopRecordingVideo(); } else { startRecordingVideo(); } } } /** * Starts a background thread and its {@link Handler}. */ private void startBackgroundThread() { backgroundThread = new HandlerThread("CameraBackground"); backgroundThread.start(); backgroundHandler = new Handler(backgroundThread.getLooper()); } /** * Stops the background thread and its {@link Handler}. */ private void stopBackgroundThread() { backgroundThread.quitSafely(); try { backgroundThread.join(); backgroundThread = null; backgroundHandler = null; } catch (InterruptedException e) { Timber.e(e); } } /** * Gets whether you should show UI with rationale for requesting permissions. * * @param permissions The permissions your app wants to request. * @return Whether you can show permission rationale UI. */ private boolean shouldShowRequestPermissionRationale(String[] permissions) { for (String permission : permissions) { if (FragmentCompat.shouldShowRequestPermissionRationale(this, permission)) { return true; } } return false; } /** * Requests permissions needed for recording video. */ private void requestVideoPermissions() { if (shouldShowRequestPermissionRationale(VIDEO_PERMISSIONS)) { new ConfirmationDialog().show(getChildFragmentManager(), FRAGMENT_DIALOG); } else { FragmentCompat.requestPermissions(this, VIDEO_PERMISSIONS, REQUEST_VIDEO_PERMISSIONS); } } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { Timber.d("onRequestPermissionsResult"); if (requestCode == REQUEST_VIDEO_PERMISSIONS) { if (grantResults.length == VIDEO_PERMISSIONS.length) { for (int result : grantResults) { if (result != PackageManager.PERMISSION_GRANTED) { ErrorDialog.newInstance(getString(R.string.request_permission)) .show(getChildFragmentManager(), FRAGMENT_DIALOG); break; } } } else { ErrorDialog.newInstance(getString(R.string.request_permission)).show(getChildFragmentManager(), FRAGMENT_DIALOG); } } else { super.onRequestPermissionsResult(requestCode, permissions, grantResults); } } private boolean hasPermissionsGranted(String[] permissions) { for (String permission : permissions) { if (ActivityCompat.checkSelfPermission(getActivity(), permission) != PackageManager.PERMISSION_GRANTED) { return false; } } return true; } /** * Tries to open a {@link CameraDevice}. The result is listened by `stateCallback`. */ @SuppressWarnings("MissingPermission") private void openCamera(int width, int height) { if (!hasPermissionsGranted(VIDEO_PERMISSIONS)) { requestVideoPermissions(); return; } final Activity activity = getActivity(); if (null == activity || activity.isFinishing()) { return; } CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE); try { Timber.d("tryAcquire"); if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { throw new RuntimeException("Time out waiting to lock camera opening."); } String cameraId = null; for (String id : manager.getCameraIdList()) { CameraCharacteristics characteristics = manager.getCameraCharacteristics(id); Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING); if (facing != null && facing != CameraCharacteristics.LENS_FACING_FRONT) { continue; } // Choose the sizes for camera preview and video recording StreamConfigurationMap map = characteristics .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); if (map == null) { continue; } videoSize = chooseVideoSize(map.getOutputSizes(MediaRecorder.class)); previewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height, videoSize); cameraId = id; break; } configureTransform(width, height); mediaRecorder = new MediaRecorder(); manager.openCamera(cameraId, stateCallback, null); } catch (CameraAccessException e) { ToastUtils.showShortToast("Cannot access the camera."); activity.finish(); } catch (NullPointerException e) { // Currently an NPE is thrown when the Camera2API is used but not supported on the // device this code runs. ErrorDialog.newInstance(getString(R.string.camera_error)).show(getChildFragmentManager(), FRAGMENT_DIALOG); } catch (InterruptedException e) { throw new RuntimeException("Interrupted while trying to lock camera opening."); } } private void closeCamera() { try { cameraOpenCloseLock.acquire(); closePreviewSession(); if (null != cameraDevice) { cameraDevice.close(); cameraDevice = null; } if (null != mediaRecorder) { mediaRecorder.release(); mediaRecorder = null; } } catch (InterruptedException e) { throw new RuntimeException("Interrupted while trying to lock camera closing."); } finally { cameraOpenCloseLock.release(); } } /** * Start the camera preview. */ private void startPreview() { if (null == cameraDevice || !textureView.isAvailable() || null == previewSize) { return; } try { closePreviewSession(); SurfaceTexture texture = textureView.getSurfaceTexture(); assert texture != null; texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight()); previewBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); Surface previewSurface = new Surface(texture); previewBuilder.addTarget(previewSurface); cameraDevice.createCaptureSession(Collections.singletonList(previewSurface), new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull CameraCaptureSession session) { previewSession = session; updatePreview(); } @Override public void onConfigureFailed(@NonNull CameraCaptureSession session) { Activity activity = getActivity(); if (null != activity) { ToastUtils.showShortToast("Failed"); } } }, backgroundHandler); } catch (CameraAccessException e) { Timber.e(e); } } /** * Update the camera preview. {@link #startPreview()} needs to be called in advance. */ private void updatePreview() { if (null == cameraDevice) { return; } try { setUpCaptureRequestBuilder(previewBuilder); HandlerThread thread = new HandlerThread("CameraPreview"); thread.start(); previewSession.setRepeatingRequest(previewBuilder.build(), null, backgroundHandler); } catch (CameraAccessException e) { Timber.e(e); } } private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) { builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO); } /** * Configures the necessary {@link android.graphics.Matrix} transformation to `textureView`. * This method should not to be called until the camera preview size is determined in * openCamera, or until the size of `textureView` is fixed. * * @param viewWidth The width of `textureView` * @param viewHeight The height of `textureView` */ private void configureTransform(int viewWidth, int viewHeight) { Activity activity = getActivity(); if (null == textureView || null == previewSize || 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, previewSize.getHeight(), previewSize.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 / previewSize.getHeight(), (float) viewWidth / previewSize.getWidth()); matrix.postScale(scale, scale, centerX, centerY); matrix.postRotate(90 * (rotation - 2), centerX, centerY); } textureView.setTransform(matrix); } private void setUpMediaRecorder() throws IOException { final Activity activity = getActivity(); if (null == activity) { return; } mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); mediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE); mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); if (nextVideoAbsolutePath == null || nextVideoAbsolutePath.isEmpty()) { nextVideoAbsolutePath = getVideoFilePath(getActivity()); } mediaRecorder.setOutputFile(nextVideoAbsolutePath); mediaRecorder.setVideoEncodingBitRate(10000000); mediaRecorder.setVideoFrameRate(30); mediaRecorder.setVideoSize(videoSize.getWidth(), videoSize.getHeight()); mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264); mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); switch (sensorOrientation) { case SENSOR_ORIENTATION_DEFAULT_DEGREES: mediaRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(rotation)); break; case SENSOR_ORIENTATION_INVERSE_DEGREES: mediaRecorder.setOrientationHint(INVERSE_ORIENTATIONS.get(rotation)); break; } mediaRecorder.prepare(); } private String getVideoFilePath(Context context) { final File dir = context.getExternalFilesDir(null); return (dir == null ? "" : (dir.getAbsolutePath() + "/")) + System.currentTimeMillis() + ".mp4"; } private void startRecordingVideo() { if (null == cameraDevice || !textureView.isAvailable() || null == previewSize) { return; } try { closePreviewSession(); setUpMediaRecorder(); SurfaceTexture texture = textureView.getSurfaceTexture(); assert texture != null; texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight()); previewBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD); List<Surface> surfaces = new ArrayList<>(); // Set up Surface for the camera preview Surface previewSurface = new Surface(texture); surfaces.add(previewSurface); previewBuilder.addTarget(previewSurface); // Set up Surface for the MediaRecorder Surface recorderSurface = mediaRecorder.getSurface(); surfaces.add(recorderSurface); previewBuilder.addTarget(recorderSurface); // Start a capture session // Once the session starts, we can update the UI and start recording cameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() { @Override public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) { previewSession = cameraCaptureSession; updatePreview(); getActivity().runOnUiThread(new Runnable() { @Override public void run() { // UI isRecordingVideo = true; // Start recording mediaRecorder.start(); ToastUtils.showLongToast( getActivity().getString(R.string.stop_video_capture_instruction)); } }); } @Override public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) { Activity activity = getActivity(); if (null != activity) { ToastUtils.showShortToast("Failed"); } } }, backgroundHandler); } catch (CameraAccessException | IOException e) { Timber.e(e); } } private void closePreviewSession() { if (previewSession != null) { previewSession.close(); previewSession = null; } } private void stopRecordingVideo() { // UI isRecordingVideo = false; // Stop recording mediaRecorder.stop(); mediaRecorder.reset(); Activity activity = getActivity(); if (null != activity) { Timber.d("Video saved: " + nextVideoAbsolutePath); } Intent i = new Intent(); i.setData(Uri.fromFile(new File(nextVideoAbsolutePath))); activity.setResult(Activity.RESULT_OK, i); activity.finish(); } public static class ConfirmationDialog extends DialogFragment { @Override public Dialog onCreateDialog(Bundle savedInstanceState) { final Fragment parent = getParentFragment(); return new AlertDialog.Builder(getActivity()).setMessage(R.string.request_permission) .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { FragmentCompat.requestPermissions(parent, VIDEO_PERMISSIONS, REQUEST_VIDEO_PERMISSIONS); } }).setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { parent.getActivity().finish(); } }).create(); } } }