From a5c1025cc0d048dca83df713d3a286401b797e35 Mon Sep 17 00:00:00 2001 From: BlueMatthew Date: Tue, 2 Jan 2024 00:28:09 +0800 Subject: [PATCH] Initial Commit --- Application/build.gradle | 68 ++ Application/src/main/AndroidManifest.xml | 43 + .../camera2video/AutoFitTextureView.java | 76 ++ .../camera2video/Camera2VideoFragment.java | 763 ++++++++++++++++++ .../android/camera2video/CameraActivity.java | 35 + .../main/res/drawable-hdpi/ic_action_info.png | Bin 0 -> 1025 bytes .../main/res/drawable-hdpi/ic_launcher.png | Bin 0 -> 4370 bytes .../src/main/res/drawable-hdpi/tile.9.png | Bin 0 -> 196 bytes .../main/res/drawable-mdpi/ic_action_info.png | Bin 0 -> 665 bytes .../main/res/drawable-mdpi/ic_launcher.png | Bin 0 -> 2739 bytes .../res/drawable-xhdpi/ic_action_info.png | Bin 0 -> 1355 bytes .../main/res/drawable-xhdpi/ic_launcher.png | Bin 0 -> 6096 bytes .../res/drawable-xxhdpi/ic_action_info.png | Bin 0 -> 2265 bytes .../main/res/drawable-xxhdpi/ic_launcher.png | Bin 0 -> 10731 bytes .../layout-land/fragment_camera2_video.xml | 58 ++ .../src/main/res/layout/activity_camera.xml | 22 + .../res/layout/fragment_camera2_video.xml | 54 ++ .../res/values-sw600dp/template-dimens.xml | 24 + .../res/values-sw600dp/template-styles.xml | 25 + .../main/res/values-v11/template-styles.xml | 22 + .../src/main/res/values-v21/base-colors.xml | 21 + .../res/values-v21/base-template-styles.xml | 24 + .../src/main/res/values/base-strings.xml | 29 + Application/src/main/res/values/strings.xml | 8 + Application/src/main/res/values/styles.xml | 20 + .../src/main/res/values/template-dimens.xml | 32 + .../src/main/res/values/template-styles.xml | 42 + build.gradle | 14 + gradle.properties | 20 + gradle/wrapper/gradle-wrapper.properties | 5 + gradlew | 172 ++++ gradlew.bat | 84 ++ screenshots/1-launch.png | Bin 0 -> 2329041 bytes screenshots/2-record.png | Bin 0 -> 2368599 bytes screenshots/3-save.png | Bin 0 -> 2183768 bytes screenshots/icon-web.png | Bin 0 -> 66500 bytes settings.gradle | 1 + 37 files changed, 1662 insertions(+) create mode 100644 Application/build.gradle create mode 100644 Application/src/main/AndroidManifest.xml create mode 100644 Application/src/main/java/com/example/android/camera2video/AutoFitTextureView.java create mode 100644 Application/src/main/java/com/example/android/camera2video/Camera2VideoFragment.java create mode 100644 Application/src/main/java/com/example/android/camera2video/CameraActivity.java create mode 100644 Application/src/main/res/drawable-hdpi/ic_action_info.png create mode 100644 Application/src/main/res/drawable-hdpi/ic_launcher.png create mode 100644 Application/src/main/res/drawable-hdpi/tile.9.png create mode 100644 Application/src/main/res/drawable-mdpi/ic_action_info.png create mode 100644 Application/src/main/res/drawable-mdpi/ic_launcher.png create mode 100644 Application/src/main/res/drawable-xhdpi/ic_action_info.png create mode 100644 Application/src/main/res/drawable-xhdpi/ic_launcher.png create mode 100644 Application/src/main/res/drawable-xxhdpi/ic_action_info.png create mode 100644 Application/src/main/res/drawable-xxhdpi/ic_launcher.png create mode 100644 Application/src/main/res/layout-land/fragment_camera2_video.xml create mode 100644 Application/src/main/res/layout/activity_camera.xml create mode 100644 Application/src/main/res/layout/fragment_camera2_video.xml create mode 100644 Application/src/main/res/values-sw600dp/template-dimens.xml create mode 100644 Application/src/main/res/values-sw600dp/template-styles.xml create mode 100644 Application/src/main/res/values-v11/template-styles.xml create mode 100644 Application/src/main/res/values-v21/base-colors.xml create mode 100644 Application/src/main/res/values-v21/base-template-styles.xml create mode 100644 Application/src/main/res/values/base-strings.xml create mode 100644 Application/src/main/res/values/strings.xml create mode 100644 Application/src/main/res/values/styles.xml create mode 100644 Application/src/main/res/values/template-dimens.xml create mode 100644 Application/src/main/res/values/template-styles.xml create mode 100644 build.gradle create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100644 gradlew create mode 100644 gradlew.bat create mode 100644 screenshots/1-launch.png create mode 100644 screenshots/2-record.png create mode 100644 screenshots/3-save.png create mode 100644 screenshots/icon-web.png create mode 100644 settings.gradle diff --git a/Application/build.gradle b/Application/build.gradle new file mode 100644 index 0000000..5a99955 --- /dev/null +++ b/Application/build.gradle @@ -0,0 +1,68 @@ + +buildscript { + repositories { + google() + jcenter() + } + + dependencies { + classpath 'com.android.tools.build:gradle:3.3.2' + } +} + +apply plugin: 'com.android.application' + +repositories { + google() + jcenter() +} + +dependencies { + + + implementation "com.android.support:support-v4:28.0.0" + implementation "com.android.support:support-v13:28.0.0" + implementation "com.android.support:cardview-v7:28.0.0" + implementation "com.android.support:appcompat-v7:28.0.0" + + + + + + +} + +// The sample build uses multiple directories to +// keep boilerplate and common code separate from +// the main sample code. +List dirs = [ + 'main', // main sample code; look here for the interesting stuff. + 'common', // components that are reused by multiple samples + 'template'] // boilerplate code that is generated by the sample template process + +android { + compileSdkVersion 28 + + defaultConfig { + minSdkVersion 21 + targetSdkVersion 28 + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_7 + targetCompatibility JavaVersion.VERSION_1_7 + } + + sourceSets { + main { + dirs.each { dir -> + java.srcDirs "src/${dir}/java" + res.srcDirs "src/${dir}/res" + } + } + androidTest.setRoot('tests') + androidTest.java.srcDirs = ['tests/src'] + + } + +} diff --git a/Application/src/main/AndroidManifest.xml b/Application/src/main/AndroidManifest.xml new file mode 100644 index 0000000..67a90d0 --- /dev/null +++ b/Application/src/main/AndroidManifest.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/Application/src/main/java/com/example/android/camera2video/AutoFitTextureView.java b/Application/src/main/java/com/example/android/camera2video/AutoFitTextureView.java new file mode 100644 index 0000000..090f81c --- /dev/null +++ b/Application/src/main/java/com/example/android/camera2video/AutoFitTextureView.java @@ -0,0 +1,76 @@ +/* + * 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. + */ + +package com.example.android.camera2video; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.TextureView; + +/** + * A {@link TextureView} that can be adjusted to a specified aspect ratio. + */ +public class AutoFitTextureView extends TextureView { + + private int mRatioWidth = 0; + private int mRatioHeight = 0; + + public AutoFitTextureView(Context context) { + this(context, null); + } + + public AutoFitTextureView(Context context, AttributeSet attrs) { + this(context, attrs, 0); + } + + public AutoFitTextureView(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + } + + /** + * Sets the aspect ratio for this view. The size of the view will be measured based on the ratio + * calculated from the parameters. Note that the actual sizes of parameters don't matter, that + * is, calling setAspectRatio(2, 3) and setAspectRatio(4, 6) make the same result. + * + * @param width Relative horizontal size + * @param height Relative vertical size + */ + public void setAspectRatio(int width, int height) { + if (width < 0 || height < 0) { + throw new IllegalArgumentException("Size cannot be negative."); + } + mRatioWidth = width; + mRatioHeight = height; + requestLayout(); + } + + @Override + protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { + super.onMeasure(widthMeasureSpec, heightMeasureSpec); + int width = MeasureSpec.getSize(widthMeasureSpec); + int height = MeasureSpec.getSize(heightMeasureSpec); + if (0 == mRatioWidth || 0 == mRatioHeight) { + setMeasuredDimension(width, height); + } else { + if (width < height * mRatioWidth / mRatioHeight) { + setMeasuredDimension(width, width * mRatioHeight / mRatioWidth); + } else { + setMeasuredDimension(height * mRatioWidth / mRatioHeight, height); + } + } + } + +} diff --git a/Application/src/main/java/com/example/android/camera2video/Camera2VideoFragment.java b/Application/src/main/java/com/example/android/camera2video/Camera2VideoFragment.java new file mode 100644 index 0000000..fc2ff13 --- /dev/null +++ b/Application/src/main/java/com/example/android/camera2video/Camera2VideoFragment.java @@ -0,0 +1,763 @@ +/* + * 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. + */ + +package com.example.android.camera2video; + +import android.Manifest; +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.pm.PackageManager; +import android.content.res.Configuration; +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.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.Log; +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 android.widget.Button; +import android.widget.Toast; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; + +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 String TAG = "Camera2VideoFragment"; + 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 AutoFitTextureView} for camera preview. + */ + private AutoFitTextureView mTextureView; + + /** + * Button to record video + */ + private Button mButtonVideo; + + /** + * A reference to the opened {@link android.hardware.camera2.CameraDevice}. + */ + private CameraDevice mCameraDevice; + + /** + * A reference to the current {@link android.hardware.camera2.CameraCaptureSession} for + * preview. + */ + private CameraCaptureSession mPreviewSession; + + /** + * {@link TextureView.SurfaceTextureListener} handles several lifecycle events on a + * {@link TextureView}. + */ + private TextureView.SurfaceTextureListener mSurfaceTextureListener + = 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 mPreviewSize; + + /** + * The {@link android.util.Size} of video recording. + */ + private Size mVideoSize; + + /** + * MediaRecorder + */ + private MediaRecorder mMediaRecorder; + + /** + * Whether the app is recording video now + */ + private boolean mIsRecordingVideo; + + /** + * An additional thread for running tasks that shouldn't block the UI. + */ + private HandlerThread mBackgroundThread; + + /** + * A {@link Handler} for running tasks in the background. + */ + private Handler mBackgroundHandler; + + /** + * A {@link Semaphore} to prevent the app from exiting before closing the camera. + */ + private Semaphore mCameraOpenCloseLock = new Semaphore(1); + + /** + * {@link CameraDevice.StateCallback} is called when {@link CameraDevice} changes its status. + */ + private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() { + + @Override + public void onOpened(@NonNull CameraDevice cameraDevice) { + mCameraDevice = cameraDevice; + startPreview(); + mCameraOpenCloseLock.release(); + if (null != mTextureView) { + configureTransform(mTextureView.getWidth(), mTextureView.getHeight()); + } + } + + @Override + public void onDisconnected(@NonNull CameraDevice cameraDevice) { + mCameraOpenCloseLock.release(); + cameraDevice.close(); + mCameraDevice = null; + } + + @Override + public void onError(@NonNull CameraDevice cameraDevice, int error) { + mCameraOpenCloseLock.release(); + cameraDevice.close(); + mCameraDevice = null; + Activity activity = getActivity(); + if (null != activity) { + activity.finish(); + } + } + + }; + private Integer mSensorOrientation; + private String mNextVideoAbsolutePath; + private CaptureRequest.Builder mPreviewBuilder; + + 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; + } + } + Log.e(TAG, "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 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 CompareSizesByArea()); + } else { + Log.e(TAG, "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_camera2_video, container, false); + } + + @Override + public void onViewCreated(final View view, Bundle savedInstanceState) { + mTextureView = (AutoFitTextureView) view.findViewById(R.id.texture); + mButtonVideo = (Button) view.findViewById(R.id.video); + mButtonVideo.setOnClickListener(this); + view.findViewById(R.id.info).setOnClickListener(this); + } + + @Override + public void onResume() { + super.onResume(); + startBackgroundThread(); + if (mTextureView.isAvailable()) { + openCamera(mTextureView.getWidth(), mTextureView.getHeight()); + } else { + mTextureView.setSurfaceTextureListener(mSurfaceTextureListener); + } + } + + @Override + public void onPause() { + closeCamera(); + stopBackgroundThread(); + super.onPause(); + } + + @Override + public void onClick(View view) { + switch (view.getId()) { + case R.id.video: { + if (mIsRecordingVideo) { + stopRecordingVideo(); + } else { + startRecordingVideo(); + } + break; + } + case R.id.info: { + Activity activity = getActivity(); + if (null != activity) { + new AlertDialog.Builder(activity) + .setMessage(R.string.intro_message) + .setPositiveButton(android.R.string.ok, null) + .show(); + } + break; + } + } + } + + /** + * Starts a background thread and its {@link Handler}. + */ + private void startBackgroundThread() { + mBackgroundThread = new HandlerThread("CameraBackground"); + mBackgroundThread.start(); + mBackgroundHandler = new Handler(mBackgroundThread.getLooper()); + } + + /** + * Stops the background thread and its {@link Handler}. + */ + private void stopBackgroundThread() { + mBackgroundThread.quitSafely(); + try { + mBackgroundThread.join(); + mBackgroundThread = null; + mBackgroundHandler = null; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + /** + * 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) { + Log.d(TAG, "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.permission_request)) + .show(getChildFragmentManager(), FRAGMENT_DIALOG); + break; + } + } + } else { + ErrorDialog.newInstance(getString(R.string.permission_request)) + .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 `mStateCallback`. + */ + @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 { + Log.d(TAG, "tryAcquire"); + if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { + throw new RuntimeException("Time out waiting to lock camera opening."); + } + String cameraId = manager.getCameraIdList()[0]; + + // Choose the sizes for camera preview and video recording + CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId); + StreamConfigurationMap map = characteristics + .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); + mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); + if (map == null) { + throw new RuntimeException("Cannot get available preview/video sizes"); + } + mVideoSize = chooseVideoSize(map.getOutputSizes(MediaRecorder.class)); + mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), + width, height, mVideoSize); + + int orientation = getResources().getConfiguration().orientation; + if (orientation == Configuration.ORIENTATION_LANDSCAPE) { + mTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight()); + } else { + mTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth()); + } + configureTransform(width, height); + mMediaRecorder = new MediaRecorder(); + manager.openCamera(cameraId, mStateCallback, null); + } catch (CameraAccessException e) { + Toast.makeText(activity, "Cannot access the camera.", Toast.LENGTH_SHORT).show(); + 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 { + mCameraOpenCloseLock.acquire(); + closePreviewSession(); + if (null != mCameraDevice) { + mCameraDevice.close(); + mCameraDevice = null; + } + if (null != mMediaRecorder) { + mMediaRecorder.release(); + mMediaRecorder = null; + } + } catch (InterruptedException e) { + throw new RuntimeException("Interrupted while trying to lock camera closing."); + } finally { + mCameraOpenCloseLock.release(); + } + } + + /** + * Start the camera preview. + */ + private void startPreview() { + if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) { + return; + } + try { + closePreviewSession(); + SurfaceTexture texture = mTextureView.getSurfaceTexture(); + assert texture != null; + texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); + mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); + + Surface previewSurface = new Surface(texture); + mPreviewBuilder.addTarget(previewSurface); + + mCameraDevice.createCaptureSession(Collections.singletonList(previewSurface), + new CameraCaptureSession.StateCallback() { + + @Override + public void onConfigured(@NonNull CameraCaptureSession session) { + mPreviewSession = session; + updatePreview(); + } + + @Override + public void onConfigureFailed(@NonNull CameraCaptureSession session) { + Activity activity = getActivity(); + if (null != activity) { + Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show(); + } + } + }, mBackgroundHandler); + } catch (CameraAccessException e) { + e.printStackTrace(); + } + } + + /** + * Update the camera preview. {@link #startPreview()} needs to be called in advance. + */ + private void updatePreview() { + if (null == mCameraDevice) { + return; + } + try { + setUpCaptureRequestBuilder(mPreviewBuilder); + HandlerThread thread = new HandlerThread("CameraPreview"); + thread.start(); + mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, mBackgroundHandler); + } catch (CameraAccessException e) { + e.printStackTrace(); + } + } + + private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) { + builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO); + } + + /** + * Configures the necessary {@link android.graphics.Matrix} transformation to `mTextureView`. + * This method should not to be called until the camera preview size is determined in + * openCamera, or until the size of `mTextureView` is fixed. + * + * @param viewWidth The width of `mTextureView` + * @param viewHeight The height of `mTextureView` + */ + private void configureTransform(int viewWidth, int viewHeight) { + Activity activity = getActivity(); + 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); + } + mTextureView.setTransform(matrix); + } + + private void setUpMediaRecorder() throws IOException { + final Activity activity = getActivity(); + if (null == activity) { + return; + } + mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); + mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE); + mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); + if (mNextVideoAbsolutePath == null || mNextVideoAbsolutePath.isEmpty()) { + mNextVideoAbsolutePath = getVideoFilePath(getActivity()); + } + mMediaRecorder.setOutputFile(mNextVideoAbsolutePath); + mMediaRecorder.setVideoEncodingBitRate(10000000); + mMediaRecorder.setVideoFrameRate(30); + mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight()); + mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264); + mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); + int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); + switch (mSensorOrientation) { + case SENSOR_ORIENTATION_DEFAULT_DEGREES: + mMediaRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(rotation)); + break; + case SENSOR_ORIENTATION_INVERSE_DEGREES: + mMediaRecorder.setOrientationHint(INVERSE_ORIENTATIONS.get(rotation)); + break; + } + mMediaRecorder.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 == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) { + return; + } + try { + closePreviewSession(); + setUpMediaRecorder(); + SurfaceTexture texture = mTextureView.getSurfaceTexture(); + assert texture != null; + texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); + mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD); + List surfaces = new ArrayList<>(); + + // Set up Surface for the camera preview + Surface previewSurface = new Surface(texture); + surfaces.add(previewSurface); + mPreviewBuilder.addTarget(previewSurface); + + // Set up Surface for the MediaRecorder + Surface recorderSurface = mMediaRecorder.getSurface(); + surfaces.add(recorderSurface); + mPreviewBuilder.addTarget(recorderSurface); + + // Start a capture session + // Once the session starts, we can update the UI and start recording + mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() { + + @Override + public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) { + mPreviewSession = cameraCaptureSession; + updatePreview(); + getActivity().runOnUiThread(new Runnable() { + @Override + public void run() { + // UI + mButtonVideo.setText(R.string.stop); + mIsRecordingVideo = true; + + // Start recording + mMediaRecorder.start(); + } + }); + } + + @Override + public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) { + Activity activity = getActivity(); + if (null != activity) { + Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show(); + } + } + }, mBackgroundHandler); + } catch (CameraAccessException | IOException e) { + e.printStackTrace(); + } + + } + + private void closePreviewSession() { + if (mPreviewSession != null) { + mPreviewSession.close(); + mPreviewSession = null; + } + } + + private void stopRecordingVideo() { + // UI + mIsRecordingVideo = false; + mButtonVideo.setText(R.string.record); + // Stop recording + mMediaRecorder.stop(); + mMediaRecorder.reset(); + + Activity activity = getActivity(); + if (null != activity) { + Toast.makeText(activity, "Video saved: " + mNextVideoAbsolutePath, + Toast.LENGTH_SHORT).show(); + Log.d(TAG, "Video saved: " + mNextVideoAbsolutePath); + } + mNextVideoAbsolutePath = null; + startPreview(); + } + + /** + * 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()); + } + + } + + public static class ErrorDialog extends DialogFragment { + + private static final String ARG_MESSAGE = "message"; + + public static ErrorDialog newInstance(String message) { + ErrorDialog dialog = new ErrorDialog(); + Bundle args = new Bundle(); + args.putString(ARG_MESSAGE, message); + dialog.setArguments(args); + return dialog; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Activity activity = getActivity(); + return new AlertDialog.Builder(activity) + .setMessage(getArguments().getString(ARG_MESSAGE)) + .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialogInterface, int i) { + activity.finish(); + } + }) + .create(); + } + + } + + public static class ConfirmationDialog extends DialogFragment { + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + final Fragment parent = getParentFragment(); + return new AlertDialog.Builder(getActivity()) + .setMessage(R.string.permission_request) + .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(); + } + + } + +} diff --git a/Application/src/main/java/com/example/android/camera2video/CameraActivity.java b/Application/src/main/java/com/example/android/camera2video/CameraActivity.java new file mode 100644 index 0000000..d90f227 --- /dev/null +++ b/Application/src/main/java/com/example/android/camera2video/CameraActivity.java @@ -0,0 +1,35 @@ +/* + * 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. + */ + +package com.example.android.camera2video; + +import android.app.Activity; +import android.os.Bundle; + +public class CameraActivity extends Activity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_camera); + if (null == savedInstanceState) { + getFragmentManager().beginTransaction() + .replace(R.id.container, Camera2VideoFragment.newInstance()) + .commit(); + } + } + +} diff --git a/Application/src/main/res/drawable-hdpi/ic_action_info.png b/Application/src/main/res/drawable-hdpi/ic_action_info.png new file mode 100644 index 0000000000000000000000000000000000000000..32bd1aabcabb85ded957230533c00e735183a323 GIT binary patch literal 1025 zcmV+c1pfPpP)UDI7BaW>`N=bRlk|E2%^dB8hrR55et*8d|IcHT75QTnx&CD( z0RP&9B@dK5;L-x65HcIEwzf8qPN%o}e7;SFVXWg@h5G(8m&<)+eJL+59~&4LNV_!r zJh>+x2#3Sl{CdQ#bT}>ywQR&8iWzy)M+Q2ECY~)rE;`M%!}m*2L~T%H1|=Rs$~z==CdX= z48rmho`|t8O+~w5HL)!Nz)I((+8|_dYHF%o7dC|2VU#(bK)xovUn~V!!l|;d@(MD7 z$QZ@DcdfYA5&%`_FTxPs#yu+u3*fUT6H!Ve0B~QYkR&!V=On%G_H8SD!V&>jgyx}+Knp;|1FUifM$%zBVA`u=>gGED zq&&B>W-!17-PoZ8pu*>pbXb_S!SK5k1xd4g)>g@d_8I_WOpy-#W+|Ck0J!uB4ECW!8~_iN3BVZu zM3MEDkbUMBz)2YFhG8#Z(6Jl<2)`3DFCpta03QGM0E#<=iav?WWt8LK<;7mY% z3dxyac6RorXJyoBBXbJC^F}6?buvmg1pu84baGnrW|R;B`7n}q8^hfEjBmA(6>OMO zoz?C*-2~m-v6H8ldj5Q=dS1|RS_C^d&`6ihclsRfvKD*(IM9&9?Zd;vNh?iLJ4%?D z6zE845IW5TKT_s_(B@n7HxeEl>YLS3QbfqjMBxtg3WS%}Dot{PRD74`S|#s^V!qg# zPm9H_7TGYtTG>~N=HxEg%iV=#PR0&OU=>NZ*?hgu`!uJkZ!7kC-AcVK)E--XpioM< v;adXW#(G}RmOS8v72WVCdBBbJyrBIJ%ovMLu~&(q00000NkvXXu0mjfpn%#$ literal 0 HcmV?d00001 diff --git a/Application/src/main/res/drawable-hdpi/ic_launcher.png b/Application/src/main/res/drawable-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..88bc107bbddfe22657393dc99bf1267497fa360a GIT binary patch literal 4370 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 literal 0 HcmV?d00001 diff --git a/Application/src/main/res/drawable-xhdpi/ic_action_info.png b/Application/src/main/res/drawable-xhdpi/ic_action_info.png new file mode 100644 index 0000000000000000000000000000000000000000..ba143ea7a80f03b0e850775ad672ccb2d6195e4c GIT binary patch literal 1355 zcmV-R1+@B!P)75wB?6-CWk+3Ez~DWohQ@%>jMdQA1c3hj{%fPr=n<5-3k6~tfy!wCFb|Kf3x&e@#l^+Hz3{3u)^7kJ zSp5(dKa9|EdqNahe-)7XjcFXF`O`@%(u@ozCtg#MS;!CX<8kdJtYc7Vj0j?7f+pnP0u| zma(1zsGz*K=QJ_;2=4hb0yr^WQ{^2z%0b}w6k+xe*Qyd@)c}y~@1x8; zYy>M|jSsb!@9pjFknu}PO9hR`7!aOuLKv?&OXDQfL48yOfYkX|EH-JCs%flnS~0tn z%clTvSjNyK%~9Sy)>skmlZtcDgu+@rpC7NLPpAq2CV!NP?=_R>nEWkG!bAB3DF3nz z7**t*OeXWaTM#8NVuV+%>hKjtIOBG_L#GBn+FMG{8&-$+zP8jQ5{WzD@scepjnKQ< zZ1y{i0#YKOf8H1(4~Va8+h#QYENUJg-j5hTmr?#rjnIa+1>v9NUKEfc3!e`p8nnFN z^BQCJ%Q%d3j$H7ChKCw}(b3TfYhm*Vf?w23Xw#C+_Q*5IQ&xgi9RMKR;uA7h7Eq~F zYC^+E1%O%7o-i)Awz9Hv%x!zC5lTbb-Q6AU>gt-p`n!!69M>$RRRDnYolGK)h#VQL ze^Mi?Lo0a%YaO@8;#DWK@#~C7uIIQ#r;KLCJS`;cqg$n_I)O}Ujz1pux#0psnhE$a3-b$iwAM78vQ z!NI{!HdQ9g9G3|Jk<-CbTfdn870jt~uG6|9c0$&DwX@qLf2h^t#@~aj06M(w5 z!ctfKSPc0IKwTF@0)QXOVV?o0?{e6W4H3TpXvl_$@q)+bz3(xtr+Q1w4*(jrB_>LH z-4vyDy@o9@*;l-Bu$^^=*7_e;{VPNb-4qoe{n!?Ft86)4!?(qaK*4@7A|M3))!4Qp z0K&~&Ua;N|2Iu9d6Pp!4kQbN1cs=fbAeo&_iKEgimL;uao}2pv2}|MNej;OAy|1tD zx_CT(*sqVI*fRg7SS+5a=H=&3rB<~iwiC1R{{#D(TqU5c_Ms#dq`>(XedXxYF literal 0 HcmV?d00001 diff --git a/Application/src/main/res/drawable-xhdpi/ic_launcher.png b/Application/src/main/res/drawable-xhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..2811666b0ed34e612d40a0bd420bfbc8af7f091d GIT binary patch literal 6096 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

