/*
* Copyright (C) 2007 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.camera;
import com.android.camera.ui.CameraPicker;
import com.android.camera.ui.IndicatorControlContainer;
import com.android.camera.ui.IndicatorControlWheelContainer;
import com.android.camera.ui.PopupManager;
import com.android.camera.ui.Rotatable;
import com.android.camera.ui.RotateImageView;
import com.android.camera.ui.RotateLayout;
import com.android.camera.ui.RotateTextToast;
import com.android.camera.ui.SharePopup;
import com.android.camera.ui.ZoomControl;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences.Editor;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.Size;
import android.location.Location;
import android.media.CamcorderProfile;
import android.media.CameraProfile;
import android.media.MediaRecorder;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.SystemClock;
import android.provider.MediaStore;
import android.provider.MediaStore.Video;
import android.util.Log;
import android.view.GestureDetector;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.MotionEvent;
import android.view.OrientationEventListener;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import android.filterpacks.videosink.MediaRecorderStopException;
/**
* The Camcorder activity.
*/
public class VideoCamera extends ActivityBase
implements CameraPreference.OnPreferenceChangedListener,
ShutterButton.OnShutterButtonListener, SurfaceHolder.Callback,
MediaRecorder.OnErrorListener, MediaRecorder.OnInfoListener,
ModePicker.OnModeChangeListener, View.OnTouchListener,
EffectsRecorder.EffectsListener {
private static final String TAG = "videocamera";
private static final int CHECK_DISPLAY_ROTATION = 3;
private static final int CLEAR_SCREEN_DELAY = 4;
private static final int UPDATE_RECORD_TIME = 5;
private static final int ENABLE_SHUTTER_BUTTON = 6;
private static final int SHOW_TAP_TO_SNAPSHOT_TOAST = 7;
private static final int SCREEN_DELAY = 2 * 60 * 1000;
// The brightness settings used when it is set to automatic in the system.
// The reason why it is set to 0.7 is just because 1.0 is too bright.
private static final float DEFAULT_CAMERA_BRIGHTNESS = 0.7f;
private static final boolean SWITCH_CAMERA = true;
private static final boolean SWITCH_VIDEO = false;
private static final long SHUTTER_BUTTON_TIMEOUT = 500L; // 500ms
private static final int[] TIME_LAPSE_VIDEO_QUALITY = {
CamcorderProfile.QUALITY_TIME_LAPSE_1080P,
CamcorderProfile.QUALITY_TIME_LAPSE_720P,
CamcorderProfile.QUALITY_TIME_LAPSE_480P,
CamcorderProfile.QUALITY_TIME_LAPSE_CIF,
CamcorderProfile.QUALITY_TIME_LAPSE_QVGA,
CamcorderProfile.QUALITY_TIME_LAPSE_QCIF};
private static final int[] VIDEO_QUALITY = {
CamcorderProfile.QUALITY_1080P,
CamcorderProfile.QUALITY_720P,
CamcorderProfile.QUALITY_480P,
CamcorderProfile.QUALITY_CIF,
CamcorderProfile.QUALITY_QVGA,
CamcorderProfile.QUALITY_QCIF};
/**
* An unpublished intent flag requesting to start recording straight away
* and return as soon as recording is stopped.
* TODO: consider publishing by moving into MediaStore.
*/
private static final String EXTRA_QUICK_CAPTURE =
"android.intent.extra.quickCapture";
private boolean mSnapshotInProgress = false;
private static final String EFFECT_BG_FROM_GALLERY = "gallery";
private final CameraErrorCallback mErrorCallback = new CameraErrorCallback();
private ComboPreferences mPreferences;
private PreferenceGroup mPreferenceGroup;
private View mPreviewPanel; // The container of PreviewFrameLayout.
private PreviewFrameLayout mPreviewFrameLayout;
private SurfaceHolder mSurfaceHolder = null;
private IndicatorControlContainer mIndicatorControlContainer;
private int mSurfaceWidth;
private int mSurfaceHeight;
private View mReviewControl;
private RotateDialogController mRotateDialog;
private Toast mNoShareToast;
// An review image having same size as preview. It is displayed when
// recording is stopped in capture intent.
private ImageView mReviewImage;
// A popup window that contains a bigger thumbnail and a list of apps to share.
private SharePopup mSharePopup;
// The bitmap of the last captured video thumbnail and the URI of the
// original video.
private Thumbnail mThumbnail;
// An imageview showing showing the last captured picture thumbnail.
private RotateImageView mThumbnailView;
private Rotatable mReviewCancelButton;
private Rotatable mReviewDoneButton;
private Rotatable mReviewPlayButton;
private ModePicker mModePicker;
private ShutterButton mShutterButton;
private TextView mRecordingTimeView;
private RotateLayout mBgLearningMessageRotater;
private View mBgLearningMessageFrame;
private LinearLayout mLabelsLinearLayout;
private boolean mIsVideoCaptureIntent;
private boolean mQuickCapture;
private boolean mOpenCameraFail = false;
private boolean mCameraDisabled = false;
private long mStorageSpace;
private MediaRecorder mMediaRecorder;
private EffectsRecorder mEffectsRecorder;
private boolean mEffectsDisplayResult;
private int mEffectType = EffectsRecorder.EFFECT_NONE;
private Object mEffectParameter = null;
private String mEffectUriFromGallery = null;
private String mPrefVideoEffectDefault;
private boolean mResetEffect = true;
public static final String RESET_EFFECT_EXTRA = "reset_effect";
public static final String BACKGROUND_URI_GALLERY_EXTRA = "background_uri_gallery";
private boolean mMediaRecorderRecording = false;
private long mRecordingStartTime;
private boolean mRecordingTimeCountsDown = false;
private RotateLayout mRecordingTimeRect;
private long mOnResumeTime;
// The video file that the hardware camera is about to record into
// (or is recording into.)
private String mVideoFilename;
private ParcelFileDescriptor mVideoFileDescriptor;
// The video file that has already been recorded, and that is being
// examined by the user.
private String mCurrentVideoFilename;
private Uri mCurrentVideoUri;
private ContentValues mCurrentVideoValues;
private CamcorderProfile mProfile;
// The video duration limit. 0 menas no limit.
private int mMaxVideoDurationInMs;
// Time Lapse parameters.
private boolean mCaptureTimeLapse = false;
// Default 0. If it is larger than 0, the camcorder is in time lapse mode.
private int mTimeBetweenTimeLapseFrameCaptureMs = 0;
private View mTimeLapseLabel;
private int mDesiredPreviewWidth;
private int mDesiredPreviewHeight;
boolean mPausing = false;
boolean mPreviewing = false; // True if preview is started.
// The display rotation in degrees. This is only valid when mPreviewing is
// true.
private int mDisplayRotation;
private ContentResolver mContentResolver;
private LocationManager mLocationManager;
private final Handler mHandler = new MainHandler();
private Parameters mParameters;
// multiple cameras support
private int mNumberOfCameras;
private int mCameraId;
private int mFrontCameraId;
private int mBackCameraId;
private GestureDetector mPopupGestureDetector;
private MyOrientationEventListener mOrientationListener;
// The degrees of the device rotated clockwise from its natural orientation.
private int mOrientation = OrientationEventListener.ORIENTATION_UNKNOWN;
// The orientation compensation for icons and thumbnails. Ex: if the value
// is 90, the UI components should be rotated 90 degrees counter-clockwise.
private int mOrientationCompensation = 0;
// The orientation compenstaion when we start recording.
private int mOrientationCompensationAtRecordStart;
private static final int ZOOM_STOPPED = 0;
private static final int ZOOM_START = 1;
private static final int ZOOM_STOPPING = 2;
private int mZoomState = ZOOM_STOPPED;
private boolean mSmoothZoomSupported = false;
private int mZoomValue; // The current zoom value.
private int mZoomMax;
private int mTargetZoomValue;
private ZoomControl mZoomControl;
private final ZoomListener mZoomListener = new ZoomListener();
// This Handler is used to post message back onto the main thread of the
// application
private class MainHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case ENABLE_SHUTTER_BUTTON:
mShutterButton.setEnabled(true);
break;
case CLEAR_SCREEN_DELAY: {
getWindow().clearFlags(
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
break;
}
case UPDATE_RECORD_TIME: {
updateRecordingTime();
break;
}
case CHECK_DISPLAY_ROTATION: {
// Restart the preview if display rotation has changed.
// Sometimes this happens when the device is held upside
// down and camera app is opened. Rotation animation will
// take some time and the rotation value we have got may be
// wrong. Framework does not have a callback for this now.
if ((Util.getDisplayRotation(VideoCamera.this) != mDisplayRotation)
&& !mMediaRecorderRecording) {
startPreview();
}
if (SystemClock.uptimeMillis() - mOnResumeTime < 5000) {
mHandler.sendEmptyMessageDelayed(CHECK_DISPLAY_ROTATION, 100);
}
break;
}
case SHOW_TAP_TO_SNAPSHOT_TOAST: {
showTapToSnapshotToast();
break;
}
default:
Log.v(TAG, "Unhandled message: " + msg.what);
break;
}
}
}
private BroadcastReceiver mReceiver = null;
private class MyBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(Intent.ACTION_MEDIA_EJECT)) {
updateAndShowStorageHint();
stopVideoRecording();
} else if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) {
updateAndShowStorageHint();
updateThumbnailButton();
} else if (action.equals(Intent.ACTION_MEDIA_UNMOUNTED)) {
// SD card unavailable
// handled in ACTION_MEDIA_EJECT
} else if (action.equals(Intent.ACTION_MEDIA_SCANNER_STARTED)) {
Toast.makeText(VideoCamera.this,
getResources().getString(R.string.wait), Toast.LENGTH_LONG).show();
} else if (action.equals(Intent.ACTION_MEDIA_SCANNER_FINISHED)) {
updateAndShowStorageHint();
}
}
}
private String createName(long dateTaken) {
Date date = new Date(dateTaken);
SimpleDateFormat dateFormat = new SimpleDateFormat(
getString(R.string.video_file_name_format));
return dateFormat.format(date);
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
Util.initializeScreenBrightness(getWindow(), getContentResolver());
mPreferences = new ComboPreferences(this);
CameraSettings.upgradeGlobalPreferences(mPreferences.getGlobal());
mCameraId = CameraSettings.readPreferredCameraId(mPreferences);
//Testing purpose. Launch a specific camera through the intent extras.
int intentCameraId = Util.getCameraFacingIntentExtras(this);
if (intentCameraId != -1) {
mCameraId = intentCameraId;
}
mPreferences.setLocalId(this, mCameraId);
CameraSettings.upgradeLocalPreferences(mPreferences.getLocal());
mNumberOfCameras = CameraHolder.instance().getNumberOfCameras();
mPrefVideoEffectDefault = getString(R.string.pref_video_effect_default);
// Do not reset the effect if users are switching between back and front
// cameras.
mResetEffect = getIntent().getBooleanExtra(RESET_EFFECT_EXTRA, true);
// If background replacement was on when the camera was switched, the
// background uri will be sent via the intent.
mEffectUriFromGallery = getIntent().getStringExtra(BACKGROUND_URI_GALLERY_EXTRA);
resetEffect();
/*
* To reduce startup time, we start the preview in another thread.
* We make sure the preview is started at the end of onCreate.
*/
Thread startPreviewThread = new Thread(new Runnable() {
public void run() {
try {
mCameraDevice = Util.openCamera(VideoCamera.this, mCameraId);
readVideoPreferences();
startPreview();
} catch (CameraHardwareException e) {
mOpenCameraFail = true;
} catch (CameraDisabledException e) {
mCameraDisabled = true;
}
}
});
startPreviewThread.start();
Util.enterLightsOutMode(getWindow());
mContentResolver = getContentResolver();
requestWindowFeature(Window.FEATURE_PROGRESS);
mIsVideoCaptureIntent = isVideoCaptureIntent();
setContentView(R.layout.video_camera);
if (mIsVideoCaptureIntent) {
mReviewDoneButton = (Rotatable) findViewById(R.id.btn_done);
mReviewPlayButton = (Rotatable) findViewById(R.id.btn_play);
mReviewCancelButton = (Rotatable) findViewById(R.id.btn_cancel);
findViewById(R.id.btn_cancel).setVisibility(View.VISIBLE);
} else {
initThumbnailButton();
mModePicker = (ModePicker) findViewById(R.id.mode_picker);
mModePicker.setVisibility(View.VISIBLE);
mModePicker.setOnModeChangeListener(this);
}
mRotateDialog = new RotateDialogController(this, R.layout.rotate_dialog);
mPreviewPanel = findViewById(R.id.frame_layout);
mPreviewFrameLayout = (PreviewFrameLayout) findViewById(R.id.frame);
mReviewImage = (ImageView) findViewById(R.id.review_image);
// don't set mSurfaceHolder here. We have it set ONLY within
// surfaceCreated / surfaceDestroyed, other parts of the code
// assume that when it is set, the surface is also set.
SurfaceView preview = (SurfaceView) findViewById(R.id.camera_preview);
SurfaceHolder holder = preview.getHolder();
holder.addCallback(this);
holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
mQuickCapture = getIntent().getBooleanExtra(EXTRA_QUICK_CAPTURE, false);
mShutterButton = (ShutterButton) findViewById(R.id.shutter_button);
mShutterButton.setBackgroundResource(R.drawable.btn_shutter_video);
mShutterButton.setOnShutterButtonListener(this);
mShutterButton.requestFocus();
// Disable the shutter button if effects are ON since it might take
// a little more time for the effects preview to be ready. We do not
// want to allow recording before that happens. The shutter button
// will be enabled when we get the message from effectsrecorder that
// the preview is running. This becomes critical when the camera is
// swapped.
if (effectsActive()) {
mShutterButton.setEnabled(false);
}
mRecordingTimeView = (TextView) findViewById(R.id.recording_time);
mRecordingTimeRect = (RotateLayout) findViewById(R.id.recording_time_rect);
mOrientationListener = new MyOrientationEventListener(this);
mTimeLapseLabel = findViewById(R.id.time_lapse_label);
// The R.id.labels can only be found in phone layout. For tablet, the id is
// R.id.labels_w1024. That is, mLabelsLinearLayout should be null in tablet layout.
mLabelsLinearLayout = (LinearLayout) findViewById(R.id.labels);
mBgLearningMessageRotater = (RotateLayout) findViewById(R.id.bg_replace_message);
mBgLearningMessageFrame = findViewById(R.id.bg_replace_message_frame);
mLocationManager = new LocationManager(this, null);
// Make sure preview is started.
try {
startPreviewThread.join();
if (mOpenCameraFail) {
Util.showErrorAndFinish(this, R.string.cannot_connect_camera);
return;
} else if (mCameraDisabled) {
Util.showErrorAndFinish(this, R.string.camera_disabled);
return;
}
} catch (InterruptedException ex) {
// ignore
}
showTimeLapseUI(mCaptureTimeLapse);
initializeVideoSnapshot();
resizeForPreviewAspectRatio();
mBackCameraId = CameraHolder.instance().getBackCameraId();
mFrontCameraId = CameraHolder.instance().getFrontCameraId();
initializeIndicatorControl();
}
private void loadCameraPreferences() {
CameraSettings settings = new CameraSettings(this, mParameters,
mCameraId, CameraHolder.instance().getCameraInfo());
// Remove the video quality preference setting when the quality is given in the intent.
mPreferenceGroup = filterPreferenceScreenByIntent(
settings.getPreferenceGroup(R.xml.video_preferences));
}
private boolean collapseCameraControls() {
if ((mIndicatorControlContainer != null)
&& mIndicatorControlContainer.dismissSettingPopup()) {
return true;
}
return false;
}
private void enableCameraControls(boolean enable) {
if (mIndicatorControlContainer != null) {
mIndicatorControlContainer.setEnabled(enable);
}
if (mModePicker != null) mModePicker.setEnabled(enable);
}
private void initializeIndicatorControl() {
mIndicatorControlContainer =
(IndicatorControlContainer) findViewById(R.id.indicator_control);
if (mIndicatorControlContainer == null) return;
loadCameraPreferences();
final String[] SETTING_KEYS = {
CameraSettings.KEY_VIDEOCAMERA_FLASH_MODE,
CameraSettings.KEY_WHITE_BALANCE,
CameraSettings.KEY_VIDEO_EFFECT,
CameraSettings.KEY_VIDEO_TIME_LAPSE_FRAME_INTERVAL,
CameraSettings.KEY_VIDEO_QUALITY};
final String[] OTHER_SETTING_KEYS = {
CameraSettings.KEY_RECORD_LOCATION};
CameraPicker.setImageResourceId(R.drawable.ic_switch_video_facing_holo_light);
mIndicatorControlContainer.initialize(this, mPreferenceGroup,
mParameters.isZoomSupported(), SETTING_KEYS, OTHER_SETTING_KEYS);
mIndicatorControlContainer.setListener(this);
mPopupGestureDetector = new GestureDetector(this,
new PopupGestureListener());
if (effectsActive()) {
mIndicatorControlContainer.overrideSettings(
CameraSettings.KEY_VIDEO_QUALITY,
Integer.toString(CamcorderProfile.QUALITY_480P));
}
}
private class MyOrientationEventListener
extends OrientationEventListener {
public MyOrientationEventListener(Context context) {
super(context);
}
@Override
public void onOrientationChanged(int orientation) {
// We keep the last known orientation. So if the user first orient
// the camera then point the camera to floor or sky, we still have
// the correct orientation.
if (orientation == ORIENTATION_UNKNOWN) return;
mOrientation = Util.roundOrientation(orientation, mOrientation);
// When the screen is unlocked, display rotation may change. Always
// calculate the up-to-date orientationCompensation.
int orientationCompensation = mOrientation
+ Util.getDisplayRotation(VideoCamera.this);
if (mOrientationCompensation != orientationCompensation) {
mOrientationCompensation = orientationCompensation;
if (effectsActive()) {
mEffectsRecorder.setOrientationHint(
mOrientationCompensation % 360);
}
// Do not rotate the icons during recording because the video
// orientation is fixed after recording.
if (!mMediaRecorderRecording) {
setOrientationIndicator(mOrientationCompensation);
}
}
// Show the toast after getting the first orientation changed.
if (mHandler.hasMessages(SHOW_TAP_TO_SNAPSHOT_TOAST)) {
mHandler.removeMessages(SHOW_TAP_TO_SNAPSHOT_TOAST);
showTapToSnapshotToast();
}
}
}
private void setOrientationIndicator(int orientation) {
Rotatable[] indicators = {mThumbnailView, mModePicker, mSharePopup,
mBgLearningMessageRotater, mIndicatorControlContainer,
mReviewDoneButton, mReviewPlayButton, mReviewCancelButton, mRotateDialog};
for (Rotatable indicator : indicators) {
if (indicator != null) indicator.setOrientation(orientation);
}
// We change the orientation of the linearlayout only for phone UI because when in portrait
// the width is not enough.
if (mLabelsLinearLayout != null) {
if (((orientation / 90) & 1) == 1) {
mLabelsLinearLayout.setOrientation(mLabelsLinearLayout.VERTICAL);
} else {
mLabelsLinearLayout.setOrientation(mLabelsLinearLayout.HORIZONTAL);
}
}
mRecordingTimeRect.setOrientation(mOrientationCompensation);
}
private void startPlayVideoActivity() {
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(mCurrentVideoUri, convertOutputFormatToMimeType(mProfile.fileFormat));
try {
startActivity(intent);
} catch (ActivityNotFoundException ex) {
Log.e(TAG, "Couldn't view video " + mCurrentVideoUri, ex);
}
}
@OnClickAttr
public void onThumbnailClicked(View v) {
if (!mMediaRecorderRecording && mThumbnail != null) {
showSharePopup();
}
}
@OnClickAttr
public void onReviewRetakeClicked(View v) {
deleteCurrentVideo();
hideAlert();
}
@OnClickAttr
public void onReviewPlayClicked(View v) {
startPlayVideoActivity();
}
@OnClickAttr
public void onReviewDoneClicked(View v) {
doReturnToCaller(true);
}
@OnClickAttr
public void onReviewCancelClicked(View v) {
stopVideoRecording();
doReturnToCaller(false);
}
private void onStopVideoRecording(boolean valid) {
mEffectsDisplayResult = true;
stopVideoRecording();
if (mIsVideoCaptureIntent) {
if (mQuickCapture) {
doReturnToCaller(valid);
} else if (!effectsActive()) {
showAlert();
}
} else if (!effectsActive()) {
getThumbnail();
}
}
public void onProtectiveCurtainClick(View v) {
// Consume clicks
}
@Override
public void onShutterButtonClick() {
if (collapseCameraControls()) return;
boolean stop = mMediaRecorderRecording;
if (stop) {
onStopVideoRecording(true);
} else {
startVideoRecording();
}
mShutterButton.setEnabled(false);
// Keep the shutter button disabled when in video capture intent
// mode and recording is stopped. It'll be re-enabled when
// re-take button is clicked.
if (!(mIsVideoCaptureIntent && stop)) {
mHandler.sendEmptyMessageDelayed(
ENABLE_SHUTTER_BUTTON, SHUTTER_BUTTON_TIMEOUT);
}
}
@Override
public void onShutterButtonFocus(boolean pressed) {
// Do nothing (everything happens in onShutterButtonClick).
}
private OnScreenHint mStorageHint;
private void updateAndShowStorageHint() {
mStorageSpace = Storage.getAvailableSpace();
showStorageHint();
}
private void showStorageHint() {
String errorMessage = null;
if (mStorageSpace == Storage.UNAVAILABLE) {
errorMessage = getString(R.string.no_storage);
} else if (mStorageSpace == Storage.PREPARING) {
errorMessage = getString(R.string.preparing_sd);
} else if (mStorageSpace == Storage.UNKNOWN_SIZE) {
errorMessage = getString(R.string.access_sd_fail);
} else if (mStorageSpace < Storage.LOW_STORAGE_THRESHOLD) {
errorMessage = getString(R.string.spaceIsLow_content);
}
if (errorMessage != null) {
if (mStorageHint == null) {
mStorageHint = OnScreenHint.makeText(this, errorMessage);
} else {
mStorageHint.setText(errorMessage);
}
mStorageHint.show();
} else if (mStorageHint != null) {
mStorageHint.cancel();
mStorageHint = null;
}
}
private void readVideoPreferences() {
// The preference stores values from ListPreference and is thus string type for all values.
// We need to convert it to int manually.
String defaultQuality = CameraSettings.getDefaultVideoQuality(mCameraId,
getResources().getString(R.string.pref_video_quality_default));
String videoQuality =
mPreferences.getString(CameraSettings.KEY_VIDEO_QUALITY,
defaultQuality);
int quality = Integer.valueOf(videoQuality);
// Set video quality.
Intent intent = getIntent();
if (intent.hasExtra(MediaStore.EXTRA_VIDEO_QUALITY)) {
int extraVideoQuality =
intent.getIntExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0);
if (extraVideoQuality > 0) {
quality = CamcorderProfile.QUALITY_HIGH;
} else { // 0 is mms.
quality = CamcorderProfile.QUALITY_LOW;
}
}
// Set video duration limit. The limit is read from the preference,
// unless it is specified in the intent.
if (intent.hasExtra(MediaStore.EXTRA_DURATION_LIMIT)) {
int seconds =
intent.getIntExtra(MediaStore.EXTRA_DURATION_LIMIT, 0);
mMaxVideoDurationInMs = 1000 * seconds;
} else {
mMaxVideoDurationInMs = CameraSettings.DEFAULT_VIDEO_DURATION;
}
// Set effect
mEffectType = CameraSettings.readEffectType(mPreferences);
if (mEffectType != EffectsRecorder.EFFECT_NONE) {
mEffectParameter = CameraSettings.readEffectParameter(mPreferences);
// Set quality to 480p for effects, unless intent is overriding it
if (!intent.hasExtra(MediaStore.EXTRA_VIDEO_QUALITY)) {
quality = CamcorderProfile.QUALITY_480P;
}
// On initial startup, can get here before indicator control is
// enabled. In that case, UI quality override handled in
// initializeIndicatorControl.
if (mIndicatorControlContainer != null) {
mIndicatorControlContainer.overrideSettings(
CameraSettings.KEY_VIDEO_QUALITY,
Integer.toString(CamcorderProfile.QUALITY_480P));
}
} else {
mEffectParameter = null;
if (mIndicatorControlContainer != null) {
mIndicatorControlContainer.overrideSettings(
CameraSettings.KEY_VIDEO_QUALITY,
null);
}
}
// Read time lapse recording interval.
String frameIntervalStr = mPreferences.getString(
CameraSettings.KEY_VIDEO_TIME_LAPSE_FRAME_INTERVAL,
getString(R.string.pref_video_time_lapse_frame_interval_default));
mTimeBetweenTimeLapseFrameCaptureMs = Integer.parseInt(frameIntervalStr);
mCaptureTimeLapse = (mTimeBetweenTimeLapseFrameCaptureMs != 0);
// TODO: This should be checked instead directly +1000.
if (mCaptureTimeLapse) quality += 1000;
mProfile = CamcorderProfile.get(mCameraId, quality);
getDesiredPreviewSize();
}
private void writeDefaultEffectToPrefs() {
ComboPreferences.Editor editor = mPreferences.edit();
editor.putString(CameraSettings.KEY_VIDEO_EFFECT,
getString(R.string.pref_video_effect_default));
editor.apply();
}
private void getDesiredPreviewSize() {
mParameters = mCameraDevice.getParameters();
if (mParameters.getSupportedVideoSizes() == null || effectsActive()) {
mDesiredPreviewWidth = mProfile.videoFrameWidth;
mDesiredPreviewHeight = mProfile.videoFrameHeight;
} else { // Driver supports separates outputs for preview and video.
List<Size> sizes = mParameters.getSupportedPreviewSizes();
Size preferred = mParameters.getPreferredPreviewSizeForVideo();
int product = preferred.width * preferred.height;
Iterator it = sizes.iterator();
// Remove the preview sizes that are not preferred.
while (it.hasNext()) {
Size size = (Size) it.next();
if (size.width * size.height > product) {
it.remove();
}
}
Size optimalSize = Util.getOptimalPreviewSize(this, sizes,
(double) mProfile.videoFrameWidth / mProfile.videoFrameHeight);
mDesiredPreviewWidth = optimalSize.width;
mDesiredPreviewHeight = optimalSize.height;
}
Log.v(TAG, "mDesiredPreviewWidth=" + mDesiredPreviewWidth +
". mDesiredPreviewHeight=" + mDesiredPreviewHeight);
}
private void resizeForPreviewAspectRatio() {
mPreviewFrameLayout.setAspectRatio(
(double) mProfile.videoFrameWidth / mProfile.videoFrameHeight);
}
@Override
protected void doOnResume() {
if (mOpenCameraFail || mCameraDisabled) return;
mPausing = false;
mZoomValue = 0;
showVideoSnapshotUI(false);
// Start orientation listener as soon as possible because it takes
// some time to get first orientation.
mOrientationListener.enable();
if (!mPreviewing) {
if (resetEffect()) {
mBgLearningMessageFrame.setVisibility(View.GONE);
mIndicatorControlContainer.reloadPreferences();
}
try {
mCameraDevice = Util.openCamera(this, mCameraId);
readVideoPreferences();
resizeForPreviewAspectRatio();
startPreview();
} catch (CameraHardwareException e) {
Util.showErrorAndFinish(this, R.string.cannot_connect_camera);
return;
} catch (CameraDisabledException e) {
Util.showErrorAndFinish(this, R.string.camera_disabled);
return;
}
}
// Initializing it here after the preview is started.
initializeZoom();
keepScreenOnAwhile();
// install an intent filter to receive SD card related events.
IntentFilter intentFilter =
new IntentFilter(Intent.ACTION_MEDIA_MOUNTED);
intentFilter.addAction(Intent.ACTION_MEDIA_EJECT);
intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED);
intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED);
intentFilter.addDataScheme("file");
mReceiver = new MyBroadcastReceiver();
registerReceiver(mReceiver, intentFilter);
mStorageSpace = Storage.getAvailableSpace();
mHandler.postDelayed(new Runnable() {
public void run() {
showStorageHint();
}
}, 200);
// Initialize location sevice.
boolean recordLocation = RecordLocationPreference.get(
mPreferences, getContentResolver());
mLocationManager.recordLocation(recordLocation);
if (!mIsVideoCaptureIntent) {
updateThumbnailButton(); // Update the last video thumbnail.
mModePicker.setCurrentMode(ModePicker.MODE_VIDEO);
}
if (mPreviewing) {
mOnResumeTime = SystemClock.uptimeMillis();
mHandler.sendEmptyMessageDelayed(CHECK_DISPLAY_ROTATION, 100);
}
// Dismiss open menu if exists.
PopupManager.getInstance(this).notifyShowPopup(null);
}
private void setPreviewDisplay(SurfaceHolder holder) {
try {
if (effectsActive()) {
mEffectsRecorder.setPreviewDisplay(
mSurfaceHolder,
mSurfaceWidth,
mSurfaceHeight);
} else {
mCameraDevice.setPreviewDisplay(holder);
}
} catch (Throwable ex) {
closeCamera();
throw new RuntimeException("setPreviewDisplay failed", ex);
}
}
private void startPreview() {
Log.v(TAG, "startPreview");
mCameraDevice.setErrorCallback(mErrorCallback);
if (mPreviewing == true) {
mCameraDevice.stopPreview();
if (effectsActive() && mEffectsRecorder != null) {
mEffectsRecorder.release();
}
mPreviewing = false;
}
mDisplayRotation = Util.getDisplayRotation(this);
int orientation = Util.getDisplayOrientation(mDisplayRotation, mCameraId);
mCameraDevice.setDisplayOrientation(orientation);
setCameraParameters();
if (!effectsActive()) {
setPreviewDisplay(mSurfaceHolder);
try {
mCameraDevice.startPreview();
} catch (Throwable ex) {
closeCamera();
throw new RuntimeException("startPreview failed", ex);
}
} else {
initializeEffectsPreview();
Log.v(TAG, "effectsStartPreview");
mEffectsRecorder.startPreview();
}
mZoomState = ZOOM_STOPPED;
mPreviewing = true;
}
private void closeCamera() {
Log.v(TAG, "closeCamera");
if (mCameraDevice == null) {
Log.d(TAG, "already stopped.");
return;
}
if (mEffectsRecorder != null) {
mEffectsRecorder.release();
}
mEffectType = EffectsRecorder.EFFECT_NONE;
CameraHolder.instance().release();
mCameraDevice.setZoomChangeListener(null);
mCameraDevice.setErrorCallback(null);
mCameraDevice = null;
mPreviewing = false;
mSnapshotInProgress = false;
}
private void finishRecorderAndCloseCamera() {
// This is similar to what mShutterButton.performClick() does,
// but not quite the same.
if (mMediaRecorderRecording) {
mEffectsDisplayResult = true;
if (mIsVideoCaptureIntent) {
stopVideoRecording();
if (!effectsActive()) showAlert();
} else {
stopVideoRecording();
if (!effectsActive()) getThumbnail();
}
} else {
stopVideoRecording();
}
closeCamera();
}
@Override
protected void onPause() {
super.onPause();
mPausing = true;
if (mIndicatorControlContainer != null) {
mIndicatorControlContainer.dismissSettingPopup();
}
finishRecorderAndCloseCamera();
closeVideoFileDescriptor();
if (mSharePopup != null) mSharePopup.dismiss();
if (mReceiver != null) {
unregisterReceiver(mReceiver);
mReceiver = null;
}
resetScreenOn();
if (!mIsVideoCaptureIntent && mThumbnail != null && !mThumbnail.fromFile()) {
mThumbnail.saveTo(new File(getFilesDir(), Thumbnail.LAST_THUMB_FILENAME));
}
if (mStorageHint != null) {
mStorageHint.cancel();
mStorageHint = null;
}
mOrientationListener.disable();
mLocationManager.recordLocation(false);
mHandler.removeMessages(CHECK_DISPLAY_ROTATION);
}
@Override
public void onUserInteraction() {
super.onUserInteraction();
if (!mMediaRecorderRecording) keepScreenOnAwhile();
}
@Override
public void onBackPressed() {
if (mPausing) return;
if (mMediaRecorderRecording) {
onStopVideoRecording(false);
} else if (!collapseCameraControls()) {
super.onBackPressed();
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// Do not handle any key if the activity is paused.
if (mPausing) {
return true;
}
switch (keyCode) {
case KeyEvent.KEYCODE_CAMERA:
if (event.getRepeatCount() == 0) {
mShutterButton.performClick();
return true;
}
break;
case KeyEvent.KEYCODE_DPAD_CENTER:
if (event.getRepeatCount() == 0) {
mShutterButton.performClick();
return true;
}
break;
case KeyEvent.KEYCODE_MENU:
if (mMediaRecorderRecording) return true;
break;
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_CAMERA:
mShutterButton.setPressed(false);
return true;
}
return super.onKeyUp(keyCode, event);
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
// Make sure we have a surface in the holder before proceeding.
if (holder.getSurface() == null) {
Log.d(TAG, "holder.getSurface() == null");
return;
}
Log.v(TAG, "surfaceChanged. w=" + w + ". h=" + h);
mSurfaceHolder = holder;
mSurfaceWidth = w;
mSurfaceHeight = h;
if (mPausing) {
// We're pausing, the screen is off and we already stopped
// video recording. We don't want to start the camera again
// in this case in order to conserve power.
// The fact that surfaceChanged is called _after_ an onPause appears
// to be legitimate since in that case the lockscreen always returns
// to portrait orientation possibly triggering the notification.
return;
}
// The mCameraDevice will be null if it is fail to connect to the
// camera hardware. In this case we will show a dialog and then
// finish the activity, so it's OK to ignore it.
if (mCameraDevice == null) return;
// Set preview display if the surface is being created. Preview was
// already started. Also restart the preview if display rotation has
// changed. Sometimes this happens when the device is held in portrait
// and camera app is opened. Rotation animation takes some time and
// display rotation in onCreate may not be what we want.
if (mPreviewing && (Util.getDisplayRotation(this) == mDisplayRotation)
&& holder.isCreating()) {
setPreviewDisplay(holder);
} else {
stopVideoRecording();
startPreview();
}
}
public void surfaceCreated(SurfaceHolder holder) {
}
public void surfaceDestroyed(SurfaceHolder holder) {
mSurfaceHolder = null;
}
private void gotoGallery() {
MenuHelper.gotoCameraVideoGallery(this);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
if (mIsVideoCaptureIntent) {
// No options menu for attach mode.
return false;
} else {
addBaseMenuItems(menu);
}
return true;
}
private boolean isVideoCaptureIntent() {
String action = getIntent().getAction();
return (MediaStore.ACTION_VIDEO_CAPTURE.equals(action));
}
private void doReturnToCaller(boolean valid) {
Intent resultIntent = new Intent();
int resultCode;
if (valid) {
resultCode = RESULT_OK;
resultIntent.setData(mCurrentVideoUri);
} else {
resultCode = RESULT_CANCELED;
}
setResultEx(resultCode, resultIntent);
finish();
}
private void cleanupEmptyFile() {
if (mVideoFilename != null) {
File f = new File(mVideoFilename);
if (f.length() == 0 && f.delete()) {
Log.v(TAG, "Empty video file deleted: " + mVideoFilename);
mVideoFilename = null;
}
}
}
// Prepares media recorder.
private void initializeRecorder() {
Log.v(TAG, "initializeRecorder");
// If the mCameraDevice is null, then this activity is going to finish
if (mCameraDevice == null) return;
if (mSurfaceHolder == null) {
Log.v(TAG, "Surface holder is null. Wait for surface changed.");
return;
}
Intent intent = getIntent();
Bundle myExtras = intent.getExtras();
long requestedSizeLimit = 0;
closeVideoFileDescriptor();
if (mIsVideoCaptureIntent && myExtras != null) {
Uri saveUri = (Uri) myExtras.getParcelable(MediaStore.EXTRA_OUTPUT);
if (saveUri != null) {
try {
mVideoFileDescriptor =
mContentResolver.openFileDescriptor(saveUri, "rw");
mCurrentVideoUri = saveUri;
} catch (java.io.FileNotFoundException ex) {
// invalid uri
Log.e(TAG, ex.toString());
}
}
requestedSizeLimit = myExtras.getLong(MediaStore.EXTRA_SIZE_LIMIT);
}
mMediaRecorder = new MediaRecorder();
// Unlock the camera object before passing it to media recorder.
mCameraDevice.unlock();
mMediaRecorder.setCamera(mCameraDevice);
if (!mCaptureTimeLapse) {
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
}
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
mMediaRecorder.setProfile(mProfile);
mMediaRecorder.setMaxDuration(mMaxVideoDurationInMs);
if (mCaptureTimeLapse) {
mMediaRecorder.setCaptureRate((1000 / (double) mTimeBetweenTimeLapseFrameCaptureMs));
}
Location loc = mLocationManager.getCurrentLocation();
if (loc != null) {
mMediaRecorder.setLocation((float) loc.getLatitude(),
(float) loc.getLongitude());
}
// Set output file.
// Try Uri in the intent first. If it doesn't exist, use our own
// instead.
if (mVideoFileDescriptor != null) {
mMediaRecorder.setOutputFile(mVideoFileDescriptor.getFileDescriptor());
} else {
generateVideoFilename(mProfile.fileFormat);
mMediaRecorder.setOutputFile(mVideoFilename);
}
mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
// Set maximum file size.
long maxFileSize = mStorageSpace - Storage.LOW_STORAGE_THRESHOLD;
if (requestedSizeLimit > 0 && requestedSizeLimit < maxFileSize) {
maxFileSize = requestedSizeLimit;
}
try {
mMediaRecorder.setMaxFileSize(maxFileSize);
} catch (RuntimeException exception) {
// We are going to ignore failure of setMaxFileSize here, as
// a) The composer selected may simply not support it, or
// b) The underlying media framework may not handle 64-bit range
// on the size restriction.
}
// See android.hardware.Camera.Parameters.setRotation for
// documentation.
// Note that mOrientation here is the device orientation, which is the opposite of
// what activity.getWindowManager().getDefaultDisplay().getRotation() would return,
// which is the orientation the graphics need to rotate in order to render correctly.
int rotation = 0;
if (mOrientation != OrientationEventListener.ORIENTATION_UNKNOWN) {
CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId];
if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
rotation = (info.orientation - mOrientation + 360) % 360;
} else { // back-facing camera
rotation = (info.orientation + mOrientation) % 360;
}
}
mMediaRecorder.setOrientationHint(rotation);
mOrientationCompensationAtRecordStart = mOrientationCompensation;
try {
mMediaRecorder.prepare();
} catch (IOException e) {
Log.e(TAG, "prepare failed for " + mVideoFilename, e);
releaseMediaRecorder();
throw new RuntimeException(e);
}
mMediaRecorder.setOnErrorListener(this);
mMediaRecorder.setOnInfoListener(this);
}
private void initializeEffectsPreview() {
Log.v(TAG, "initializeEffectsPreview");
// If the mCameraDevice is null, then this activity is going to finish
if (mCameraDevice == null) return;
boolean inLandscape =
(getRequestedOrientation() ==
ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId];
mEffectsDisplayResult = false;
mEffectsRecorder = new EffectsRecorder(this);
// TODO: Confirm none of the foll need to go to initializeEffectsRecording()
// and none of these change even when the preview is not refreshed.
mEffectsRecorder.setAppToLandscape(inLandscape);
mEffectsRecorder.setCamera(mCameraDevice);
mEffectsRecorder.setCameraFacing(info.facing);
mEffectsRecorder.setProfile(mProfile);
mEffectsRecorder.setEffectsListener(this);
mEffectsRecorder.setOnInfoListener(this);
mEffectsRecorder.setOnErrorListener(this);
// See android.hardware.Camera.Parameters.setRotation for
// documentation.
int rotation = 0;
if (mOrientation != OrientationEventListener.ORIENTATION_UNKNOWN) {
rotation = mOrientationCompensation % 360;
}
mEffectsRecorder.setOrientationHint(rotation);
mOrientationCompensationAtRecordStart = mOrientationCompensation;
mEffectsRecorder.setPreviewDisplay(
mSurfaceHolder,
mSurfaceWidth,
mSurfaceHeight);
if (mEffectType == EffectsRecorder.EFFECT_BACKDROPPER &&
((String) mEffectParameter).equals(EFFECT_BG_FROM_GALLERY)) {
mEffectsRecorder.setEffect(mEffectType, mEffectUriFromGallery);
} else {
mEffectsRecorder.setEffect(mEffectType, mEffectParameter);
}
}
private void initializeEffectsRecording() {
Log.v(TAG, "initializeEffectsRecording");
Intent intent = getIntent();
Bundle myExtras = intent.getExtras();
long requestedSizeLimit = 0;
closeVideoFileDescriptor();
if (mIsVideoCaptureIntent && myExtras != null) {
Uri saveUri = (Uri) myExtras.getParcelable(MediaStore.EXTRA_OUTPUT);
if (saveUri != null) {
try {
mVideoFileDescriptor =
mContentResolver.openFileDescriptor(saveUri, "rw");
mCurrentVideoUri = saveUri;
} catch (java.io.FileNotFoundException ex) {
// invalid uri
Log.e(TAG, ex.toString());
}
}
requestedSizeLimit = myExtras.getLong(MediaStore.EXTRA_SIZE_LIMIT);
}
mEffectsRecorder.setProfile(mProfile);
// important to set the capture rate to zero if not timelapsed, since the
// effectsrecorder object does not get created again for each recording
// session
if (mCaptureTimeLapse) {
mEffectsRecorder.setCaptureRate((1000 / (double) mTimeBetweenTimeLapseFrameCaptureMs));
} else {
mEffectsRecorder.setCaptureRate(0);
}
// Set output file
if (mVideoFileDescriptor != null) {
mEffectsRecorder.setOutputFile(mVideoFileDescriptor.getFileDescriptor());
} else {
generateVideoFilename(mProfile.fileFormat);
mEffectsRecorder.setOutputFile(mVideoFilename);
}
// Set maximum file size.
long maxFileSize = mStorageSpace - Storage.LOW_STORAGE_THRESHOLD;
if (requestedSizeLimit > 0 && requestedSizeLimit < maxFileSize) {
maxFileSize = requestedSizeLimit;
}
mEffectsRecorder.setMaxFileSize(maxFileSize);
mEffectsRecorder.setMaxDuration(mMaxVideoDurationInMs);
}
private void releaseMediaRecorder() {
Log.v(TAG, "Releasing media recorder.");
if (mMediaRecorder != null) {
cleanupEmptyFile();
mMediaRecorder.reset();
mMediaRecorder.release();
mMediaRecorder = null;
}
mVideoFilename = null;
}
private void releaseEffectsRecorder() {
Log.v(TAG, "Releasing effects recorder.");
if (mEffectsRecorder != null) {
cleanupEmptyFile();
mEffectsRecorder.release();
mEffectsRecorder = null;
}
mVideoFilename = null;
}
private void generateVideoFilename(int outputFileFormat) {
long dateTaken = System.currentTimeMillis();
String title = createName(dateTaken);
// Used when emailing.
String filename = title + convertOutputFormatToFileExt(outputFileFormat);
String mime = convertOutputFormatToMimeType(outputFileFormat);
mVideoFilename = Storage.DIRECTORY + '/' + filename;
mCurrentVideoValues = new ContentValues(7);
mCurrentVideoValues.put(Video.Media.TITLE, title);
mCurrentVideoValues.put(Video.Media.DISPLAY_NAME, filename);
mCurrentVideoValues.put(Video.Media.DATE_TAKEN, dateTaken);
mCurrentVideoValues.put(Video.Media.MIME_TYPE, mime);
mCurrentVideoValues.put(Video.Media.DATA, mVideoFilename);
mCurrentVideoValues.put(Video.Media.RESOLUTION,
Integer.toString(mProfile.videoFrameWidth) + "x" +
Integer.toString(mProfile.videoFrameHeight));
Location loc = mLocationManager.getCurrentLocation();
if (loc != null) {
mCurrentVideoValues.put(Video.Media.LATITUDE, loc.getLatitude());
mCurrentVideoValues.put(Video.Media.LONGITUDE, loc.getLongitude());
}
Log.v(TAG, "New video filename: " + mVideoFilename);
}
private void addVideoToMediaStore() {
if (mVideoFileDescriptor == null) {
Uri videoTable = Uri.parse("content://media/external/video/media");
mCurrentVideoValues.put(Video.Media.SIZE,
new File(mCurrentVideoFilename).length());
long duration = SystemClock.uptimeMillis() - mRecordingStartTime;
if (duration > 0) {
if (mCaptureTimeLapse) {
duration = getTimeLapseVideoLength(duration);
}
mCurrentVideoValues.put(Video.Media.DURATION, duration);
} else {
Log.w(TAG, "Video duration <= 0 : " + duration);
}
try {
mCurrentVideoUri = mContentResolver.insert(videoTable,
mCurrentVideoValues);
sendBroadcast(new Intent(android.hardware.Camera.ACTION_NEW_VIDEO,
mCurrentVideoUri));
} catch (Exception e) {
// We failed to insert into the database. This can happen if
// the SD card is unmounted.
mCurrentVideoUri = null;
mCurrentVideoFilename = null;
} finally {
Log.v(TAG, "Current video URI: " + mCurrentVideoUri);
}
}
mCurrentVideoValues = null;
}
private void deleteCurrentVideo() {
// Remove the video and the uri if the uri is not passed in by intent.
if (mCurrentVideoFilename != null) {
deleteVideoFile(mCurrentVideoFilename);
mCurrentVideoFilename = null;
if (mCurrentVideoUri != null) {
mContentResolver.delete(mCurrentVideoUri, null, null);
mCurrentVideoUri = null;
}
}
updateAndShowStorageHint();
}
private void deleteVideoFile(String fileName) {
Log.v(TAG, "Deleting video " + fileName);
File f = new File(fileName);
if (!f.delete()) {
Log.v(TAG, "Could not delete " + fileName);
}
}
private void addBaseMenuItems(Menu menu) {
MenuHelper.addSwitchModeMenuItem(menu, ModePicker.MODE_CAMERA, new Runnable() {
public void run() {
switchToOtherMode(ModePicker.MODE_CAMERA);
}
});
MenuHelper.addSwitchModeMenuItem(menu, ModePicker.MODE_PANORAMA, new Runnable() {
public void run() {
switchToOtherMode(ModePicker.MODE_PANORAMA);
}
});
if (mNumberOfCameras > 1) {
menu.add(R.string.switch_camera_id)
.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
CameraSettings.writePreferredCameraId(mPreferences,
((mCameraId == mFrontCameraId)
? mBackCameraId : mFrontCameraId));
onSharedPreferenceChanged();
return true;
}
}).setIcon(android.R.drawable.ic_menu_camera);
}
}
private PreferenceGroup filterPreferenceScreenByIntent(
PreferenceGroup screen) {
Intent intent = getIntent();
if (intent.hasExtra(MediaStore.EXTRA_VIDEO_QUALITY)) {
CameraSettings.removePreferenceFromScreen(screen,
CameraSettings.KEY_VIDEO_QUALITY);
}
if (intent.hasExtra(MediaStore.EXTRA_DURATION_LIMIT)) {
CameraSettings.removePreferenceFromScreen(screen,
CameraSettings.KEY_VIDEO_QUALITY);
}
return screen;
}
// from MediaRecorder.OnErrorListener
public void onError(MediaRecorder mr, int what, int extra) {
Log.e(TAG, "MediaRecorder error. what=" + what + ". extra=" + extra);
if (what == MediaRecorder.MEDIA_RECORDER_ERROR_UNKNOWN) {
// We may have run out of space on the sdcard.
stopVideoRecording();
updateAndShowStorageHint();
}
}
// from MediaRecorder.OnInfoListener
public void onInfo(MediaRecorder mr, int what, int extra) {
if (what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
if (mMediaRecorderRecording) onStopVideoRecording(true);
} else if (what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED) {
if (mMediaRecorderRecording) onStopVideoRecording(true);
// Show the toast.
Toast.makeText(this, R.string.video_reach_size_limit,
Toast.LENGTH_LONG).show();
}
}
/*
* Make sure we're not recording music playing in the background, ask the
* MediaPlaybackService to pause playback.
*/
private void pauseAudioPlayback() {
// Shamelessly copied from MediaPlaybackService.java, which
// should be public, but isn't.
Intent i = new Intent("com.android.music.musicservicecommand");
i.putExtra("command", "pause");
sendBroadcast(i);
}
// For testing.
public boolean isRecording() {
return mMediaRecorderRecording;
}
private void startVideoRecording() {
Log.v(TAG, "startVideoRecording");
updateAndShowStorageHint();
if (mStorageSpace < Storage.LOW_STORAGE_THRESHOLD) {
Log.v(TAG, "Storage issue, ignore the start request");
return;
}
mCurrentVideoUri = null;
if (effectsActive()) {
initializeEffectsRecording();
if (mEffectsRecorder == null) {
Log.e(TAG, "Fail to initialize effect recorder");
return;
}
} else {
initializeRecorder();
if (mMediaRecorder == null) {
Log.e(TAG, "Fail to initialize media recorder");
return;
}
}
pauseAudioPlayback();
if (effectsActive()) {
try {
mEffectsRecorder.startRecording();
} catch (RuntimeException e) {
Log.e(TAG, "Could not start effects recorder. ", e);
releaseEffectsRecorder();
return;
}
} else {
try {
mMediaRecorder.start(); // Recording is now started
} catch (RuntimeException e) {
Log.e(TAG, "Could not start media recorder. ", e);
releaseMediaRecorder();
// If start fails, frameworks will not lock the camera for us.
mCameraDevice.lock();
return;
}
}
enableCameraControls(false);
mMediaRecorderRecording = true;
mRecordingStartTime = SystemClock.uptimeMillis();
showRecordingUI(true);
updateRecordingTime();
keepScreenOn();
}
private void showRecordingUI(boolean recording) {
if (recording) {
mIndicatorControlContainer.dismissSecondLevelIndicator();
if (mThumbnailView != null) mThumbnailView.setEnabled(false);
mShutterButton.setBackgroundResource(R.drawable.btn_shutter_video_recording);
mRecordingTimeView.setText("");
mRecordingTimeView.setVisibility(View.VISIBLE);
if (mReviewControl != null) mReviewControl.setVisibility(View.GONE);
if (mCaptureTimeLapse) {
if (Util.isTabletUI()) {
((IndicatorControlWheelContainer) mIndicatorControlContainer)
.startTimeLapseAnimation(
mTimeBetweenTimeLapseFrameCaptureMs,
mRecordingStartTime);
}
}
} else {
if (mThumbnailView != null) mThumbnailView.setEnabled(true);
mShutterButton.setBackgroundResource(R.drawable.btn_shutter_video);
mRecordingTimeView.setVisibility(View.GONE);
if (mReviewControl != null) mReviewControl.setVisibility(View.VISIBLE);
if (mCaptureTimeLapse) {
if (Util.isTabletUI()) {
((IndicatorControlWheelContainer) mIndicatorControlContainer)
.stopTimeLapseAnimation();
}
}
}
}
private void getThumbnail() {
if (mCurrentVideoUri != null) {
Bitmap videoFrame = Thumbnail.createVideoThumbnail(mCurrentVideoFilename,
mPreviewFrameLayout.getWidth());
if (videoFrame != null) {
mThumbnail = new Thumbnail(mCurrentVideoUri, videoFrame, 0);
mThumbnailView.setBitmap(mThumbnail.getBitmap());
// Share popup may still have the reference to the old thumbnail. Clear it.
mSharePopup = null;
}
}
}
private void showAlert() {
Bitmap bitmap = null;
if (mVideoFileDescriptor != null) {
bitmap = Thumbnail.createVideoThumbnail(mVideoFileDescriptor.getFileDescriptor(),
mPreviewFrameLayout.getWidth());
} else if (mCurrentVideoFilename != null) {
bitmap = Thumbnail.createVideoThumbnail(mCurrentVideoFilename,
mPreviewFrameLayout.getWidth());
}
if (bitmap != null) {
// MetadataRetriever already rotates the thumbnail. We should rotate
// it to match the UI orientation (and mirror if it is front-facing camera).
CameraInfo[] info = CameraHolder.instance().getCameraInfo();
boolean mirror = (info[mCameraId].facing == CameraInfo.CAMERA_FACING_FRONT);
bitmap = Util.rotateAndMirror(bitmap, -mOrientationCompensationAtRecordStart,
mirror);
mReviewImage.setImageBitmap(bitmap);
mReviewImage.setVisibility(View.VISIBLE);
}
Util.fadeOut(mShutterButton);
Util.fadeOut(mIndicatorControlContainer);
int[] pickIds = {R.id.btn_retake, R.id.btn_done, R.id.btn_play};
for (int id : pickIds) {
Util.fadeIn(findViewById(id));
}
showTimeLapseUI(false);
}
private void hideAlert() {
mReviewImage.setVisibility(View.GONE);
mShutterButton.setEnabled(true);
enableCameraControls(true);
int[] pickIds = {R.id.btn_retake, R.id.btn_done, R.id.btn_play};
for (int id : pickIds) {
Util.fadeOut(findViewById(id));
}
Util.fadeIn(mShutterButton);
Util.fadeIn(mIndicatorControlContainer);
if (mCaptureTimeLapse) {
showTimeLapseUI(true);
}
}
private void stopVideoRecording() {
Log.v(TAG, "stopVideoRecording");
if (mMediaRecorderRecording) {
boolean shouldAddToMediaStoreNow = false;
try {
if (effectsActive()) {
// This is asynchronous, so we can't add to media store now because thumbnail
// may not be ready. In such case addVideoToMediaStore is called later
// through a callback from the MediaEncoderFilter to EffectsRecorder,
// and then to the VideoCamera.
mEffectsRecorder.stopRecording();
} else {
mMediaRecorder.setOnErrorListener(null);
mMediaRecorder.setOnInfoListener(null);
mMediaRecorder.stop();
shouldAddToMediaStoreNow = true;
}
mCurrentVideoFilename = mVideoFilename;
Log.v(TAG, "Setting current video filename: "
+ mCurrentVideoFilename);
} catch (RuntimeException e) {
Log.e(TAG, "stop fail", e);
if (mVideoFilename != null) deleteVideoFile(mVideoFilename);
}
mMediaRecorderRecording = false;
showRecordingUI(false);
if (!mIsVideoCaptureIntent) {
enableCameraControls(true);
}
// The orientation was fixed during video recording. Now make it
// reflect the device orientation as video recording is stopped.
setOrientationIndicator(mOrientationCompensation);
keepScreenOnAwhile();
if (shouldAddToMediaStoreNow) {
addVideoToMediaStore();
}
}
// always release media recorder
if (!effectsActive()) {
releaseMediaRecorder();
}
}
private void resetScreenOn() {
mHandler.removeMessages(CLEAR_SCREEN_DELAY);
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
}
private void keepScreenOnAwhile() {
mHandler.removeMessages(CLEAR_SCREEN_DELAY);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
mHandler.sendEmptyMessageDelayed(CLEAR_SCREEN_DELAY, SCREEN_DELAY);
}
private void keepScreenOn() {
mHandler.removeMessages(CLEAR_SCREEN_DELAY);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
}
private void initThumbnailButton() {
mThumbnailView = (RotateImageView) findViewById(R.id.thumbnail);
mThumbnailView.enableFilter(false);
mThumbnailView.setVisibility(View.VISIBLE);
// Load the thumbnail from the disk.
mThumbnail = Thumbnail.loadFrom(new File(getFilesDir(), Thumbnail.LAST_THUMB_FILENAME));
}
private void updateThumbnailButton() {
if (mThumbnail == null || !Util.isUriValid(mThumbnail.getUri(), mContentResolver)) {
mThumbnail = Thumbnail.getLastThumbnail(mContentResolver);
}
if (mThumbnail != null) {
mThumbnailView.setBitmap(mThumbnail.getBitmap());
} else {
mThumbnailView.setBitmap(null);
}
}
private static String millisecondToTimeString(long milliSeconds, boolean displayCentiSeconds) {
long seconds = milliSeconds / 1000; // round down to compute seconds
long minutes = seconds / 60;
long hours = minutes / 60;
long remainderMinutes = minutes - (hours * 60);
long remainderSeconds = seconds - (minutes * 60);
StringBuilder timeStringBuilder = new StringBuilder();
// Hours
if (hours > 0) {
if (hours < 10) {
timeStringBuilder.append('0');
}
timeStringBuilder.append(hours);
timeStringBuilder.append(':');
}
// Minutes
if (remainderMinutes < 10) {
timeStringBuilder.append('0');
}
timeStringBuilder.append(remainderMinutes);
timeStringBuilder.append(':');
// Seconds
if (remainderSeconds < 10) {
timeStringBuilder.append('0');
}
timeStringBuilder.append(remainderSeconds);
// Centi seconds
if (displayCentiSeconds) {
timeStringBuilder.append('.');
long remainderCentiSeconds = (milliSeconds - seconds * 1000) / 10;
if (remainderCentiSeconds < 10) {
timeStringBuilder.append('0');
}
timeStringBuilder.append(remainderCentiSeconds);
}
return timeStringBuilder.toString();
}
private long getTimeLapseVideoLength(long deltaMs) {
// For better approximation calculate fractional number of frames captured.
// This will update the video time at a higher resolution.
double numberOfFrames = (double) deltaMs / mTimeBetweenTimeLapseFrameCaptureMs;
return (long) (numberOfFrames / mProfile.videoFrameRate * 1000);
}
private void updateRecordingTime() {
if (!mMediaRecorderRecording) {
return;
}
long now = SystemClock.uptimeMillis();
long delta = now - mRecordingStartTime;
// Starting a minute before reaching the max duration
// limit, we'll countdown the remaining time instead.
boolean countdownRemainingTime = (mMaxVideoDurationInMs != 0
&& delta >= mMaxVideoDurationInMs - 60000);
long deltaAdjusted = delta;
if (countdownRemainingTime) {
deltaAdjusted = Math.max(0, mMaxVideoDurationInMs - deltaAdjusted) + 999;
}
String text;
long targetNextUpdateDelay;
if (!mCaptureTimeLapse) {
text = millisecondToTimeString(deltaAdjusted, false);
targetNextUpdateDelay = 1000;
} else {
// The length of time lapse video is different from the length
// of the actual wall clock time elapsed. Display the video length
// only in format hh:mm:ss.dd, where dd are the centi seconds.
text = millisecondToTimeString(getTimeLapseVideoLength(delta), true);
targetNextUpdateDelay = mTimeBetweenTimeLapseFrameCaptureMs;
}
mRecordingTimeView.setText(text);
if (mRecordingTimeCountsDown != countdownRemainingTime) {
// Avoid setting the color on every update, do it only
// when it needs changing.
mRecordingTimeCountsDown = countdownRemainingTime;
int color = getResources().getColor(countdownRemainingTime
? R.color.recording_time_remaining_text
: R.color.recording_time_elapsed_text);
mRecordingTimeView.setTextColor(color);
}
long actualNextUpdateDelay = targetNextUpdateDelay - (delta % targetNextUpdateDelay);
mHandler.sendEmptyMessageDelayed(
UPDATE_RECORD_TIME, actualNextUpdateDelay);
}
private static boolean isSupported(String value, List<String> supported) {
return supported == null ? false : supported.indexOf(value) >= 0;
}
private void setCameraParameters() {
mParameters = mCameraDevice.getParameters();
mParameters.setPreviewSize(mDesiredPreviewWidth, mDesiredPreviewHeight);
mParameters.setPreviewFrameRate(mProfile.videoFrameRate);
// Set flash mode.
String flashMode = mPreferences.getString(
CameraSettings.KEY_VIDEOCAMERA_FLASH_MODE,
getString(R.string.pref_camera_video_flashmode_default));
List<String> supportedFlash = mParameters.getSupportedFlashModes();
if (isSupported(flashMode, supportedFlash)) {
mParameters.setFlashMode(flashMode);
} else {
flashMode = mParameters.getFlashMode();
if (flashMode == null) {
flashMode = getString(
R.string.pref_camera_flashmode_no_flash);
}
}
// Set white balance parameter.
String whiteBalance = mPreferences.getString(
CameraSettings.KEY_WHITE_BALANCE,
getString(R.string.pref_camera_whitebalance_default));
if (isSupported(whiteBalance,
mParameters.getSupportedWhiteBalance())) {
mParameters.setWhiteBalance(whiteBalance);
} else {
whiteBalance = mParameters.getWhiteBalance();
if (whiteBalance == null) {
whiteBalance = Parameters.WHITE_BALANCE_AUTO;
}
}
// Set zoom.
if (mParameters.isZoomSupported()) {
mParameters.setZoom(mZoomValue);
}
// Set continuous autofocus.
List<String> supportedFocus = mParameters.getSupportedFocusModes();
if (isSupported(Parameters.FOCUS_MODE_CONTINUOUS_VIDEO, supportedFocus)) {
mParameters.setFocusMode(Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
mParameters.setRecordingHint(true);
// Enable video stabilization. Convenience methods not available in API
// level <= 14
String vstabSupported = mParameters.get("video-stabilization-supported");
if ("true".equals(vstabSupported)) {
mParameters.set("video-stabilization", "true");
}
// Set picture size.
// The logic here is different from the logic in still-mode camera.
// There we determine the preview size based on the picture size, but
// here we determine the picture size based on the preview size.
List<Size> supported = mParameters.getSupportedPictureSizes();
Size optimalSize = Util.getOptimalVideoSnapshotPictureSize(supported,
(double) mDesiredPreviewWidth / mDesiredPreviewHeight);
Size original = mParameters.getPictureSize();
if (!original.equals(optimalSize)) {
mParameters.setPictureSize(optimalSize.width, optimalSize.height);
}
Log.v(TAG, "Video snapshot size is " + optimalSize.width + "x" +
optimalSize.height);
// Set JPEG quality.
int jpegQuality = CameraProfile.getJpegEncodingQualityParameter(mCameraId,
CameraProfile.QUALITY_HIGH);
mParameters.setJpegQuality(jpegQuality);
mCameraDevice.setParameters(mParameters);
// Keep preview size up to date.
mParameters = mCameraDevice.getParameters();
}
private boolean switchToOtherMode(int mode) {
if (isFinishing()) return false;
MenuHelper.gotoMode(mode, this);
finish();
return true;
}
public boolean onModeChanged(int mode) {
if (mode != ModePicker.MODE_VIDEO) {
return switchToOtherMode(mode);
} else {
return true;
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case EffectsRecorder.EFFECT_BACKDROPPER:
if (resultCode == RESULT_OK) {
// onActivityResult() runs before onResume(), so this parameter will be
// seen by startPreview from onResume()
mEffectUriFromGallery = ((Uri) data.getData()).toString();
Log.v(TAG, "Received URI from gallery: " + mEffectUriFromGallery);
mResetEffect = false;
} else {
mEffectUriFromGallery = null;
Log.w(TAG, "No URI from gallery");
mResetEffect = true;
}
break;
default:
Log.e(TAG, "Unknown activity result sent to Camera!");
break;
}
}
@Override
public void onEffectsUpdate(int effectId, int effectMsg) {
if (effectMsg == EffectsRecorder.EFFECT_MSG_EFFECTS_STOPPED) {
// Effects have shut down. Hide learning message if any,
// and restart regular preview.
mBgLearningMessageFrame.setVisibility(View.GONE);
checkQualityAndStartPreview();
} else if (effectMsg == EffectsRecorder.EFFECT_MSG_RECORDING_DONE) {
// TODO: This assumes the codepath from onStopVideoRecording. It
// does not appear to cause problems for the other codepaths, but
// should be properly thought through.
if (mEffectsDisplayResult) {
addVideoToMediaStore();
if (mIsVideoCaptureIntent) {
if (!mQuickCapture) {
showAlert();
}
} else {
getThumbnail();
}
}
mEffectsDisplayResult = false;
} else if (effectMsg == EffectsRecorder.EFFECT_MSG_PREVIEW_RUNNING) {
// Enable the shutter button once the preview is complete.
mShutterButton.setEnabled(true);
} else if (effectId == EffectsRecorder.EFFECT_BACKDROPPER) {
switch (effectMsg) {
case EffectsRecorder.EFFECT_MSG_STARTED_LEARNING:
mBgLearningMessageFrame.setVisibility(View.VISIBLE);
break;
case EffectsRecorder.EFFECT_MSG_DONE_LEARNING:
case EffectsRecorder.EFFECT_MSG_SWITCHING_EFFECT:
mBgLearningMessageFrame.setVisibility(View.GONE);
break;
}
}
}
public void onCancelBgTraining(View v) {
// Remove training message
mBgLearningMessageFrame.setVisibility(View.GONE);
// Write default effect out to shared prefs
writeDefaultEffectToPrefs();
// Tell the indicator controller to redraw based on new shared pref values
mIndicatorControlContainer.reloadPreferences();
// Tell VideoCamer to re-init based on new shared pref values.
onSharedPreferenceChanged();
}
@Override
public synchronized void onEffectsError(Exception exception, String fileName) {
// TODO: Eventually we may want to show the user an error dialog, and then restart the
// camera and encoder gracefully. For now, we just delete the file and bail out.
if (fileName != null && new File(fileName).exists()) {
deleteVideoFile(fileName);
}
if (exception instanceof MediaRecorderStopException) {
Log.w(TAG, "Problem recoding video file. Removing incomplete file.");
return;
}
throw new RuntimeException("Error during recording!", exception);
}
@Override
public void onConfigurationChanged(Configuration config) {
super.onConfigurationChanged(config);
}
public void onOverriddenPreferencesClicked() {
}
public void onRestorePreferencesClicked() {
Runnable runnable = new Runnable() {
public void run() {
restorePreferences();
}
};
mRotateDialog.showAlertDialog(
getString(R.string.confirm_restore_title),
getString(R.string.confirm_restore_message),
getString(android.R.string.ok), runnable,
getString(android.R.string.cancel), null);
}
private void restorePreferences() {
// Reset the zoom. Zoom value is not stored in preference.
if (mParameters.isZoomSupported()) {
mZoomValue = 0;
setCameraParameters();
mZoomControl.setZoomIndex(0);
}
if (mIndicatorControlContainer != null) {
mIndicatorControlContainer.dismissSettingPopup();
CameraSettings.restorePreferences(this, mPreferences,
mParameters);
mIndicatorControlContainer.reloadPreferences();
onSharedPreferenceChanged();
}
}
private boolean effectsActive() {
return (mEffectType != EffectsRecorder.EFFECT_NONE);
}
public void onSharedPreferenceChanged() {
// ignore the events after "onPause()" or preview has not started yet
if (mPausing) return;
synchronized (mPreferences) {
// If mCameraDevice is not ready then we can set the parameter in
// startPreview().
if (mCameraDevice == null) return;
boolean recordLocation = RecordLocationPreference.get(
mPreferences, getContentResolver());
mLocationManager.recordLocation(recordLocation);
// Check if the current effects selection has changed
if (updateEffectSelection()) return;
// Check if camera id is changed.
int cameraId = CameraSettings.readPreferredCameraId(mPreferences);
if (mCameraId != cameraId) {
// Restart the activity to have a crossfade animation.
// TODO: Use SurfaceTexture to implement a better and faster
// animation.
Intent intent;
if (mIsVideoCaptureIntent) {
// If the intent is video capture, stay in video capture mode.
intent = getIntent();
} else {
intent = new Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA);
}
// To maintain the same background in background replacer, we
// need to send the background video uri via the Intent (apart
// from the condition that the effects should not be reset).
intent.putExtra(BACKGROUND_URI_GALLERY_EXTRA, mEffectUriFromGallery);
intent.putExtra(RESET_EFFECT_EXTRA, false);
MenuHelper.gotoVideoMode(this, intent);
finish();
} else {
readVideoPreferences();
showTimeLapseUI(mCaptureTimeLapse);
// We need to restart the preview if preview size is changed.
Size size = mParameters.getPreviewSize();
if (size.width != mDesiredPreviewWidth
|| size.height != mDesiredPreviewHeight) {
if (!effectsActive()) {
mCameraDevice.stopPreview();
} else {
mEffectsRecorder.release();
}
resizeForPreviewAspectRatio();
startPreview(); // Parameters will be set in startPreview().
} else {
setCameraParameters();
}
}
}
}
private boolean updateEffectSelection() {
int previousEffectType = mEffectType;
Object previousEffectParameter = mEffectParameter;
mEffectType = CameraSettings.readEffectType(mPreferences);
mEffectParameter = CameraSettings.readEffectParameter(mPreferences);
if (mEffectType == previousEffectType) {
if (mEffectType == EffectsRecorder.EFFECT_NONE) return false;
if (mEffectParameter.equals(previousEffectParameter)) return false;
}
Log.v(TAG, "New effect selection: " + mPreferences.getString(
CameraSettings.KEY_VIDEO_EFFECT, "none"));
if (mEffectType == EffectsRecorder.EFFECT_NONE) {
// Stop effects and return to normal preview
mEffectsRecorder.stopPreview();
return true;
}
if (mEffectType == EffectsRecorder.EFFECT_BACKDROPPER &&
((String) mEffectParameter).equals(EFFECT_BG_FROM_GALLERY)) {
// Request video from gallery to use for background
Intent i = new Intent(Intent.ACTION_PICK);
i.setDataAndType(Video.Media.EXTERNAL_CONTENT_URI,
"video/*");
i.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
startActivityForResult(i, EffectsRecorder.EFFECT_BACKDROPPER);
return true;
}
if (previousEffectType == EffectsRecorder.EFFECT_NONE) {
// Stop regular preview and start effects.
mCameraDevice.stopPreview();
checkQualityAndStartPreview();
} else {
// Switch currently running effect
mEffectsRecorder.setEffect(mEffectType, mEffectParameter);
}
return true;
}
// Verifies that the current preview view size is correct before starting
// preview. If not, resets the surface holder and resizes the view.
private void checkQualityAndStartPreview() {
readVideoPreferences();
showTimeLapseUI(mCaptureTimeLapse);
Size size = mParameters.getPreviewSize();
if (size.width != mDesiredPreviewWidth
|| size.height != mDesiredPreviewHeight) {
resizeForPreviewAspectRatio();
} else {
// Start up preview again
startPreview();
}
}
private void showTimeLapseUI(boolean enable) {
if (mTimeLapseLabel != null) {
mTimeLapseLabel.setVisibility(enable ? View.VISIBLE : View.GONE);
}
}
private void showSharePopup() {
Uri uri = mThumbnail.getUri();
if (mSharePopup == null || !uri.equals(mSharePopup.getUri())) {
mSharePopup = new SharePopup(this, uri, mThumbnail.getBitmap(),
mOrientationCompensation, mPreviewPanel);
}
mSharePopup.showAtLocation(mThumbnailView, Gravity.NO_GRAVITY, 0, 0);
}
@Override
public boolean dispatchTouchEvent(MotionEvent m) {
// Check if the popup window should be dismissed first.
if (mPopupGestureDetector != null && mPopupGestureDetector.onTouchEvent(m)) {
return true;
}
return super.dispatchTouchEvent(m);
}
private class PopupGestureListener extends
GestureDetector.SimpleOnGestureListener {
@Override
public boolean onDown(MotionEvent e) {
// Check if the popup window is visible.
View popup = mIndicatorControlContainer.getActiveSettingPopup();
if (popup == null) return false;
// Let popup window or indicator wheel handle the event by
// themselves. Dismiss the popup window if users touch on other
// areas.
if (!Util.pointInView(e.getX(), e.getY(), popup)
&& !Util.pointInView(e.getX(), e.getY(), mIndicatorControlContainer)) {
mIndicatorControlContainer.dismissSettingPopup();
// Let event fall through.
}
return false;
}
}
private class ZoomChangeListener implements ZoomControl.OnZoomChangedListener {
// only for immediate zoom
@Override
public void onZoomValueChanged(int index) {
VideoCamera.this.onZoomValueChanged(index);
}
// only for smooth zoom
@Override
public void onZoomStateChanged(int state) {
if (mPausing) return;
Log.v(TAG, "zoom picker state=" + state);
if (state == ZoomControl.ZOOM_IN) {
VideoCamera.this.onZoomValueChanged(mZoomMax);
} else if (state == ZoomControl.ZOOM_OUT){
VideoCamera.this.onZoomValueChanged(0);
} else {
mTargetZoomValue = -1;
if (mZoomState == ZOOM_START) {
mZoomState = ZOOM_STOPPING;
mCameraDevice.stopSmoothZoom();
}
}
}
}
private void initializeZoom() {
mZoomControl = (ZoomControl) findViewById(R.id.zoom_control);
// Get the parameter to make sure we have the up-to-date zoom value.
mParameters = mCameraDevice.getParameters();
if (!mParameters.isZoomSupported()) return;
mZoomMax = mParameters.getMaxZoom();
// Currently we use immediate zoom for fast zooming to get better UX and
// there is no plan to take advantage of the smooth zoom.
mZoomControl.setZoomMax(mZoomMax);
mZoomControl.setZoomIndex(mParameters.getZoom());
mZoomControl.setSmoothZoomSupported(mSmoothZoomSupported);
mZoomControl.setOnZoomChangeListener(new ZoomChangeListener());
mCameraDevice.setZoomChangeListener(mZoomListener);
}
private final class ZoomListener
implements android.hardware.Camera.OnZoomChangeListener {
@Override
public void onZoomChange(int value, boolean stopped, android.hardware.Camera camera) {
Log.v(TAG, "Zoom changed: value=" + value + ". stopped=" + stopped);
mZoomValue = value;
// Update the UI when we get zoom value.
mZoomControl.setZoomIndex(value);
// Keep mParameters up to date. We do not getParameter again in
// takePicture. If we do not do this, wrong zoom value will be set.
mParameters.setZoom(value);
if (stopped && mZoomState != ZOOM_STOPPED) {
if (mTargetZoomValue != -1 && value != mTargetZoomValue) {
mCameraDevice.startSmoothZoom(mTargetZoomValue);
mZoomState = ZOOM_START;
} else {
mZoomState = ZOOM_STOPPED;
}
}
}
}
private void onZoomValueChanged(int index) {
// Not useful to change zoom value when the activity is paused.
if (mPausing) return;
if (mSmoothZoomSupported) {
if (mTargetZoomValue != index && mZoomState != ZOOM_STOPPED) {
mTargetZoomValue = index;
if (mZoomState == ZOOM_START) {
mZoomState = ZOOM_STOPPING;
mCameraDevice.stopSmoothZoom();
}
} else if (mZoomState == ZOOM_STOPPED && mZoomValue != index) {
mTargetZoomValue = index;
mCameraDevice.startSmoothZoom(index);
mZoomState = ZOOM_START;
}
} else {
mZoomValue = index;
setCameraParameters();
}
}
private void initializeVideoSnapshot() {
if (mParameters.isVideoSnapshotSupported() && !mIsVideoCaptureIntent) {
findViewById(R.id.camera_preview).setOnTouchListener(this);
// Show the tap to focus toast if this is the first start.
if (mPreferences.getBoolean(
CameraSettings.KEY_VIDEO_FIRST_USE_HINT_SHOWN, true)) {
// Delay the toast for one second to wait for orientation.
mHandler.sendEmptyMessageDelayed(SHOW_TAP_TO_SNAPSHOT_TOAST, 1000);
}
}
}
void showVideoSnapshotUI(boolean enabled) {
if (mParameters.isVideoSnapshotSupported() && !mIsVideoCaptureIntent) {
mPreviewFrameLayout.showBorder(enabled);
mIndicatorControlContainer.enableZoom(!enabled);
mShutterButton.setEnabled(!enabled);
}
}
// Preview area is touched. Take a picture.
@Override
public boolean onTouch(View v, MotionEvent e) {
if (mMediaRecorderRecording && effectsActive()) {
new RotateTextToast(this, R.string.disable_video_snapshot_hint,
mOrientation).show();
return false;
}
if (mPausing || mSnapshotInProgress
|| !mMediaRecorderRecording || effectsActive()) {
return false;
}
// Set rotation and gps data.
Util.setRotationParameter(mParameters, mCameraId, mOrientation);
Location loc = mLocationManager.getCurrentLocation();
Util.setGpsParameters(mParameters, loc);
mCameraDevice.setParameters(mParameters);
Log.v(TAG, "Video snapshot start");
mCameraDevice.takePicture(null, null, null, new JpegPictureCallback(loc));
showVideoSnapshotUI(true);
mSnapshotInProgress = true;
return true;
}
private final class JpegPictureCallback implements PictureCallback {
Location mLocation;
public JpegPictureCallback(Location loc) {
mLocation = loc;
}
@Override
public void onPictureTaken(byte [] jpegData, android.hardware.Camera camera) {
Log.v(TAG, "onPictureTaken");
mSnapshotInProgress = false;
showVideoSnapshotUI(false);
storeImage(jpegData, mLocation);
}
}
private void storeImage(final byte[] data, Location loc) {
long dateTaken = System.currentTimeMillis();
String title = Util.createJpegName(dateTaken);
int orientation = Exif.getOrientation(data);
Size s = mParameters.getPictureSize();
Uri uri = Storage.addImage(mContentResolver, title, dateTaken, loc, orientation, data,
s.width, s.height);
if (uri != null) {
// Create a thumbnail whose width is equal or bigger than that of the preview.
int ratio = (int) Math.ceil((double) mParameters.getPictureSize().width
/ mPreviewFrameLayout.getWidth());
int inSampleSize = Integer.highestOneBit(ratio);
mThumbnail = Thumbnail.createThumbnail(data, orientation, inSampleSize, uri);
if (mThumbnail != null) {
mThumbnailView.setBitmap(mThumbnail.getBitmap());
}
// Share popup may still have the reference to the old thumbnail. Clear it.
mSharePopup = null;
Util.broadcastNewPicture(this, uri);
}
}
private boolean resetEffect() {
if (mResetEffect) {
String value = mPreferences.getString(CameraSettings.KEY_VIDEO_EFFECT,
mPrefVideoEffectDefault);
if (!mPrefVideoEffectDefault.equals(value)) {
writeDefaultEffectToPrefs();
return true;
}
}
mResetEffect = true;
return false;
}
private String convertOutputFormatToMimeType(int outputFileFormat) {
if (outputFileFormat == MediaRecorder.OutputFormat.MPEG_4) {
return "video/mp4";
}
return "video/3gpp";
}
private String convertOutputFormatToFileExt(int outputFileFormat) {
if (outputFileFormat == MediaRecorder.OutputFormat.MPEG_4) {
return ".mp4";
}
return ".3gp";
}
private void closeVideoFileDescriptor() {
if (mVideoFileDescriptor != null) {
try {
mVideoFileDescriptor.close();
} catch (IOException e) {
Log.e(TAG, "Fail to close fd", e);
}
mVideoFileDescriptor = null;
}
}
private void showTapToSnapshotToast() {
new RotateTextToast(this, R.string.video_snapshot_hint, mOrientation)
.show();
// Clear the preference.
Editor editor = mPreferences.edit();
editor.putBoolean(CameraSettings.KEY_VIDEO_FIRST_USE_HINT_SHOWN, false);
editor.apply();
}
}