/* * 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 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 + 1) % mNumberOfCameras); 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 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 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 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 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(); } }