| /* |
| * Copyright (C) 2012 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.android.testingcamera; |
| |
| import android.Manifest; |
| import android.annotation.SuppressLint; |
| import android.app.Activity; |
| import android.app.FragmentManager; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.graphics.ImageFormat; |
| import android.hardware.Camera; |
| import android.hardware.Camera.Parameters; |
| import android.hardware.Camera.ErrorCallback; |
| import android.media.CamcorderProfile; |
| import android.media.MediaRecorder; |
| import android.media.MediaScannerConnection; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.os.SystemClock; |
| import android.view.OrientationEventListener; |
| import android.view.View; |
| import android.view.Surface; |
| import android.view.SurfaceHolder; |
| import android.view.SurfaceView; |
| import android.view.View.OnClickListener; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.CheckBox; |
| import android.widget.LinearLayout; |
| import android.widget.LinearLayout.LayoutParams; |
| import android.widget.SeekBar; |
| import android.widget.Spinner; |
| import android.widget.TextView; |
| import android.widget.ToggleButton; |
| import android.renderscript.RenderScript; |
| import android.text.Layout; |
| import android.text.method.ScrollingMovementMethod; |
| import android.util.Log; |
| import android.util.SparseArray; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.text.SimpleDateFormat; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * A simple test application for the camera API. |
| * |
| * The goal of this application is to allow all camera API features to be |
| * exercised, and all information provided by the API to be shown. |
| */ |
| public class TestingCamera extends Activity |
| implements SurfaceHolder.Callback, Camera.PreviewCallback, |
| Camera.ErrorCallback { |
| |
| /** UI elements */ |
| private SurfaceView mPreviewView; |
| private SurfaceHolder mPreviewHolder; |
| private LinearLayout mPreviewColumn; |
| |
| private SurfaceView mCallbackView; |
| private SurfaceHolder mCallbackHolder; |
| |
| private Spinner mCameraSpinner; |
| private CheckBox mKeepOpenCheckBox; |
| private Button mInfoButton; |
| private Spinner mPreviewSizeSpinner; |
| private Spinner mPreviewFrameRateSpinner; |
| private ToggleButton mPreviewToggle; |
| private ToggleButton mHDRToggle; |
| private Spinner mAutofocusModeSpinner; |
| private Button mAutofocusButton; |
| private Button mCancelAutofocusButton; |
| private TextView mFlashModeSpinnerLabel; |
| private Spinner mFlashModeSpinner; |
| private ToggleButton mExposureLockToggle; |
| private Spinner mSnapshotSizeSpinner; |
| private Button mTakePictureButton; |
| private Spinner mCamcorderProfileSpinner; |
| private Spinner mVideoRecordSizeSpinner; |
| private Spinner mVideoFrameRateSpinner; |
| private ToggleButton mRecordToggle; |
| private CheckBox mRecordHandoffCheckBox; |
| private ToggleButton mRecordStabilizationToggle; |
| private ToggleButton mRecordHintToggle; |
| private ToggleButton mLockCameraToggle; |
| private Spinner mCallbackFormatSpinner; |
| private ToggleButton mCallbackToggle; |
| private TextView mColorEffectSpinnerLabel; |
| private Spinner mColorEffectSpinner; |
| private SeekBar mZoomSeekBar; |
| |
| private TextView mLogView; |
| |
| SnapshotDialogFragment mSnapshotDialog = null; |
| |
| private Set<View> mOpenOnlyControls = new HashSet<View>(); |
| private Set<View> mPreviewOnlyControls = new HashSet<View>(); |
| |
| private SparseArray<String> mFormatNames; |
| |
| /** Camera state */ |
| private int mCameraId; |
| private Camera mCamera; |
| private Camera.Parameters mParams; |
| private List<Camera.Size> mPreviewSizes; |
| private int mPreviewSize = 0; |
| private List<Integer> mPreviewFrameRates; |
| private int mPreviewFrameRate = 0; |
| private List<Integer> mPreviewFormats; |
| private int mPreviewFormat = 0; |
| private List<String> mAfModes; |
| private int mAfMode = 0; |
| private List<String> mFlashModes; |
| private int mFlashMode = 0; |
| private List<Camera.Size> mSnapshotSizes; |
| private int mSnapshotSize = 0; |
| private List<CamcorderProfile> mCamcorderProfiles; |
| private int mCamcorderProfile = 0; |
| private List<Camera.Size> mVideoRecordSizes; |
| private int mVideoRecordSize = 0; |
| private List<Integer> mVideoFrameRates; |
| private int mVideoFrameRate = 0; |
| private List<String> mColorEffects; |
| private int mColorEffect = 0; |
| private int mZoom = 0; |
| |
| private MediaRecorder mRecorder; |
| private File mRecordingFile; |
| |
| private RenderScript mRS; |
| |
| private boolean mCallbacksEnabled = false; |
| private CallbackProcessor mCallbackProcessor = null; |
| long mLastCallbackTimestamp = -1; |
| float mCallbackAvgFrameDuration = 30; |
| int mCallbackFrameCount = 0; |
| private static final float MEAN_FPS_HISTORY_COEFF = 0.9f; |
| private static final float MEAN_FPS_MEASUREMENT_COEFF = 0.1f; |
| private static final int FPS_REPORTING_PERIOD = 200; // frames |
| private static final int CALLBACK_BUFFER_COUNT = 3; |
| |
| private static final int CAMERA_UNINITIALIZED = 0; |
| private static final int CAMERA_OPEN = 1; |
| private static final int CAMERA_PREVIEW = 2; |
| private static final int CAMERA_TAKE_PICTURE = 3; |
| private static final int CAMERA_RECORD = 4; |
| private int mState = CAMERA_UNINITIALIZED; |
| |
| private static final int NO_CAMERA_ID = -1; |
| |
| /** Misc variables */ |
| |
| private static final String TAG = "TestingCamera"; |
| private static final int PERMISSIONS_REQUEST_CAMERA = 1; |
| private static final int PERMISSIONS_REQUEST_RECORDING = 2; |
| static final int PERMISSIONS_REQUEST_SNAPSHOT = 3; |
| private OrientationEventHandler mOrientationHandler; |
| |
| /** Activity lifecycle */ |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| |
| setContentView(R.layout.main); |
| |
| mPreviewColumn = (LinearLayout) findViewById(R.id.preview_column); |
| |
| mPreviewView = (SurfaceView) findViewById(R.id.preview); |
| mPreviewView.getHolder().addCallback(this); |
| |
| mCallbackView = (SurfaceView)findViewById(R.id.callback_view); |
| |
| mCameraSpinner = (Spinner) findViewById(R.id.camera_spinner); |
| mCameraSpinner.setOnItemSelectedListener(mCameraSpinnerListener); |
| |
| mKeepOpenCheckBox = (CheckBox) findViewById(R.id.keep_open_checkbox); |
| |
| mInfoButton = (Button) findViewById(R.id.info_button); |
| mInfoButton.setOnClickListener(mInfoButtonListener); |
| mOpenOnlyControls.add(mInfoButton); |
| |
| mPreviewSizeSpinner = (Spinner) findViewById(R.id.preview_size_spinner); |
| mPreviewSizeSpinner.setOnItemSelectedListener(mPreviewSizeListener); |
| mOpenOnlyControls.add(mPreviewSizeSpinner); |
| |
| mPreviewFrameRateSpinner = (Spinner) findViewById(R.id.preview_frame_rate_spinner); |
| mPreviewFrameRateSpinner.setOnItemSelectedListener(mPreviewFrameRateListener); |
| mOpenOnlyControls.add(mPreviewFrameRateSpinner); |
| |
| mHDRToggle = (ToggleButton) findViewById(R.id.hdr_mode); |
| mHDRToggle.setOnClickListener(mHDRToggleListener); |
| mOpenOnlyControls.add(mHDRToggle); |
| |
| mPreviewToggle = (ToggleButton) findViewById(R.id.start_preview); |
| mPreviewToggle.setOnClickListener(mPreviewToggleListener); |
| mOpenOnlyControls.add(mPreviewToggle); |
| |
| mAutofocusModeSpinner = (Spinner) findViewById(R.id.af_mode_spinner); |
| mAutofocusModeSpinner.setOnItemSelectedListener(mAutofocusModeListener); |
| mOpenOnlyControls.add(mAutofocusModeSpinner); |
| |
| mAutofocusButton = (Button) findViewById(R.id.af_button); |
| mAutofocusButton.setOnClickListener(mAutofocusButtonListener); |
| mPreviewOnlyControls.add(mAutofocusButton); |
| |
| mCancelAutofocusButton = (Button) findViewById(R.id.af_cancel_button); |
| mCancelAutofocusButton.setOnClickListener(mCancelAutofocusButtonListener); |
| mPreviewOnlyControls.add(mCancelAutofocusButton); |
| |
| mFlashModeSpinnerLabel = (TextView) findViewById(R.id.flash_mode_spinner_label); |
| |
| mFlashModeSpinner = (Spinner) findViewById(R.id.flash_mode_spinner); |
| mFlashModeSpinner.setOnItemSelectedListener(mFlashModeListener); |
| mOpenOnlyControls.add(mFlashModeSpinner); |
| |
| mExposureLockToggle = (ToggleButton) findViewById(R.id.exposure_lock); |
| mExposureLockToggle.setOnClickListener(mExposureLockToggleListener); |
| mOpenOnlyControls.add(mExposureLockToggle); |
| |
| mZoomSeekBar = (SeekBar) findViewById(R.id.zoom_seekbar); |
| mZoomSeekBar.setOnSeekBarChangeListener(mZoomSeekBarListener); |
| |
| mSnapshotSizeSpinner = (Spinner) findViewById(R.id.snapshot_size_spinner); |
| mSnapshotSizeSpinner.setOnItemSelectedListener(mSnapshotSizeListener); |
| mOpenOnlyControls.add(mSnapshotSizeSpinner); |
| |
| mTakePictureButton = (Button) findViewById(R.id.take_picture); |
| mTakePictureButton.setOnClickListener(mTakePictureListener); |
| mPreviewOnlyControls.add(mTakePictureButton); |
| |
| mCamcorderProfileSpinner = (Spinner) findViewById(R.id.camcorder_profile_spinner); |
| mCamcorderProfileSpinner.setOnItemSelectedListener(mCamcorderProfileListener); |
| mOpenOnlyControls.add(mCamcorderProfileSpinner); |
| |
| mVideoRecordSizeSpinner = (Spinner) findViewById(R.id.video_record_size_spinner); |
| mVideoRecordSizeSpinner.setOnItemSelectedListener(mVideoRecordSizeListener); |
| mOpenOnlyControls.add(mVideoRecordSizeSpinner); |
| |
| mVideoFrameRateSpinner = (Spinner) findViewById(R.id.video_frame_rate_spinner); |
| mVideoFrameRateSpinner.setOnItemSelectedListener(mVideoFrameRateListener); |
| mOpenOnlyControls.add(mVideoFrameRateSpinner); |
| |
| mRecordToggle = (ToggleButton) findViewById(R.id.start_record); |
| mRecordToggle.setOnClickListener(mRecordToggleListener); |
| mPreviewOnlyControls.add(mRecordToggle); |
| |
| mRecordHandoffCheckBox = (CheckBox) findViewById(R.id.record_handoff_checkbox); |
| |
| mRecordStabilizationToggle = (ToggleButton) findViewById(R.id.record_stabilization); |
| mRecordStabilizationToggle.setOnClickListener(mRecordStabilizationToggleListener); |
| mOpenOnlyControls.add(mRecordStabilizationToggle); |
| |
| mRecordHintToggle = (ToggleButton) findViewById(R.id.record_hint); |
| mRecordHintToggle.setOnClickListener(mRecordHintToggleListener); |
| mOpenOnlyControls.add(mRecordHintToggle); |
| |
| mLockCameraToggle = (ToggleButton) findViewById(R.id.lock_camera); |
| mLockCameraToggle.setOnClickListener(mLockCameraToggleListener); |
| mLockCameraToggle.setChecked(true); // ON by default |
| mOpenOnlyControls.add(mLockCameraToggle); |
| |
| mCallbackFormatSpinner = (Spinner) findViewById(R.id.callback_format_spinner); |
| mCallbackFormatSpinner.setOnItemSelectedListener(mCallbackFormatListener); |
| mOpenOnlyControls.add(mCallbackFormatSpinner); |
| |
| mCallbackToggle = (ToggleButton) findViewById(R.id.enable_callbacks); |
| mCallbackToggle.setOnClickListener(mCallbackToggleListener); |
| mOpenOnlyControls.add(mCallbackToggle); |
| |
| mColorEffectSpinnerLabel = (TextView) findViewById(R.id.color_effect_spinner_label); |
| |
| mColorEffectSpinner = (Spinner) findViewById(R.id.color_effect_spinner); |
| mColorEffectSpinner.setOnItemSelectedListener(mColorEffectListener); |
| mOpenOnlyControls.add(mColorEffectSpinner); |
| |
| mLogView = (TextView) findViewById(R.id.log); |
| mLogView.setMovementMethod(new ScrollingMovementMethod()); |
| |
| mOpenOnlyControls.addAll(mPreviewOnlyControls); |
| |
| mFormatNames = new SparseArray<String>(7); |
| mFormatNames.append(ImageFormat.JPEG, "JPEG"); |
| mFormatNames.append(ImageFormat.NV16, "NV16"); |
| mFormatNames.append(ImageFormat.NV21, "NV21"); |
| mFormatNames.append(ImageFormat.RGB_565, "RGB_565"); |
| mFormatNames.append(ImageFormat.UNKNOWN, "UNKNOWN"); |
| mFormatNames.append(ImageFormat.YUY2, "YUY2"); |
| mFormatNames.append(ImageFormat.YV12, "YV12"); |
| |
| int numCameras = Camera.getNumberOfCameras(); |
| String[] cameraNames = new String[numCameras + 1]; |
| cameraNames[0] = "None"; |
| for (int i = 0; i < numCameras; i++) { |
| cameraNames[i + 1] = "Camera " + i; |
| } |
| |
| mCameraSpinner.setAdapter( |
| new ArrayAdapter<String>(this, |
| R.layout.spinner_item, cameraNames)); |
| if (numCameras > 0) { |
| mCameraId = 0; |
| mCameraSpinner.setSelection(mCameraId + 1); |
| } else { |
| resetCamera(); |
| mCameraSpinner.setSelection(0); |
| } |
| |
| mRS = RenderScript.create(this); |
| |
| mOrientationHandler = new OrientationEventHandler(this); |
| } |
| |
| private static class OrientationEventHandler extends OrientationEventListener { |
| private TestingCamera mActivity; |
| private int mCurrentRotation = -1; |
| OrientationEventHandler(TestingCamera activity) { |
| super(activity); |
| mActivity = activity; |
| } |
| |
| @Override |
| public void onOrientationChanged(int orientation) { |
| if (mActivity != null) { |
| int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation(); |
| if (mCurrentRotation != rotation) { |
| mCurrentRotation = rotation; |
| mActivity.runOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| mActivity.setCameraDisplayOrientation(); |
| mActivity.resizePreview(); |
| } |
| }); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| log("onResume: Setting up"); |
| setUpCamera(); |
| mOrientationHandler.enable(); |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| if (mState == CAMERA_RECORD) { |
| stopRecording(false); |
| } |
| if (mKeepOpenCheckBox.isChecked()) { |
| log("onPause: Not releasing camera"); |
| |
| if (mState == CAMERA_PREVIEW) { |
| mCamera.stopPreview(); |
| mState = CAMERA_OPEN; |
| } |
| } else { |
| log("onPause: Releasing camera"); |
| |
| if (mCamera != null) { |
| mCamera.release(); |
| } |
| mState = CAMERA_UNINITIALIZED; |
| } |
| mOrientationHandler.disable(); |
| } |
| |
| @Override |
| public void onRequestPermissionsResult (int requestCode, String[] permissions, |
| int[] grantResults) { |
| if (requestCode == PERMISSIONS_REQUEST_CAMERA) { |
| if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { |
| log("Camera permission granted"); |
| setUpCamera(); |
| } else { |
| log("Camera permission denied, can't do anything"); |
| finish(); |
| } |
| } else if (requestCode == PERMISSIONS_REQUEST_RECORDING) { |
| mRecordToggle.setChecked(false); |
| for (int i = 0; i < grantResults.length; i++) { |
| if (grantResults[i] == PackageManager.PERMISSION_DENIED) { |
| log("Recording permission " + permissions[i] + " denied"); |
| return; |
| } |
| log("Recording permissions granted"); |
| setUpCamera(); |
| } |
| } else if (requestCode == PERMISSIONS_REQUEST_SNAPSHOT) { |
| if (mSnapshotDialog != null) { |
| mSnapshotDialog.onRequestPermissionsResult(requestCode, permissions, |
| grantResults); |
| } |
| } |
| |
| } |
| |
| /** SurfaceHolder.Callback methods */ |
| @Override |
| public void surfaceChanged(SurfaceHolder holder, |
| int format, |
| int width, |
| int height) { |
| if (holder == mPreviewView.getHolder()) { |
| if (mState >= CAMERA_OPEN) { |
| final int previewWidth = |
| mPreviewSizes.get(mPreviewSize).width; |
| final int previewHeight = |
| mPreviewSizes.get(mPreviewSize).height; |
| |
| if ( Math.abs((float)previewWidth / previewHeight - |
| (float)width/height) > 0.01f) { |
| Handler h = new Handler(); |
| h.post(new Runnable() { |
| @Override |
| public void run() { |
| layoutPreview(); |
| } |
| }); |
| } |
| } |
| |
| if (mPreviewHolder != null || mState == CAMERA_UNINITIALIZED) { |
| return; |
| } |
| log("Surface holder available: " + width + " x " + height); |
| mPreviewHolder = holder; |
| try { |
| if (mCamera != null) { |
| mCamera.setPreviewDisplay(holder); |
| } |
| } catch (IOException e) { |
| logE("Unable to set up preview!"); |
| } |
| } else if (holder == mCallbackView.getHolder()) { |
| mCallbackHolder = holder; |
| } |
| } |
| |
| @Override |
| public void surfaceCreated(SurfaceHolder holder) { |
| |
| } |
| |
| @Override |
| public void surfaceDestroyed(SurfaceHolder holder) { |
| mPreviewHolder = null; |
| } |
| |
| public void setCameraDisplayOrientation() { |
| android.hardware.Camera.CameraInfo info = |
| new android.hardware.Camera.CameraInfo(); |
| android.hardware.Camera.getCameraInfo(mCameraId, info); |
| int rotation = getWindowManager().getDefaultDisplay() |
| .getRotation(); |
| int degrees = 0; |
| switch (rotation) { |
| case Surface.ROTATION_0: degrees = 0; break; |
| case Surface.ROTATION_90: degrees = 90; break; |
| case Surface.ROTATION_180: degrees = 180; break; |
| case Surface.ROTATION_270: degrees = 270; break; |
| } |
| |
| int result; |
| if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { |
| result = (info.orientation + degrees) % 360; |
| result = (360 - result) % 360; // compensate the mirror |
| } else { // back-facing |
| result = (info.orientation - degrees + 360) % 360; |
| } |
| log(String.format( |
| "Camera sensor orientation %d, UI rotation %d, facing %s. Final orientation %d", |
| info.orientation, rotation, |
| info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT ? "FRONT" : "BACK", |
| result)); |
| mCamera.setDisplayOrientation(result); |
| } |
| |
| /** UI controls enable/disable for all open-only controls */ |
| private void enableOpenOnlyControls(boolean enabled) { |
| for (View v : mOpenOnlyControls) { |
| v.setEnabled(enabled); |
| } |
| } |
| |
| /** UI controls enable/disable for all preview-only controls */ |
| private void enablePreviewOnlyControls(boolean enabled) { |
| for (View v : mPreviewOnlyControls) { |
| v.setEnabled(enabled); |
| } |
| } |
| |
| /** UI listeners */ |
| |
| private AdapterView.OnItemSelectedListener mCameraSpinnerListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| int cameraId = pos - 1; |
| if (mCameraId != cameraId) { |
| resetCamera(); |
| mCameraId = cameraId; |
| mPreviewToggle.setChecked(false); |
| setUpCamera(); |
| } |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private OnClickListener mInfoButtonListener = new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mCameraId != NO_CAMERA_ID) { |
| FragmentManager fm = getFragmentManager(); |
| InfoDialogFragment infoDialog = new InfoDialogFragment(); |
| infoDialog.updateInfo(mCameraId, mCamera); |
| infoDialog.show(fm, "info_dialog_fragment"); |
| } |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mPreviewSizeListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mPreviewSize) return; |
| if (mState == CAMERA_PREVIEW) { |
| log("Stopping preview and callbacks to switch resolutions"); |
| stopCallbacks(); |
| mCamera.stopPreview(); |
| } |
| |
| mPreviewSize = pos; |
| int width = mPreviewSizes.get(mPreviewSize).width; |
| int height = mPreviewSizes.get(mPreviewSize).height; |
| mParams.setPreviewSize(width, height); |
| |
| log("Setting preview size to " + width + "x" + height); |
| |
| mCamera.setParameters(mParams); |
| resizePreview(); |
| |
| if (mState == CAMERA_PREVIEW) { |
| log("Restarting preview"); |
| mCamera.startPreview(); |
| } |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mPreviewFrameRateListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mPreviewFrameRate) return; |
| mPreviewFrameRate = pos; |
| mParams.setPreviewFrameRate(mPreviewFrameRates.get(mPreviewFrameRate)); |
| |
| log("Setting preview frame rate to " + ((TextView)view).getText()); |
| |
| mCamera.setParameters(mParams); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private View.OnClickListener mHDRToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mState == CAMERA_TAKE_PICTURE) { |
| logE("Can't change preview state while taking picture!"); |
| return; |
| } |
| |
| if (mHDRToggle.isChecked()) { |
| log("Turning on HDR"); |
| mParams.setSceneMode(Camera.Parameters.SCENE_MODE_HDR); |
| } else { |
| log("Turning off HDR"); |
| mParams.setSceneMode(Camera.Parameters.SCENE_MODE_AUTO); |
| } |
| mCamera.setParameters(mParams); |
| } |
| }; |
| |
| private View.OnClickListener mPreviewToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (mState == CAMERA_TAKE_PICTURE) { |
| logE("Can't change preview state while taking picture!"); |
| return; |
| } |
| if (mPreviewToggle.isChecked()) { |
| log("Starting preview"); |
| mCamera.startPreview(); |
| mState = CAMERA_PREVIEW; |
| enablePreviewOnlyControls(true); |
| } else { |
| log("Stopping preview"); |
| mCamera.stopPreview(); |
| mState = CAMERA_OPEN; |
| |
| enablePreviewOnlyControls(false); |
| } |
| } |
| }; |
| |
| private OnItemSelectedListener mAutofocusModeListener = |
| new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mAfMode) return; |
| |
| mAfMode = pos; |
| String focusMode = mAfModes.get(mAfMode); |
| log("Setting focus mode to " + focusMode); |
| if (focusMode == Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE || |
| focusMode == Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO) { |
| mCamera.setAutoFocusMoveCallback(mAutofocusMoveCallback); |
| } |
| mParams.setFocusMode(focusMode); |
| |
| mCamera.setParameters(mParams); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| |
| } |
| }; |
| |
| private OnClickListener mAutofocusButtonListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| log("Triggering autofocus"); |
| mCamera.autoFocus(mAutofocusCallback); |
| } |
| }; |
| |
| private OnClickListener mCancelAutofocusButtonListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| log("Cancelling autofocus"); |
| mCamera.cancelAutoFocus(); |
| } |
| }; |
| |
| private Camera.AutoFocusCallback mAutofocusCallback = |
| new Camera.AutoFocusCallback() { |
| @Override |
| public void onAutoFocus(boolean success, Camera camera) { |
| log("Autofocus completed: " + (success ? "success" : "failure") ); |
| } |
| }; |
| |
| private Camera.AutoFocusMoveCallback mAutofocusMoveCallback = |
| new Camera.AutoFocusMoveCallback() { |
| @Override |
| public void onAutoFocusMoving(boolean start, Camera camera) { |
| log("Autofocus movement: " + (start ? "starting" : "stopped") ); |
| } |
| }; |
| |
| private OnItemSelectedListener mFlashModeListener = |
| new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mFlashMode) return; |
| |
| mFlashMode = pos; |
| String flashMode = mFlashModes.get(mFlashMode); |
| log("Setting flash mode to " + flashMode); |
| mParams.setFlashMode(flashMode); |
| mCamera.setParameters(mParams); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| |
| } |
| }; |
| |
| |
| private AdapterView.OnItemSelectedListener mSnapshotSizeListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mSnapshotSize) return; |
| |
| mSnapshotSize = pos; |
| int width = mSnapshotSizes.get(mSnapshotSize).width; |
| int height = mSnapshotSizes.get(mSnapshotSize).height; |
| log("Setting snapshot size to " + width + " x " + height); |
| |
| mParams.setPictureSize(width, height); |
| |
| mCamera.setParameters(mParams); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private View.OnClickListener mTakePictureListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| log("Taking picture"); |
| if (mState == CAMERA_PREVIEW) { |
| mState = CAMERA_TAKE_PICTURE; |
| enablePreviewOnlyControls(false); |
| mPreviewToggle.setChecked(false); |
| |
| mCamera.takePicture(mShutterCb, mRawCb, mPostviewCb, mJpegCb); |
| } else { |
| logE("Can't take picture while not running preview!"); |
| } |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mCamcorderProfileListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos != mCamcorderProfile) { |
| log("Setting camcorder profile to " + ((TextView)view).getText()); |
| mCamcorderProfile = pos; |
| } |
| |
| // Additionally change video recording size to match |
| mVideoRecordSize = 0; // "default", in case it's not found |
| int width = mCamcorderProfiles.get(pos).videoFrameWidth; |
| int height = mCamcorderProfiles.get(pos).videoFrameHeight; |
| for (int i = 0; i < mVideoRecordSizes.size(); i++) { |
| Camera.Size s = mVideoRecordSizes.get(i); |
| if (width == s.width && height == s.height) { |
| mVideoRecordSize = i; |
| break; |
| } |
| } |
| log("Setting video record size to " + mVideoRecordSize); |
| mVideoRecordSizeSpinner.setSelection(mVideoRecordSize); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mVideoRecordSizeListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mVideoRecordSize) return; |
| |
| log("Setting video record size to " + ((TextView)view).getText()); |
| mVideoRecordSize = pos; |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mVideoFrameRateListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mVideoFrameRate) return; |
| |
| log("Setting video frame rate to " + ((TextView)view).getText()); |
| mVideoFrameRate = pos; |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private View.OnClickListener mRecordToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (!mLockCameraToggle.isChecked()) { |
| logE("Re-lock camera before recording"); |
| return; |
| } |
| |
| mPreviewToggle.setEnabled(false); |
| if (mState == CAMERA_PREVIEW) { |
| startRecording(); |
| } else if (mState == CAMERA_RECORD) { |
| stopRecording(false); |
| } else { |
| logE("Can't toggle recording in current state!"); |
| } |
| mPreviewToggle.setEnabled(true); |
| } |
| }; |
| |
| private View.OnClickListener mRecordStabilizationToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| boolean on = ((ToggleButton) v).isChecked(); |
| mParams.setVideoStabilization(on); |
| |
| mCamera.setParameters(mParams); |
| } |
| }; |
| |
| private View.OnClickListener mRecordHintToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| boolean on = ((ToggleButton) v).isChecked(); |
| mParams.setRecordingHint(on); |
| |
| mCamera.setParameters(mParams); |
| } |
| }; |
| |
| private View.OnClickListener mLockCameraToggleListener = |
| new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| |
| if (mState == CAMERA_RECORD) { |
| logE("Stop recording before toggling lock"); |
| return; |
| } |
| |
| boolean on = ((ToggleButton) v).isChecked(); |
| |
| if (on) { |
| mCamera.lock(); |
| log("Locked camera"); |
| } else { |
| mCamera.unlock(); |
| log("Unlocked camera"); |
| } |
| } |
| }; |
| |
| private Camera.ShutterCallback mShutterCb = new Camera.ShutterCallback() { |
| @Override |
| public void onShutter() { |
| log("Shutter callback received"); |
| } |
| }; |
| |
| private Camera.PictureCallback mRawCb = new Camera.PictureCallback() { |
| @Override |
| public void onPictureTaken(byte[] data, Camera camera) { |
| log("Raw callback received"); |
| } |
| }; |
| |
| private Camera.PictureCallback mPostviewCb = new Camera.PictureCallback() { |
| @Override |
| public void onPictureTaken(byte[] data, Camera camera) { |
| log("Postview callback received"); |
| } |
| }; |
| |
| private Camera.PictureCallback mJpegCb = new Camera.PictureCallback() { |
| @Override |
| public void onPictureTaken(byte[] data, Camera camera) { |
| log("JPEG picture callback received"); |
| FragmentManager fm = getFragmentManager(); |
| mSnapshotDialog = new SnapshotDialogFragment(); |
| |
| mSnapshotDialog.updateImage(data); |
| mSnapshotDialog.show(fm, "snapshot_dialog_fragment"); |
| |
| mPreviewToggle.setEnabled(true); |
| |
| mState = CAMERA_OPEN; |
| } |
| }; |
| |
| private AdapterView.OnItemSelectedListener mCallbackFormatListener = |
| new AdapterView.OnItemSelectedListener() { |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| mPreviewFormat = pos; |
| |
| log("Setting preview format to " + |
| mFormatNames.get(mPreviewFormats.get(mPreviewFormat))); |
| |
| switch (mState) { |
| case CAMERA_UNINITIALIZED: |
| return; |
| case CAMERA_OPEN: |
| break; |
| case CAMERA_PREVIEW: |
| if (mCallbacksEnabled) { |
| log("Stopping preview and callbacks to switch formats"); |
| stopCallbacks(); |
| mCamera.stopPreview(); |
| } |
| break; |
| case CAMERA_RECORD: |
| logE("Can't update format while recording active"); |
| return; |
| } |
| |
| mParams.setPreviewFormat(mPreviewFormats.get(mPreviewFormat)); |
| mCamera.setParameters(mParams); |
| |
| if (mCallbacksEnabled) { |
| if (mState == CAMERA_PREVIEW) { |
| mCamera.startPreview(); |
| } |
| } |
| |
| configureCallbacks(mCallbackView.getWidth(), mCallbackView.getHeight()); |
| } |
| |
| public void onNothingSelected(AdapterView<?> parent) { |
| |
| } |
| }; |
| |
| private View.OnClickListener mCallbackToggleListener = |
| new View.OnClickListener() { |
| public void onClick(View v) { |
| if (mCallbacksEnabled) { |
| log("Disabling preview callbacks"); |
| stopCallbacks(); |
| mCallbacksEnabled = false; |
| resizePreview(); |
| mCallbackView.setVisibility(View.GONE); |
| |
| } else { |
| log("Enabling preview callbacks"); |
| mCallbacksEnabled = true; |
| resizePreview(); |
| mCallbackView.setVisibility(View.VISIBLE); |
| } |
| } |
| }; |
| |
| |
| // Internal methods |
| |
| void setUpCamera() { |
| if (mCameraId == NO_CAMERA_ID) return; |
| |
| log("Setting up camera " + mCameraId); |
| logIndent(1); |
| |
| if (mState < CAMERA_OPEN) { |
| log("Opening camera " + mCameraId); |
| |
| if (checkSelfPermission(Manifest.permission.CAMERA) |
| != PackageManager.PERMISSION_GRANTED) { |
| log("Requested camera permission"); |
| requestPermissions(new String[] {Manifest.permission.CAMERA}, |
| PERMISSIONS_REQUEST_CAMERA); |
| return; |
| } |
| |
| |
| try { |
| mCamera = Camera.open(mCameraId); |
| } catch (RuntimeException e) { |
| logE("Exception opening camera: " + e.getMessage()); |
| resetCamera(); |
| mCameraSpinner.setSelection(0); |
| logIndent(-1); |
| return; |
| } |
| mState = CAMERA_OPEN; |
| } |
| |
| mCamera.setErrorCallback(this); |
| |
| setCameraDisplayOrientation(); |
| mParams = mCamera.getParameters(); |
| mHDRToggle.setEnabled(false); |
| if (mParams != null) { |
| List<String> sceneModes = mParams.getSupportedSceneModes(); |
| if (sceneModes != null) { |
| for (String mode : sceneModes) { |
| if (Camera.Parameters.SCENE_MODE_HDR.equals(mode)){ |
| mHDRToggle.setEnabled(true); |
| break; |
| } |
| } |
| } else { |
| Log.i(TAG, "Supported scene modes is null"); |
| } |
| } |
| |
| // Set up preview size selection |
| |
| log("Configuring camera"); |
| logIndent(1); |
| |
| updatePreviewSizes(mParams); |
| updatePreviewFrameRate(mCameraId); |
| updatePreviewFormats(mParams); |
| updateAfModes(mParams); |
| updateFlashModes(mParams); |
| updateSnapshotSizes(mParams); |
| updateCamcorderProfile(mCameraId); |
| updateVideoRecordSize(mCameraId); |
| updateVideoFrameRate(mCameraId); |
| updateColorEffects(mParams); |
| |
| // Trigger updating video record size to match camcorder profile |
| if (mCamcorderProfile >= 0) { |
| mCamcorderProfileSpinner.setSelection(mCamcorderProfile); |
| } |
| |
| if (mParams.isVideoStabilizationSupported()) { |
| log("Video stabilization is supported"); |
| mRecordStabilizationToggle.setEnabled(true); |
| } else { |
| log("Video stabilization not supported"); |
| mRecordStabilizationToggle.setEnabled(false); |
| } |
| |
| if (mParams.isAutoExposureLockSupported()) { |
| log("Auto-Exposure locking is supported"); |
| mExposureLockToggle.setEnabled(true); |
| } else { |
| log("Auto-Exposure locking is not supported"); |
| mExposureLockToggle.setEnabled(false); |
| } |
| |
| if (mParams.isZoomSupported()) { |
| int maxZoom = mParams.getMaxZoom(); |
| mZoomSeekBar.setMax(maxZoom); |
| log("Zoom is supported, set max to " + maxZoom); |
| mZoomSeekBar.setEnabled(true); |
| } else { |
| log("Zoom is not supported"); |
| mZoomSeekBar.setEnabled(false); |
| } |
| |
| // Update parameters based on above updates |
| mCamera.setParameters(mParams); |
| |
| if (mPreviewHolder != null) { |
| log("Setting preview display"); |
| try { |
| mCamera.setPreviewDisplay(mPreviewHolder); |
| } catch(IOException e) { |
| Log.e(TAG, "Unable to set up preview!"); |
| } |
| } |
| |
| logIndent(-1); |
| |
| enableOpenOnlyControls(true); |
| |
| resizePreview(); |
| if (mPreviewToggle.isChecked()) { |
| log("Starting preview" ); |
| mCamera.startPreview(); |
| mState = CAMERA_PREVIEW; |
| } else { |
| mState = CAMERA_OPEN; |
| enablePreviewOnlyControls(false); |
| } |
| logIndent(-1); |
| } |
| |
| private void resetCamera() { |
| if (mState >= CAMERA_OPEN) { |
| log("Closing old camera"); |
| mCamera.release(); |
| } |
| mCamera = null; |
| mCameraId = NO_CAMERA_ID; |
| mState = CAMERA_UNINITIALIZED; |
| |
| enableOpenOnlyControls(false); |
| } |
| |
| private void updateAfModes(Parameters params) { |
| mAfModes = params.getSupportedFocusModes(); |
| |
| mAutofocusModeSpinner.setAdapter( |
| new ArrayAdapter<String>(this, R.layout.spinner_item, |
| mAfModes.toArray(new String[0]))); |
| |
| mAfMode = 0; |
| |
| params.setFocusMode(mAfModes.get(mAfMode)); |
| |
| log("Setting AF mode to " + mAfModes.get(mAfMode)); |
| } |
| |
| private void updateFlashModes(Parameters params) { |
| mFlashModes = params.getSupportedFlashModes(); |
| |
| if (mFlashModes != null) { |
| mFlashModeSpinnerLabel.setVisibility(View.VISIBLE); |
| mFlashModeSpinner.setVisibility(View.VISIBLE); |
| mFlashModeSpinner.setAdapter( |
| new ArrayAdapter<String>(this, R.layout.spinner_item, |
| mFlashModes.toArray(new String[0]))); |
| |
| mFlashMode = 0; |
| |
| params.setFlashMode(mFlashModes.get(mFlashMode)); |
| |
| log("Setting Flash mode to " + mFlashModes.get(mFlashMode)); |
| } else { |
| // this camera has no flash |
| mFlashModeSpinnerLabel.setVisibility(View.GONE); |
| mFlashModeSpinner.setVisibility(View.GONE); |
| } |
| } |
| |
| private View.OnClickListener mExposureLockToggleListener = |
| new View.OnClickListener() { |
| public void onClick(View v) { |
| boolean on = ((ToggleButton) v).isChecked(); |
| log("Auto-Exposure was " + mParams.getAutoExposureLock()); |
| mParams.setAutoExposureLock(on); |
| log("Auto-Exposure is now " + mParams.getAutoExposureLock()); |
| } |
| }; |
| |
| private final SeekBar.OnSeekBarChangeListener mZoomSeekBarListener = |
| new SeekBar.OnSeekBarChangeListener() { |
| @Override |
| public void onProgressChanged(SeekBar seekBar, int progress, |
| boolean fromUser) { |
| mZoom = progress; |
| mParams.setZoom(mZoom); |
| mCamera.setParameters(mParams); |
| } |
| @Override |
| public void onStartTrackingTouch(SeekBar seekBar) { } |
| @Override |
| public void onStopTrackingTouch(SeekBar seekBar) { |
| log("Zoom set to " + mZoom + " / " + mParams.getMaxZoom() + " (" + |
| ((float)(mParams.getZoomRatios().get(mZoom))/100) + "x)"); |
| } |
| }; |
| |
| private void updatePreviewSizes(Camera.Parameters params) { |
| mPreviewSizes = params.getSupportedPreviewSizes(); |
| |
| String[] availableSizeNames = new String[mPreviewSizes.size()]; |
| int i = 0; |
| for (Camera.Size previewSize: mPreviewSizes) { |
| availableSizeNames[i++] = |
| Integer.toString(previewSize.width) + " x " + |
| Integer.toString(previewSize.height); |
| } |
| mPreviewSizeSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, availableSizeNames)); |
| |
| mPreviewSize = 0; |
| |
| int width = mPreviewSizes.get(mPreviewSize).width; |
| int height = mPreviewSizes.get(mPreviewSize).height; |
| params.setPreviewSize(width, height); |
| log("Setting preview size to " + width + " x " + height); |
| } |
| |
| private void updatePreviewFrameRate(int cameraId) { |
| List<Integer> frameRates = mParams.getSupportedPreviewFrameRates(); |
| int defaultPreviewFrameRate = mParams.getPreviewFrameRate(); |
| |
| List<String> frameRateStrings = new ArrayList<String>(); |
| mPreviewFrameRates = new ArrayList<Integer>(); |
| |
| int currentIndex = 0; |
| for (Integer frameRate : frameRates) { |
| mPreviewFrameRates.add(frameRate); |
| if(frameRate == defaultPreviewFrameRate) { |
| frameRateStrings.add(frameRate.toString() + " (Default)"); |
| mPreviewFrameRate = currentIndex; |
| } else { |
| frameRateStrings.add(frameRate.toString()); |
| } |
| currentIndex++; |
| } |
| |
| String[] nameArray = (String[])frameRateStrings.toArray(new String[0]); |
| mPreviewFrameRateSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, nameArray)); |
| |
| mPreviewFrameRateSpinner.setSelection(mPreviewFrameRate); |
| log("Setting preview frame rate to " + nameArray[mPreviewFrameRate]); |
| } |
| |
| private void updatePreviewFormats(Camera.Parameters params) { |
| mPreviewFormats = params.getSupportedPreviewFormats(); |
| |
| String[] availableFormatNames = new String[mPreviewFormats.size()]; |
| int i = 0; |
| for (Integer previewFormat: mPreviewFormats) { |
| availableFormatNames[i++] = mFormatNames.get(previewFormat); |
| } |
| mCallbackFormatSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, availableFormatNames)); |
| |
| mPreviewFormat = 0; |
| mCallbacksEnabled = false; |
| mCallbackToggle.setChecked(false); |
| mCallbackView.setVisibility(View.GONE); |
| |
| params.setPreviewFormat(mPreviewFormats.get(mPreviewFormat)); |
| log("Setting preview format to " + |
| mFormatNames.get(mPreviewFormats.get(mPreviewFormat))); |
| } |
| |
| private void updateSnapshotSizes(Camera.Parameters params) { |
| String[] availableSizeNames; |
| mSnapshotSizes = params.getSupportedPictureSizes(); |
| |
| availableSizeNames = new String[mSnapshotSizes.size()]; |
| int i = 0; |
| for (Camera.Size snapshotSize : mSnapshotSizes) { |
| availableSizeNames[i++] = |
| Integer.toString(snapshotSize.width) + " x " + |
| Integer.toString(snapshotSize.height); |
| } |
| mSnapshotSizeSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, availableSizeNames)); |
| |
| mSnapshotSize = 0; |
| |
| int snapshotWidth = mSnapshotSizes.get(mSnapshotSize).width; |
| int snapshotHeight = mSnapshotSizes.get(mSnapshotSize).height; |
| params.setPictureSize(snapshotWidth, snapshotHeight); |
| log("Setting snapshot size to " + snapshotWidth + " x " + snapshotHeight); |
| } |
| |
| private void updateCamcorderProfile(int cameraId) { |
| // Have to query all of these individually, |
| final int PROFILES[] = new int[] { |
| CamcorderProfile.QUALITY_2160P, |
| CamcorderProfile.QUALITY_1080P, |
| CamcorderProfile.QUALITY_480P, |
| CamcorderProfile.QUALITY_720P, |
| CamcorderProfile.QUALITY_CIF, |
| CamcorderProfile.QUALITY_HIGH, |
| CamcorderProfile.QUALITY_LOW, |
| CamcorderProfile.QUALITY_QCIF, |
| CamcorderProfile.QUALITY_QVGA, |
| CamcorderProfile.QUALITY_TIME_LAPSE_2160P, |
| CamcorderProfile.QUALITY_TIME_LAPSE_1080P, |
| CamcorderProfile.QUALITY_TIME_LAPSE_480P, |
| CamcorderProfile.QUALITY_TIME_LAPSE_720P, |
| CamcorderProfile.QUALITY_TIME_LAPSE_CIF, |
| CamcorderProfile.QUALITY_TIME_LAPSE_HIGH, |
| CamcorderProfile.QUALITY_TIME_LAPSE_LOW, |
| CamcorderProfile.QUALITY_TIME_LAPSE_QCIF, |
| CamcorderProfile.QUALITY_TIME_LAPSE_QVGA |
| }; |
| |
| final String PROFILE_NAMES[] = new String[] { |
| "2160P", |
| "1080P", |
| "480P", |
| "720P", |
| "CIF", |
| "HIGH", |
| "LOW", |
| "QCIF", |
| "QVGA", |
| "TIME_LAPSE_2160P", |
| "TIME_LAPSE_1080P", |
| "TIME_LAPSE_480P", |
| "TIME_LAPSE_720P", |
| "TIME_LAPSE_CIF", |
| "TIME_LAPSE_HIGH", |
| "TIME_LAPSE_LOW", |
| "TIME_LAPSE_QCIF", |
| "TIME_LAPSE_QVGA" |
| }; |
| |
| List<String> availableCamcorderProfileNames = new ArrayList<String>(); |
| mCamcorderProfiles = new ArrayList<CamcorderProfile>(); |
| |
| for (int i = 0; i < PROFILES.length; i++) { |
| if (CamcorderProfile.hasProfile(cameraId, PROFILES[i])) { |
| availableCamcorderProfileNames.add(PROFILE_NAMES[i]); |
| mCamcorderProfiles.add(CamcorderProfile.get(cameraId, PROFILES[i])); |
| } |
| } |
| |
| String[] nameArray = (String[])availableCamcorderProfileNames.toArray(new String[0]); |
| mCamcorderProfileSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, nameArray)); |
| |
| if (availableCamcorderProfileNames.size() == 0) { |
| log("Camera " + cameraId + " doesn't support camcorder profile"); |
| mCamcorderProfile = -1; |
| return; |
| } |
| |
| mCamcorderProfile = 0; |
| log("Setting camcorder profile to " + nameArray[mCamcorderProfile]); |
| |
| } |
| |
| private void updateVideoRecordSize(int cameraId) { |
| List<Camera.Size> videoSizes = mParams.getSupportedVideoSizes(); |
| if (videoSizes == null) { // TODO: surface this to the user |
| log("Failed to get video size list, using preview sizes instead"); |
| videoSizes = mParams.getSupportedPreviewSizes(); |
| } |
| |
| List<String> availableVideoRecordSizes = new ArrayList<String>(); |
| mVideoRecordSizes = new ArrayList<Camera.Size>(); |
| |
| availableVideoRecordSizes.add("Default"); |
| mVideoRecordSizes.add(mCamera.new Size(0,0)); |
| |
| for (Camera.Size s : videoSizes) { |
| availableVideoRecordSizes.add(s.width + "x" + s.height); |
| mVideoRecordSizes.add(s); |
| } |
| String[] nameArray = (String[])availableVideoRecordSizes.toArray(new String[0]); |
| mVideoRecordSizeSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, nameArray)); |
| |
| mVideoRecordSize = 0; |
| log("Setting video record profile to " + nameArray[mVideoRecordSize]); |
| } |
| |
| private void updateVideoFrameRate(int cameraId) { |
| // Use preview framerates as video framerates |
| List<Integer> frameRates = mParams.getSupportedPreviewFrameRates(); |
| |
| List<String> frameRateStrings = new ArrayList<String>(); |
| mVideoFrameRates = new ArrayList<Integer>(); |
| |
| frameRateStrings.add("Default"); |
| mVideoFrameRates.add(0); |
| |
| for (Integer frameRate : frameRates) { |
| frameRateStrings.add(frameRate.toString()); |
| mVideoFrameRates.add(frameRate); |
| } |
| String[] nameArray = (String[])frameRateStrings.toArray(new String[0]); |
| mVideoFrameRateSpinner.setAdapter( |
| new ArrayAdapter<String>( |
| this, R.layout.spinner_item, nameArray)); |
| |
| mVideoFrameRate = 0; |
| log("Setting recording frame rate to " + nameArray[mVideoFrameRate]); |
| } |
| |
| void resizePreview() { |
| // Reset preview layout parameters, to trigger layout pass |
| // This will eventually call layoutPreview below |
| Resources res = getResources(); |
| mPreviewView.setLayoutParams( |
| new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, 0, |
| mCallbacksEnabled ? |
| res.getInteger(R.integer.preview_with_callback_weight): |
| res.getInteger(R.integer.preview_only_weight) )); |
| } |
| |
| void layoutPreview() { |
| int rotation = getWindowManager().getDefaultDisplay().getRotation(); |
| int width = mPreviewSizes.get(mPreviewSize).width; |
| int height = mPreviewSizes.get(mPreviewSize).height; |
| switch (rotation) { |
| case Surface.ROTATION_0: |
| case Surface.ROTATION_180: |
| // Portrait |
| // Switch the preview size so that the longer edge aligns with the taller |
| // dimension. |
| if (width > height) { |
| int tmp = height; |
| height = width; |
| width = tmp; |
| } |
| break; |
| case Surface.ROTATION_90: |
| case Surface.ROTATION_270: |
| // Landscape |
| // Possibly somewhat unlikely case but we should try to handle it too. |
| if (height > width) { |
| int tmp = height; |
| height = width; |
| width = tmp; |
| } |
| break; |
| } |
| |
| float previewAspect = ((float) width) / height; |
| |
| int viewHeight = mPreviewView.getHeight(); |
| int viewWidth = mPreviewView.getWidth(); |
| float viewAspect = ((float) viewWidth) / viewHeight; |
| if ( previewAspect > viewAspect) { |
| viewHeight = (int) (viewWidth / previewAspect); |
| } else { |
| viewWidth = (int) (viewHeight * previewAspect); |
| } |
| mPreviewView.setLayoutParams( |
| new LayoutParams(viewWidth, viewHeight)); |
| log("Setting layout params viewWidth: " + viewWidth + " viewHeight: " + viewHeight + |
| " display rotation: " + rotation); |
| |
| if (mCallbacksEnabled) { |
| int callbackHeight = mCallbackView.getHeight(); |
| int callbackWidth = mCallbackView.getWidth(); |
| float callbackAspect = ((float) callbackWidth) / callbackHeight; |
| if ( previewAspect > callbackAspect) { |
| callbackHeight = (int) (callbackWidth / previewAspect); |
| } else { |
| callbackWidth = (int) (callbackHeight * previewAspect); |
| } |
| mCallbackView.setLayoutParams( |
| new LayoutParams(callbackWidth, callbackHeight)); |
| configureCallbacks(callbackWidth, callbackHeight); |
| } |
| } |
| |
| |
| private void configureCallbacks(int callbackWidth, int callbackHeight) { |
| if (mState >= CAMERA_OPEN && mCallbacksEnabled) { |
| mCamera.setPreviewCallbackWithBuffer(null); |
| int width = mPreviewSizes.get(mPreviewSize).width; |
| int height = mPreviewSizes.get(mPreviewSize).height; |
| int format = mPreviewFormats.get(mPreviewFormat); |
| |
| mCallbackProcessor = new CallbackProcessor(width, height, format, |
| getResources(), mCallbackView, |
| callbackWidth, callbackHeight, mRS); |
| |
| int size = getCallbackBufferSize(width, height, format); |
| log("Configuring callbacks:" + width + " x " + height + |
| " , format " + format); |
| for (int i = 0; i < CALLBACK_BUFFER_COUNT; i++) { |
| mCamera.addCallbackBuffer(new byte[size]); |
| } |
| mCamera.setPreviewCallbackWithBuffer(this); |
| } |
| mLastCallbackTimestamp = -1; |
| mCallbackFrameCount = 0; |
| mCallbackAvgFrameDuration = 30; |
| } |
| |
| private void stopCallbacks() { |
| if (mState >= CAMERA_OPEN) { |
| mCamera.setPreviewCallbackWithBuffer(null); |
| if (mCallbackProcessor != null) { |
| if (!mCallbackProcessor.stop()) { |
| logE("Can't stop preview callback processing!"); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void onPreviewFrame(byte[] data, Camera camera) { |
| long timestamp = SystemClock.elapsedRealtime(); |
| if (mLastCallbackTimestamp != -1) { |
| long frameDuration = timestamp - mLastCallbackTimestamp; |
| mCallbackAvgFrameDuration = |
| mCallbackAvgFrameDuration * MEAN_FPS_HISTORY_COEFF + |
| frameDuration * MEAN_FPS_MEASUREMENT_COEFF; |
| } |
| mLastCallbackTimestamp = timestamp; |
| if (mState < CAMERA_PREVIEW || !mCallbacksEnabled) { |
| mCamera.addCallbackBuffer(data); |
| return; |
| } |
| mCallbackFrameCount++; |
| if (mCallbackFrameCount % FPS_REPORTING_PERIOD == 0) { |
| log("Got " + FPS_REPORTING_PERIOD + " callback frames, fps " |
| + 1e3/mCallbackAvgFrameDuration); |
| } |
| mCallbackProcessor.displayCallback(data); |
| |
| mCamera.addCallbackBuffer(data); |
| } |
| |
| @Override |
| public void onError(int error, Camera camera) { |
| String errorName; |
| switch (error) { |
| case Camera.CAMERA_ERROR_SERVER_DIED: |
| errorName = "SERVER_DIED"; |
| break; |
| case Camera.CAMERA_ERROR_UNKNOWN: |
| errorName = "UNKNOWN"; |
| break; |
| default: |
| errorName = "?"; |
| break; |
| } |
| logE("Camera error received: " + errorName + " (" + error + ")" ); |
| logE("Shutting down camera"); |
| resetCamera(); |
| mCameraSpinner.setSelection(0); |
| } |
| |
| static final int MEDIA_TYPE_IMAGE = 0; |
| static final int MEDIA_TYPE_VIDEO = 1; |
| @SuppressLint("SimpleDateFormat") |
| File getOutputMediaFile(int type){ |
| // To be safe, you should check that the SDCard is mounted |
| // using Environment.getExternalStorageState() before doing this. |
| |
| String state = Environment.getExternalStorageState(); |
| if (!Environment.MEDIA_MOUNTED.equals(state)) { |
| return null; |
| } |
| |
| File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory( |
| Environment.DIRECTORY_DCIM), "TestingCamera"); |
| // This location works best if you want the created images to be shared |
| // between applications and persist after your app has been uninstalled. |
| |
| // Create the storage directory if it does not exist |
| if (! mediaStorageDir.exists()){ |
| if (! mediaStorageDir.mkdirs()){ |
| logE("Failed to create directory for pictures/video"); |
| return null; |
| } |
| } |
| |
| // Create a media file name |
| String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); |
| File mediaFile; |
| if (type == MEDIA_TYPE_IMAGE){ |
| mediaFile = new File(mediaStorageDir.getPath() + File.separator + |
| "IMG_"+ timeStamp + ".jpg"); |
| } else if(type == MEDIA_TYPE_VIDEO) { |
| mediaFile = new File(mediaStorageDir.getPath() + File.separator + |
| "VID_"+ timeStamp + ".mp4"); |
| } else { |
| return null; |
| } |
| |
| return mediaFile; |
| } |
| |
| void notifyMediaScannerOfFile(File newFile, |
| final MediaScannerConnection.OnScanCompletedListener listener) { |
| final Handler h = new Handler(); |
| MediaScannerConnection.scanFile(this, |
| new String[] { newFile.toString() }, |
| null, |
| new MediaScannerConnection.OnScanCompletedListener() { |
| @Override |
| public void onScanCompleted(final String path, final Uri uri) { |
| h.post(new Runnable() { |
| @Override |
| public void run() { |
| log("MediaScanner notified: " + |
| path + " -> " + uri); |
| if (listener != null) |
| listener.onScanCompleted(path, uri); |
| } |
| }); |
| } |
| }); |
| } |
| |
| private void deleteFile(File badFile) { |
| if (badFile.exists()) { |
| boolean success = badFile.delete(); |
| if (success) log("Deleted file " + badFile.toString()); |
| else log("Unable to delete file " + badFile.toString()); |
| } |
| } |
| |
| private static final int BIT_RATE_1080P = 16000000; |
| private static final int BIT_RATE_MIN = 64000; |
| private static final int BIT_RATE_MAX = 40000000; |
| |
| private int getVideoBitRate(Camera.Size sz) { |
| int rate = BIT_RATE_1080P; |
| float scaleFactor = sz.height * sz.width / (float)(1920 * 1080); |
| rate = (int)(rate * scaleFactor); |
| |
| // Clamp to the MIN, MAX range. |
| return Math.max(BIT_RATE_MIN, Math.min(BIT_RATE_MAX, rate)); |
| } |
| |
| private void startRecording() { |
| log("Starting recording"); |
| |
| if ((checkSelfPermission(Manifest.permission.RECORD_AUDIO) |
| != PackageManager.PERMISSION_GRANTED) |
| || (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) |
| != PackageManager.PERMISSION_GRANTED)) { |
| log("Requesting recording permissions (audio, storage)"); |
| requestPermissions(new String[] { |
| Manifest.permission.RECORD_AUDIO, |
| Manifest.permission.WRITE_EXTERNAL_STORAGE}, |
| PERMISSIONS_REQUEST_RECORDING); |
| return; |
| } |
| |
| logIndent(1); |
| log("Configuring MediaRecoder"); |
| |
| mRecordHandoffCheckBox.setEnabled(false); |
| if (mRecordHandoffCheckBox.isChecked()) { |
| mCamera.release(); |
| } else { |
| mCamera.unlock(); |
| } |
| |
| if (mRecorder != null) { |
| mRecorder.release(); |
| } |
| |
| mRecorder = new MediaRecorder(); |
| mRecorder.setOnErrorListener(mRecordingErrorListener); |
| mRecorder.setOnInfoListener(mRecordingInfoListener); |
| if (!mRecordHandoffCheckBox.isChecked()) { |
| mRecorder.setCamera(mCamera); |
| } |
| mRecorder.setPreviewDisplay(mPreviewHolder.getSurface()); |
| |
| mRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER); |
| mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); |
| |
| Camera.Size videoRecordSize = mVideoRecordSizes.get(mVideoRecordSize); |
| if (mCamcorderProfile >= 0) { |
| mRecorder.setProfile(mCamcorderProfiles.get(mCamcorderProfile)); |
| } else { |
| mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); |
| mRecorder.setVideoEncodingBitRate(getVideoBitRate(videoRecordSize)); |
| mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264); |
| mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); |
| } |
| |
| if (videoRecordSize.width > 0 && videoRecordSize.height > 0) { |
| mRecorder.setVideoSize(videoRecordSize.width, videoRecordSize.height); |
| } |
| if (mVideoFrameRates.get(mVideoFrameRate) > 0) { |
| mRecorder.setVideoFrameRate(mVideoFrameRates.get(mVideoFrameRate)); |
| } |
| File outputFile = getOutputMediaFile(MEDIA_TYPE_VIDEO); |
| log("File name:" + outputFile.toString()); |
| mRecorder.setOutputFile(outputFile.toString()); |
| |
| boolean ready = false; |
| log("Preparing MediaRecorder"); |
| try { |
| mRecorder.prepare(); |
| ready = true; |
| } catch (Exception e) { |
| StringWriter writer = new StringWriter(); |
| e.printStackTrace(new PrintWriter(writer)); |
| logE("Exception preparing MediaRecorder:\n" + writer.toString()); |
| } |
| |
| if (ready) { |
| try { |
| log("Starting MediaRecorder"); |
| mRecorder.start(); |
| mState = CAMERA_RECORD; |
| log("Recording active"); |
| mRecordingFile = outputFile; |
| } catch (Exception e) { |
| StringWriter writer = new StringWriter(); |
| e.printStackTrace(new PrintWriter(writer)); |
| logE("Exception starting MediaRecorder:\n" + writer.toString()); |
| ready = false; |
| } |
| } |
| |
| if (!ready) { |
| mRecordToggle.setChecked(false); |
| mRecordHandoffCheckBox.setEnabled(true); |
| |
| if (mRecordHandoffCheckBox.isChecked()) { |
| mState = CAMERA_UNINITIALIZED; |
| setUpCamera(); |
| } |
| } |
| logIndent(-1); |
| } |
| |
| private MediaRecorder.OnErrorListener mRecordingErrorListener = |
| new MediaRecorder.OnErrorListener() { |
| @Override |
| public void onError(MediaRecorder mr, int what, int extra) { |
| logE("MediaRecorder reports error: " + what + ", extra " |
| + extra); |
| if (mState == CAMERA_RECORD) { |
| stopRecording(true); |
| } |
| } |
| }; |
| |
| private MediaRecorder.OnInfoListener mRecordingInfoListener = |
| new MediaRecorder.OnInfoListener() { |
| @Override |
| public void onInfo(MediaRecorder mr, int what, int extra) { |
| log("MediaRecorder reports info: " + what + ", extra " |
| + extra); |
| } |
| }; |
| |
| private void stopRecording(boolean error) { |
| log("Stopping recording"); |
| mRecordHandoffCheckBox.setEnabled(true); |
| mRecordToggle.setChecked(false); |
| if (mRecorder != null) { |
| try { |
| mRecorder.stop(); |
| } catch (RuntimeException e) { |
| // this can happen if there were no frames received by recorder |
| logE("Could not create output file"); |
| error = true; |
| } |
| |
| if (mRecordHandoffCheckBox.isChecked()) { |
| mState = CAMERA_UNINITIALIZED; |
| setUpCamera(); |
| } else { |
| mCamera.lock(); |
| mState = CAMERA_PREVIEW; |
| } |
| |
| if (!error) { |
| notifyMediaScannerOfFile(mRecordingFile, null); |
| } else { |
| deleteFile(mRecordingFile); |
| } |
| mRecordingFile = null; |
| } else { |
| logE("Recorder is unexpectedly null!"); |
| } |
| } |
| |
| static int getCallbackBufferSize(int width, int height, int format) { |
| int size = -1; |
| switch (format) { |
| case ImageFormat.NV21: |
| size = width * height * 3 / 2; |
| break; |
| case ImageFormat.YV12: |
| int y_stride = (int) (Math.ceil( width / 16.) * 16); |
| int y_size = y_stride * height; |
| int c_stride = (int) (Math.ceil(y_stride / 32.) * 16); |
| int c_size = c_stride * height/2; |
| size = y_size + c_size * 2; |
| break; |
| case ImageFormat.NV16: |
| case ImageFormat.RGB_565: |
| case ImageFormat.YUY2: |
| size = 2 * width * height; |
| break; |
| case ImageFormat.JPEG: |
| Log.e(TAG, "JPEG callback buffers not supported!"); |
| size = 0; |
| break; |
| case ImageFormat.UNKNOWN: |
| Log.e(TAG, "Unknown-format callback buffers not supported!"); |
| size = 0; |
| break; |
| } |
| return size; |
| } |
| |
| private OnItemSelectedListener mColorEffectListener = |
| new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, |
| View view, int pos, long id) { |
| if (pos == mColorEffect) return; |
| |
| mColorEffect = pos; |
| String colorEffect = mColorEffects.get(mColorEffect); |
| log("Setting color effect to " + colorEffect); |
| mParams.setColorEffect(colorEffect); |
| mCamera.setParameters(mParams); |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| } |
| }; |
| |
| private void updateColorEffects(Parameters params) { |
| mColorEffects = params.getSupportedColorEffects(); |
| if (mColorEffects != null) { |
| mColorEffectSpinnerLabel.setVisibility(View.VISIBLE); |
| mColorEffectSpinner.setVisibility(View.VISIBLE); |
| mColorEffectSpinner.setAdapter( |
| new ArrayAdapter<String>(this, R.layout.spinner_item, |
| mColorEffects.toArray(new String[0]))); |
| mColorEffect = 0; |
| params.setColorEffect(mColorEffects.get(mColorEffect)); |
| log("Setting Color Effect to " + mColorEffects.get(mColorEffect)); |
| } else { |
| mColorEffectSpinnerLabel.setVisibility(View.GONE); |
| mColorEffectSpinner.setVisibility(View.GONE); |
| } |
| } |
| |
| private int mLogIndentLevel = 0; |
| private String mLogIndent = "\t"; |
| /** Increment or decrement log indentation level */ |
| synchronized void logIndent(int delta) { |
| mLogIndentLevel += delta; |
| if (mLogIndentLevel < 0) mLogIndentLevel = 0; |
| char[] mLogIndentArray = new char[mLogIndentLevel + 1]; |
| for (int i = -1; i < mLogIndentLevel; i++) { |
| mLogIndentArray[i + 1] = '\t'; |
| } |
| mLogIndent = new String(mLogIndentArray); |
| } |
| |
| @SuppressLint("SimpleDateFormat") |
| SimpleDateFormat mDateFormatter = new SimpleDateFormat("HH:mm:ss.SSS"); |
| /** Log both to log text view and to device logcat */ |
| void log(String logLine) { |
| Log.d(TAG, logLine); |
| logAndScrollToBottom(logLine, mLogIndent); |
| } |
| |
| void logE(String logLine) { |
| Log.e(TAG, logLine); |
| logAndScrollToBottom(logLine, mLogIndent + "!!! "); |
| } |
| |
| synchronized private void logAndScrollToBottom(String logLine, String logIndent) { |
| StringBuffer logEntry = new StringBuffer(32); |
| logEntry.append("\n").append(mDateFormatter.format(new Date())).append(logIndent); |
| logEntry.append(logLine); |
| mLogView.append(logEntry); |
| final Layout layout = mLogView.getLayout(); |
| if (layout != null){ |
| int scrollDelta = layout.getLineBottom(mLogView.getLineCount() - 1) |
| - mLogView.getScrollY() - mLogView.getHeight(); |
| if(scrollDelta > 0) { |
| mLogView.scrollBy(0, scrollDelta); |
| } |
| } |
| } |
| } |