-Mf)az%Qy6?UwBW&Sz>T67g78W`LATiMlfDITNfUR4- z9?*FLtz`XrQw*rn9e4O|9zZ?HTey%fkC98$@tLq-0gJu&Ua$Lm@&`X?GQx6pZMVpm zp5qvRuY2@x8DTjWP~A^O6+xu?ZrkSdfRN|So-xC9pOAuJ3NxpW-|jSYj3zHpa_2O; zppEtPl8TIuLd}t<1v}tvIZ2>#6(qS|HN5h>v<(2DsK}WFe4UVB20((LPR#e3xv@pQYx8BN8gAZ9Qvz(U=+{CuwGEBEbV)s))(7v6Zo^_C0Nl81uDTG8ZUVi^nO68@omQ4XzAzU^1rIfZg`vm|&dO@`_*RU$Cp{mN1 zUE>B>aJ>47>mx2*awY*^gonGlAUhD0>qb2*HDv)rGZ0k31cjUJGvP_Z+yS6X($oYE zZ&ugi%DDtkC$>A{qe;I2U~s(7(b608L~u2vU063u2;C+P$5=?*RGj> z@&+WTJEEq>nFM^&u_I5)yJ(@P6Y<^ZS~I{j&bC!Q5>QECZ`F^y&x-Jz!Nu;0DuKm! zHFjjED;ZakDn^qCTRWh%e^YI(GXOs7(7^?OMvP{Jr-zz$J_KNL?qCI;&gp6$9e|dE zAatqF)s0SQ9W0%*Wql&PvHclcGxn9Uk_5F)@%wFcbLUL4Zh=ZtdyA`MV!u?jNNas#*ZV*pbONzu8hE^xC zqSg%1G)YVN_~Y3(-+VK6Oh+I~Y&fb6TW1_P2Vz}bef8CGQ>RYFo7bLpR$^I1=+KEus`{Mr^75?u`g+>`AaI2??5HEo}twS4*V z=jjw%{90@b&HK`E&6+i@M$)^#xQD=E^XARN>MmM;Zdt%s5zkQR-Me?HeAc;h=kk{> zUHS~QVY{=fpGFSdUq}aK^BKMVZ!ZCSaCBgEA8a|ISV=#1rKy>qWy_Y$Oixc=NH}mJ z*3{HAzVy;dOLp(x{l4gMGovMLPuRYF`@v{>-xv2?q}9(;rcA-E??pDf1S9nrJ9g~d zbLY-oM8E|R=i_eUHE{9~kkx_}rU zOHECM3JDdehwa+6Yx|NVOR!)Qi$t-%zPpXmeE|St#s4D= zUbJY@d?NUL9cfvMkf8d!yu48lJ@n95t<8{a0YLEk@4vshM~@!2!RrA4g@uJB)2C0L zT~<~`dkb(c!IM$+1pv@CjE-bddpD4qy^aiW96Tt1Kwi{G6DCX;>qhMb1e;a|VB5BB z_tU`NklY6VHg4Rw{*_l=!ER5q?wcDbPsLXN&@LQ|0gpcV=#OU2n)O5kZDj)ha1<02 zJV3_W`?pLy_14YrtqQ=(l`AQ6HuOmM?%mU%e?j~cCr%tE?thB<_%$7H)$BYUbr?n`4I7gC_wNt4Gg|uKpM3Jkp850V(>5vW5FMDJ+qs?kSe*g@w-h0lA*)uc`q^!_ z-F7=>)c}B8+RBWKi~%!e&TN(cQ)?{%g5G}n?M>u%K8#QRxWBZtwCb_P9(yt?E9+w- zL^d6!Ae9I1atZ*NN6;}fEiG*fF~^$t`1mNOMf9z>xOfYBNsrL)?mRJn2teyZIw`Vx z^PoY4KBgIHuyi}$eDlrMSFBjEjz)2W4y?lUX0ZMM0L<5!jzLd9{q$^#{5~ih1CoRW zvQ1+sf=TNk16x`{0)ol2IB@U1_l~-bR!xX_PXR>-XA>A-(D3lLex4V7n(2_TXV0D- z3a)WOj+rp&b59d7D@tM~sGbz48?kxw=5;hTNrYSaIlW`BbLY;_-g)Ppo4inqJ|Puw z04N#p-=un8h2f=vvRiJs1%rEm+)=z%PrGz5U!svI6e`alZwl&ygFx{kUjP8n5bf

efti9l+whE7Gu}v z?%TI7%?Al>F$94IAZGmd@kfaJlP}Ol8D!+@>CZy{j|?zY@t&ds5kg-|3I*Q)Y%qnC z;k`5*IB)=jvJ1v}dIloDePd%|?;bH?#0vThr9L7)m3#2uLHvtExu*tv{XNhCBv9gH zVq#+AJOW_=4eH(O?CiDFStKV+nISI+kU|rv*C?EEt02@z$B!TXF9!g~OyFR$15eUS z{T@oB9HTZ@5(r?HfJI6J4FG&?Y)^O%9mq4#W}aO2;9o_(aXWQ<@XE`Lbfk(Ovgz|v z(Y}{h8r9*J;$LLb=|KC4+n-dJ#n*P--WO;9Ky+l-kmkgn3DC|=EQgMk#CzOzJcfS6 z7P$2PC%nLuqCcl`tSS&Ef-S*&tkra2GKLJ6U8c=3D1in59fYd~;^PwoahGar>3|T= zL7Va)B0wx0Er}z!dj?Nk(gDVSYm7F%b&*>-241f<0Pw0q|7n%m0cc~y+W}}}0RA5t W1JzNK7us|H00000Sa)mFG$~BrwGw0-3DQAu%!<3<>`YB@WF#2L4)EuSE zty+Mwp46!_OhU$-u#fo@-=VmIj*02@&T;fB_;>vP{&Kz3a7%?Vt znPuw-)7Ljl!+T!N#AT8`HicVp&J2{tr@H*4@J*m(-vfF;9vB9h8<025G-Mbn6F_ezr2EHxq5pvpRuquBy62jsm$|`3SY%$=Q6WJ=-1Ka1ZS8iLNo@Xn zHI+&|IX^$YX>-n*moK~kDJdyIA+PJe3+_MnD;o9KX70^ErymnFiG%isjxK8rp{mxp zy1ML}0w44op8)2w42O#-S7BB`spVBb6vpNj;gg6kJ>dbV-DE5tKiq`$hvZ6j?xD!C z#WtXzuVdyNg+fuGskn6eRIb!Qu{hjOsEB7W4sHw6_E~VP+-x-&Wu3K!oy)rT^~cOk z9R!QT>S-J}zzHyQeV1_*cL*}0khy8F?!ld#;#I_YaTu-zRyiF0+o|xQg(!~!u&T4& zlWajGlkC@5R}n!00g}1##@c|eN=$dFnEi+9f1DfViTo`(L_{DE3vxOhFHXoVe0YQk zzv$)Vb)seOqQ~xtgJ@F0&Q{;pSabE0C$nYG7O_`Dd%-PkcV2_Uyv%#Kit9l${3RJX zHSa-h$36_DItQq!nu#_IJNT~&Z0K9|yG}YC{{4VrLjV%jx}>ia*wWLG3Her#!Xk2M zA558dJo&jDn8XwmO5e6|Ja_J+P;hW?;zT!376$ly{ysb&uQeN$b2=$zA1BW4l&R#W zU3Lc}$XoKy%{nuFQt$2KgfMs zH8}Je4wfR-5TwCjEvd;IhTq4ZoOK8rem~voFa_7m*z+Q)?a)+-F6VE>W&JUbTI3rT zIOnb||JR7*^zvprZSuw$F*jqk=nJ<+U}=vdH;t@Ucaw{Yi{Eu@t@d1H-a=H)nhW5W z(uGd1BX1ihy)%oCt!Ynrm#YiLd$eYUV@W*qiT?U0clc5bW%l{*l*{6>^NaNNu2miZ zSahE7s7+SKKSq4>WZM8oaq_1~d0fafnNJ(p0Y6;~M=%;5m5JL3adMnm<-%mc&1!|T zKFJ%Yizq|uI(T#_y$Ycz1mwIDYtZ5vO06->#d7&*W%B7~zvV{#TZy`=hV=17xs&4g z8shHVD?Tak4M_z%i23(T)qjp=<^M#9;?|E6 z5lx5JyJ2G_UxFkS4hEZ9s0m9=9{q?eE&Hf{)jffh&Bb!Z5~YeOOKJH9AJQhCx$fO_ z8PKxvu)0>s&5u6X=beSMBFf9l`x_e@y{6|yg}(lW+Hjx|cG#VVPib2eLV;>*a$hz|QT7?-3n zM=jRFMd#^oFBYKF>7U!wgBrVWjZc=Z_)aaSz%8!#5v(IbR*Q!qrds|h7A zbSVHk*>GU|ucXz&mW`7*wZB6YP6%@GC-SH_q7p2YRvBjZZQsQrL>f*|Q8yr~4?hktLA;y@Vonv|o z_IaR)H@6)%AU-rD4qy+&Y50|dpw8lT@0Q8TwKt#yLd0;+8=DCxz z@)aKrK1kxNjM#nzZ);N7j}dF?o$DMB_PHWVSg^$a)FAgukG;ZApZ9ij9cZR zu=Ijvyr>bSo%akk_`M{Z2~<%Q&QCjrQBbngfhi!JVD^ISw?_}-7A_U3NJ)d9P#1c% zLXdY*Vaq4TO1Kv?gfr#au?CU@W|EAqx1} z+&^AlvP%psdC#4+%40}Hp1)_L@au+;ODa%jcOB6Zgw9H zdNEDMzrxW>CJmBOi?my-HPJZn9?Dq;Yi#f2_b5WO>2o2Agv z{5845qXJ}V=F6EKqJN?1zQJc1r?C{JDmkhx>raF0`&3F!MO|H4c3C9~vM1cq@)FPc z1R&`<=U=5}D0?OoJ-a5SJ3PW8mfXnH;1pz!(zoNXCH&~>t=}<~(fe)3MKenl-VFKq z`FXEye9J7n5!P={Rg$<=D19#rVs4-$2>vX*n7?nRSqq@yp}E6~d-Q<+AlY}V3n~h7 hjc7SdOaB+y5x5D7s}z~a3kK|(*rHJ*@v&hE2KBc_jbe!nqsEFvjf(9t8hcAo zF(Qfu4GOkcX-ivR7g%;-VcGwC&pqGp&ADgh-n%<<_bPXuXP$fS%$YN1&Uxqk>N&TQ zlijjC(2gGH)Q)Sjmu7pw$pR<~f_C*l7C`OlzU;+W0A(@It{%t&s9oKcy*LY?EC$-u z16csItNXGS2LTA@c<(H}XF>Pl#!V|d9`BpPcN~k`{J?%qNkzis#6vV31zw^>IJ=FB$Pp3ASl zY}fjYfoyM3eF`0-!Lt8tb<_FfD^^Sxu~+qNbXBtrL^c3{dGe=Cd;75Mx7+S<#YDD2 z<#xz(vNLVRgX#$y2(vD;9tjTaBy+IL`V+O!uRXT5a9LY#rqb3_2~YyueC}lHO4JXn zPRo~He|7xcd;jcZs&c&skz2d@$k25lrn=VG*Uu>^D5y%d9ocd}-X2)DZe2}DNy!j; z!baLR&<@>5Z6<)gK83XRsI9GCxM`DH?#J6Z*(Xcb1El{trKP3)sNgEvn*uxt!5!B1Le`tV%q!E)YN>j#q>`0K@;{sRaMmv zRA@Qvt7(TqZ3R%i22k1j`SU+bSZlVx7SjU*1`HTX54%hQ2+DLIfcnguHS6y^d-lXd z*=-B&fx5c7&#J4dj};8$3m}Lvr32AkL3=OSyVH*2%0KjQMa6xso#-p?I6>b#$xn-puBN>Qww}}u>rt&e8Rwy*WwzS zHrZu&@kO$eE~$!e_(~-cx)_;j=>0lZ3<`y69G)H z%osq0|LWIoh5`yRL~LYY;1R6BY@!AUMZhl1O6n5LRJcY1&mDBGPcoebjmtvfoQLta zJs4m8T>;&4+<11kownmR=CX-dfZuRcDE6xGz<5BU>+mpw9y}bAY{i4hAYz74;NxqE zNfavywnI6thuO*n9?F8vBrwG>)bop)nvryfO?3bTV8U-$U+ZWG`}q2Sl$fF&fMMX^ zJB}+8|33o<{?EfYbWn*K283W71`mrLc^$v~?x()q6^+bhx^6W#Xox8q={GZ>$4k%b zh-)-}JdB454Y9_!aN8|_5(FMD#sj9>Dn*y@r?F`90F1?t0YnV8%R+)BTmWhIaPP~& zVph@ZV9_VbNwMgHm9E=w!GfP^umCvdGJuGI6c-b-Ip1*%J6>BEg$IC&rVkvr$Q=-& zm$;%r>nSedNF4>=S&z}*F^D!%=m7=ahk+oOjM)WGD_Bb5L+Df<{Yn6e%eh$b0hKz> z;zR(1JCL2OJXoq;QO?y(EOn@X6)a-vK_=MH4p;Orh;Y3SN3rI{bQ@QE3H^#0&vRcY zJ9_^7zI15=?F=9cEf_~e<~Mhjc*zodg=p*k?!bY|6@c{MxC1S~q;wT2hEOvr$}H+M zyJ8PLXYt6JZ=MtrtmHC?Sm%+- zuZIn^E+a*bsS|m`n+AeZq?xT$yQE&l;z}#iE?6}Pxjfgu=e&7+s0Jv`uA&?S3>yRa zl~(|oxz$$7m9E2j3%}(oas;^4Ku}p09nvau#e`v*NpMPq+@@c7*b8qQ@F9R02N)KU z3P;*XVo|0QScUZl zP{k?I8dR!2txxSbcW$%*`gogdmNNq|OR!=qO>t8%av4dmlSenwEad_~D9NVcEG<0s zmTTo*>Rhf!WwFMLXeiXI2YJl;pjS>|L35Vz$smX`ku`wS2M@X)+&HscE6E;RYUAGt+Td!zF-wR)7C}v;dkz08*VUP3J_vrARXYWL|5EKRz$nMS@Fw z_lQkCt`MfJMDrM*v#^i^l*i9wVpfS${ zm6cYS4}(R|KmtH<3?bPj2ryFonWE4Hm+ic%&uG0yD(0*}1L$2!OPv9C-kBN@+EIGh zU3WPRGiG=lb`l(tmE@qBK=U!tT`?&^5LDI&d?rf)m>mZoi+@KkjL8_{cW$pzv;z{UUAk=2BxfxF$aDhQM3j3> z4zkc=;;u13t^fA7)JBI&uYLDjXUU)b zWCxJ6vLO0219donH0vY;RU+lsu(oV0;)=hF1yBeU7{pB|016UunuWUb>63m2B9I3% zj?h)CpfZ@jH0zU6r2PP7ySKhydKk!}!+7AynKPX=Z@l5G`|?W< z19>bo!)#X~?DpGJX1casP)j1LAsGNAX=z!-Tnc)PM3$tNm_!QXuicF%X9!Gtp}NUQX3R!50hCKDq|SP7eIo&a{KppwtgH_ z&%E2FHEW!;AAI06y!W00PHPio6EHA@t_2Tt-d0;V1wZ+TlRIF515wqvE2S?n10jsE zaih~YFVD%}7CGVR**4VFI2%_Xg+^@B0m;52zw^*@_?*pgXAK4U^uQJcpxlZIr)aOeoNgmWD$qd3$!_iIfh`6=ea<+; z={aVMlLK=*L$=oDW~Z4Paf%N-u*3TvAc14D>C;c0^EiXtWm35&Y za6b8-x{@2AaOhB{b2rR@>e$T#pd`K2ww$2!I}%02-SrR$ggPoGOmKP}dT59BcFXG3 z&g$1+cN*S&)4_LlYL6xAAJ<5cd8p3O?;OfCD&B8Dr)b}Oot&bg4tp*JP$EyWOa-xJ zDW(TNwk*OVqw#&Oy2>g3`Onkd(XAwsR#OaZ^}qh*Y^91cNCY~Ya@i%F!h=8|u! zm|l$Tqes(9lIdScG9>^7FjQs(hz6zawb!Oygf%Z*=&X3~L1*1pU&T*1@?#!90BPo7 z28#XEQ;_MiaPVNK_t>#cZkqj83P9AizWG6ZakGrc2ja9-OU#PB$`Ens1`uLuh!M3A z>$veW%{tZv79?;?o-{?61P=p?${={#hd@+Fj?i>%9sv0ST@&R=r#&N4&JD9o+pz^y z(+Qw8Q>Qx1A9_dyRO2G}LUj4A)Zqsp29C)_A|(|8Tv(h%Kl@o)Fysp$KXKJzInlOh zJt@q}sG@*hI;=1So+(olcs%hn299JJ{k?Nxp_4}@IvAugDZ~iUV!|CPwwBsjW$G*Q zUIIrj4*@r}3j<3QkU3to`|c{b539;=L&iYUoH;6`w&@F60Z=E(yE9cWNXC>N_>0Q^@BdVY zCdw@iKyAoIMBCE`pj0d|p%+CBAY>{oo;cBIrNlE+=W&?`BT2yNM)9`dU;M%;*lxR& zru;xxSoito&gy^u(`o$pR8Wb6ZR=xbPvxt;v&-5Q#a(;Qrz4g|y#T9G-vK%w@peO;fY27+!@zqy5>%RFWrt_HMigTnXXxrhw75u+Z)+D^dVr9VpSvj)3Vu=>w3>1Fer)J<|H^ue$#FNB{(1PtC;_JDX(sD<`LE z5am(!V#TGGDkVAWZNs8P&Jq%x8TynD?pb;P zQ6_`T!&> ztGH=3esM9nriy4jY(G%_3okg!@4w&ITrZ;dRQY-5g*jgSb^f8vydt zeQeg5p=^f@AS8j!JM+w#)6inNtHHYLvUZv4sg5)TZPDeIJJ5+ts|;^BJl+HU`qxm? zck2m2aAEkSYv}3Bi2#;f03|EN1mLP}y2&ZtfB#g+#J4=A1TDVdhIqe^z9&RicgodC z_Xb9&g;9}!D$&p8f)~tH6 zKq11^y=3Z!@J3tN2Q3hwOCNxQi7Y1pn#<6cQSd5KFvA4UQnF|eQm{D>5u)gK>#d;; zQYsZej4c>H-hqFLm1#MEB}X6alv1EItW5!klJz{n)Ku6<11)+04H&R_i92%@GB)qg zE4HQR=vdeQg7XZEIoWc3ibjo6j>C@H7LlUd_}~9-)=SV3Jy6|Aj8~B3Gpx-8kPrK) zTPGpjhAmhSu?Uj@Y6A-?0EL*+T64)IvGoX9R0>792L(#Y&N(NnF-p0fCG@OoC^Nte zuHtt$io+qjH>^zo2EAyV3lqAH?{X^^7OEmoZI}RB zc+o{pBh9X`IS@+@KinxLG15`nQVLtFro1FG$O=(bM04W$BJ>c_245HhC~(=k1OQ7v zfRbS$X@!LiAQDl^X~#;mWFTU?vUE8REkIaIVVj2O)2$B0?v$xm38gorjR9o!``FSt zO!m>gqX$sGez8yn`**ay6UaiMjA9@XEn#g)Bws@*6;cP{wjgwYd1xKAEx7PPXC2Ku zb7M_H2kLRiAx=4+4{K8ZBAv^13Zi05SVP9W)V+-|!)j_G7GV-VQj|#skjw5GW%`jH zC`fEd2fNW2Y^NX0X7J4H?!}|NQfD07}O1W0r{?Kz;kFSeOkgaY0q7AL(n5 z4-+N>ttI^jinLz_VxQAaizIy_(ZJWbFq>}|J!a$ z%PJa}0gD(|^MVCxVBNut{ZMVhn$=xt>Ao;G1t7{gNS0~*%0&*Kk1Hy?jzrTBlt8=z zKqVos&VluP=AM4K)BOGSzN>BYqBV(1k@gYgMsM^|ioMlSezHbS+$Uyd3?PxpdSqD5 z0e}_~)5ck0er)992O7R~X|xOk04Ygfh_1MQ%8~jHE?^~^Iyh_qq573iJmJ8kx9LHu zy)?@daj~dogeWmWqH7ricRl}a%FLtLsDeT-@Q{bSDFAWYPm3y#36C549GB&WFIyHd zfXd4^I}-i;Kmja-=y((WQi>~Bh^8NVQacoSVspf>#x&+;745la*yE@EegUyB_;0U(SA6ls-}$I7Axj$Awe z$?RpcHnq~jm_^$$m`I+lhcAj8maPmP2902!&Xm}XKr&XKjbf`K0M&qjOy{69*^>}w z!)t3JW*`7az0TSfWUx>orCI?fqRDmWJXmC_Xb~xoLM>Q`Loo0~Vc`R;d)U?ubHFg6 z5DPiPuwwifF9V22jK(!8H`5H z=Iae06>Pt~)1QoooCq@`;gJV`Y+_5{*f8P!fHr*j@`xFzPah9}0vShuiWvca{1zpE zaLe^%je*Xa=gspb(=(VPu;@G1HpIf_SQ#IG%F>0FA;x;un8)6_VT1bL4$M4VPjl{@ zC`5rIG5l+gyD?yxargus&!^cSNaF=qqucIZ)T2X@mgntimoo?ohBzOdXzyt*}{~m4& zEDIdMNn*qe_2y!a=04;I=&FbCT>jx5GN(Myz$wQkC04XM-<$ICxx{f~Omh_5b ziAG(3$JKxIHEJ~u$`H&SI51Hyp`2F$GJ?0hRv7Lm^d2eBs#mUzmVsvV>g8+3$4Dml z&*0JtAhZYR6iDn+siii3NDrTFZD_xdHNm3F3B3otCir`>E>OBQ7eI-uFu_i778{*Q z4}fAwv4TaNvMA9Etp4Sj8QUIb3?uZR@wJ?W% zHCa$lj$KA-Ph+UlJJDK*$}K<%Vu-YN#8&szQwl(StAhAiXNH1ZU0)wDfJ#c@&G-~R zG=Rbl9R(mBSgdo1|D8uF>_#@jlVKmOK(kO60!uN?dd157Fx5M91Avf1>xqSFag{81 zP&_>VvM`J4JipL}IEO%DM+1ll8q2{n(44YH`oB@k>`;>cF_YA9BeNb#G5$Rf`PSGw z^6w2~Gm*UJ0Z<#jqeR%MRS`2#j~+1wY9ojgfG8g((>6>&hOY;UHQ=uhHet;}=nWKv z&7nV2ffEqsIR2_C6aS-C0SGxpLYYs6d02PadG+dO0rcPE;`nq94W_uXQf4GYPBH5Y z!Ng1iP^JMo)%GX=kq6#YqBR4VA}uaINm^}mO%R)GsIOXGHoC`sy$epb^%YKG(#6j zf=2`bEae&+*@W2H9aW6Nl~#|jflb)23g&h6aT7%_mlcJ+ub+njXO zNm9uU09dT3R>=7}GJrC{ z(U#ummkFLBZy9jy8hGWfL>K!gM_P0ZAXX zvW%a|vWTfvQaJoD6`0x~0byeuI_4R4E)xVU<6NBM&{9V-%)=m$96%ocKn8Gpbr?Np zDKnOZNdomCS)RTJ0wWCZ#b`<-#suoxEyfH0CIt!~Kw7=ky6kT2*GJ1hGxGC;tuQ|^ zBEe*19+Opk%EYbpBdsr)ha@ROmPw>A2c1t~Jy}6wfX&UzG1&=hBy)BwjFpmNZGt=* zJ&LXw88v{W0YJtZ?@@yN#10KiXJdfbv~|}MlI#%xGEH zo+ztPRUIJ87;LV~LYLjd3nnBZ4lN+tySX`Z20|OL=h0sLT5c}=A(k3xHzCU$KnV!X zEKxsD@Pp8KKT+k$a@6GmfzuwQF%g>Rcd~w+WX$>iCW_OSEFfdhnQUdUn^go-eFtvX zP);AKX>UeT^zPdOK|VLk9K@cZcPwU8{7P=_+|A=1@4t})9XK1pP+x!3o;NZ_ab7==~^2d)KKj`eU&z|(v(4nz)Nd%jC^b*M;n~@g#CLM2kcl`z}mbSm>& zeW3|b&om`b-%sbvnKfzBq_Zbao=i)fH~uAMtgUB&YL&y z{$9O$Mf=~?Ne*7NShPK`a^=dI0|yQ~o$f+eb6EI_RK1_uqg2ad~-pDl9+`?S6j!_1AAb_~3&NQ#nvCl)wPf zN!5qv%OkeEzmWb_5cNT^#okQI=uMa~0eS(~WwlCl=b(M6u2WAv_2lih-+naOhkDRH z{(SSzH}8G*)mPu8a!^uHUr_tf+3)D9CfZ@nLxioQ9lB6b45S7|0|tLB3?N}iEhyDE zmsGk<#80c*SX5M0OoM%IAKG9^ZKRnM7#s}z+O=yNCr+Gr;erJV7U|B2lix-gnR&Yr z+dkcmW@0cPQ765b&KYN%aSUAp#S$Iqc@vGgSdT31-@kuf5(j_o(W6IKVsf{Q0Me>e ztCnAW`Q_sp8X7QA45Em;E@AZmF~AI^8B34=I1RcF1E6&@J^Gkqj=_I**6WT1ApJJBV(|j@Jonsl#}G@N1XhzQg!ayvGv|RTuDF7h z+E;IUB9=^7&jUbsLGX;|H@q-t8;&Kk!q7+-5$r@{@UT}pT@PZrk9xZgKm71*&pGFu z*NTga3*fMXh+&blY}vBKC!c)sSxrq%i>WLWKn75dhyZ}VwtZfI{q^^{(|U@ik68@> zB5{fJ=};fu${+xtpYY-VKz#@}m5)5~Du*JM000T5Nkl+7gI;*y1z0?ZSTY^`&faGRk#r`;^=`3i6Yk3lYX8QnW zs8MH7`%P=M;<3jbo4CUcI}Dd1SL;`;GiJ;<;^K=heuFAZBx+Obvq;PTkN~6tx+GeP zo__l2|CE=P59va4)g}8hHa50gb=6hpl66D>fvMOB)_4U_Z ze+MblIZ*nUg}|OGR;-xw>tFwR-!*I2K-_X5Gt$8iqw*gTfRs{C7Sid12M@ljE3LK6 zB7j-w{rBJh$9d8Rp0H!a# z_~LvLb@XTRuF@LD7)M&i4+TI^%+;`)RH$Fj6jLw&qQjo(>c2E=mLjCL$QWhTV z^p6XdjydY6qkan(m6je@h=SIW$BY>R9WIm1dS4*@5CDV$$iMKy3kOrDzfH<5%xzb3 z2K$f|GoL#BY;yL&X$UI`z8W5Ygl~~95EXz>J;X0O`6aX?G*tP_Gtb;jR^$MSS>OE1 zE3b^Y>86|JP+5rIWM6<}pEJ~QnGPUUM7vU_K1qI*gV5npafXMOa#yZ+{PD-9Y4%~W zJyk_CN&qPXfOa<@_`NB=>Kbxbl2yOitcOCqbm`JpDFfm-Di0By$o&v1AX2R? z(*dMR;XCfQkjS8DLo(x)}(mqf=z2_W2_&3Y)*2vS#& zE_BV1Awzb9NM=tu$KA*vIPQWAE_j8?CF6of;_;#>lF0y4Z*4_IMe(DLKKgc9S=n}o zCBae10Zxi{Z6M#tSu;o*lLK4-@rcf1~EFWypgGB$ippFaIL0?=go zX`1bA(Ho)$5Sp#@IojE*uOMCLtbO*`=P2oxU>5r3n{OtZbka$8Qu$Q%xh)<*%5ot+ zq5rsX<36A_w8S*qmoHylNAa%T*4Ea}*X#qcy*-voIsoKal+;$3^<|}{r2{EWc3)*> zWlxJ)Uw`kt_wG*CC!R4Q&H7AaAlG;D)KgF0HfYeGu{N`vywP{vdh4yvQpd8{&K}&h zun*qYbO4B12nw|dw9;Ndy3VhTJMOr1z(UNfU?H&V!i5W`9DD4swD@64KCLa9ft2_5 z>Z`Bb^}quUoJwYU7c<^9fByV$s8i3?;9;|!Qx4kNdFcWW+Q+FfFzZWcucVjdcJguk z1i@i;E&@ap#N9}tnFFr8@=BzaChJviYagV1U8XUR8$Y`1uDf2?bI(0TnPxksRkTt# z;8OC|&d>njcvpKBO&36Kz4ewgm`b`zD#6sC!H{M>6zYm2k34cDG0}|_>r-aE^iY$L zFr9LWur_kCalMp*(AEnw4M57&CF|r^a`{ggP78YPPK$YSa+glPnofB@*J<#u*&fE5 z=>ll#)Twa*LO##|2OJO*0_fm_51vi;SMCBbr(MV88*jW3CV<@BCTf(5lkK$APTNz8?qqsl3TMrl zIBrSuLL zz!Yq~{=*MH{1aW5F=l$O3-+r@u)1UF;z5o!1PRQ>RHh|Fo5M?SCn|8#>`jgnchZwL7q6`d#7fE}n z>nYi7J1WO1wQaRH+t@|%mt_io(1|M8NaEuQqVOW_IL>n>bM_XBRKKj*2l1}dP(_&nAc!wDm6~Q*jHSW5l+4#Wo}xqFKl|j9PkvA5;c;fgIqVK}bD~L% zPNO!!I#PoNQ9^@P_t8fmjn?dk@Ip{dbgF~LFAyu#mBWS&yP3i_JAs9uz!Q+0DQodY z@=j0D0OI`VRPPmP`HTY)-atzE988^eDupk0r#EmBvCnlRN|4@=YMN>)odp0v7bztR z@K?kF7m@e71WZT(qV)z=-b!gBa9jew5Fud#C@%e#`d|pPVFG>jr8ay(vqc}EK0wS5 zj#Ftor1FfRm(3Ia@f(O35lmWmXz?~;W&;Ka9fpB}1(HgdYAPLud%-)b{4%-?_>B$X z5=uJ;4{gBjSWqs!O{Tx14d@5xf&ez|1=d3w&=2T?uo<{bPm(DBVkH{NB!Gh*g9p(D z2O&BPNn+e_VVLb^hp~4UAcigir8X8@h=maVVg_(~z23ILl5sM$0r$rz^dmekKnoCI zM|(0NHkK&>Vrzt_RAbdGH6_w?I`!k5}*7J03w2i0v z;;oN*Aq0pr?gP9~+y{7(WFKV2LJXM%AO;Z+q@0J(YxE^t^fBpI$6iq0o7ad$Nxr{q zM>}ujdpX+Bk$sTTb7dNUQfhp}h0VUnh&MjsXHL2LEPzt(vg`%22eJUl;-OtVkOfe? dx-Wb2{{t%n0DvX5CmR3&002ovPDHLkV1j1%@)`gD literal 0 HcmV?d00001 diff --git a/Application/src/main/res/layout-land/fragment_camera2_video.xml b/Application/src/main/res/layout-land/fragment_camera2_video.xml new file mode 100644 index 0000000..aa139a9 --- /dev/null +++ b/Application/src/main/res/layout-land/fragment_camera2_video.xml @@ -0,0 +1,58 @@ + + + + + + + +