/*
* 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.gallery.IImage;
import com.android.camera.gallery.IImageList;
import com.android.camera.ui.CamcorderHeadUpDisplay;
import com.android.camera.ui.GLRootView;
import com.android.camera.ui.HeadUpDisplay;
import com.android.camera.ui.RotateRecordingTime;
import com.android.camera.ui.ZoomControllerListener;
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;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.Size;
import android.media.CamcorderProfile;
import android.media.MediaRecorder;
import android.media.ThumbnailUtils;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.ParcelFileDescriptor;
import android.os.Message;
import android.os.StatFs;
import android.os.SystemClock;
import android.provider.MediaStore;
import android.provider.Settings;
import android.provider.MediaStore.Video;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.OrientationEventListener;
import android.view.MenuItem.OnMenuItemClickListener;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import android.graphics.ImageFormat;
/**
* The Camcorder activity.
*/
public class VideoCamera extends BaseCamera
implements View.OnClickListener,
ShutterButton.OnShutterButtonListener, SurfaceHolder.Callback,
MediaRecorder.OnErrorListener, MediaRecorder.OnInfoListener,
Switcher.OnSwitchListener {
private static final String TAG = "videocamera";
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 DELAYED_ONRESUME_FUNCTION = 7;
private static final int SCREEN_DELAY = 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 long NO_STORAGE_ERROR = -1L;
private static final long CANNOT_STAT_ERROR = -2L;
private static final long LOW_STORAGE_THRESHOLD = 512L * 1024L;
private static final int STORAGE_STATUS_OK = 0;
private static final int STORAGE_STATUS_LOW = 1;
private static final int STORAGE_STATUS_NONE = 2;
private static final int STORAGE_STATUS_FAIL = 3;
private static final boolean SWITCH_CAMERA = true;
private static final boolean SWITCH_VIDEO = false;
private static final long SHUTTER_BUTTON_TIMEOUT = 500L; // 500ms
private int mZoomValue; // The current zoom value.
private int mZoomMax;
private GestureDetector mGestureDetector;
private final ZoomListener mZoomListener = new ZoomListener();
/**
* 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 final static String EXTRA_QUICK_CAPTURE =
"android.intent.extra.quickCapture";
private PreviewFrameLayout mPreviewFrameLayout;
private SurfaceView mVideoPreview;
private SurfaceHolder mSurfaceHolder = null;
private ImageView mVideoFrame;
private GLRootView mGLRootView;
private CamcorderHeadUpDisplay mHeadUpDisplay;
private boolean mIsVideoCaptureIntent;
private boolean mQuickCapture;
// mLastPictureButton and mThumbController
// are non-null only if mIsVideoCaptureIntent is true.
private ImageView mLastPictureButton;
private ThumbnailController mThumbController;
private boolean mStartPreviewFail = false;
private int mStorageStatus = STORAGE_STATUS_OK;
private MediaRecorder mMediaRecorder;
private boolean mMediaRecorderRecording = false;
private long mRecordingStartTime;
// 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;
boolean mPausing = false;
boolean mPreviewing = false; // True if preview is started.
private ContentResolver mContentResolver;
private ShutterButton mShutterButton;
private RotateRecordingTime mRecordingTimeRect;
private TextView mRecordingTimeView;
private Switcher mSwitcher;
private boolean mRecordingTimeCountsDown = false;
private final ArrayList<MenuItem> mGalleryItems = new ArrayList<MenuItem>();
private final Handler mHandler = new MainHandler();
// multiple cameras support
private int mNumberOfCameras;
private int mCameraId;
private MyOrientationEventListener mOrientationListener;
// The device orientation in degrees. Default is unknown.
private int mOrientation = OrientationEventListener.ORIENTATION_UNKNOWN;
// The orientation compensation for icons and thumbnails. Degrees are in
// counter-clockwise
private int mOrientationCompensation = 0;
private int mOrientationHint; // the orientation hint for video playback
private SharedPreferences prefs;
// indicate if video zoom is supported for the current settings
// for general zoom support check mParameters.isZoomSupported()
private boolean mZoomSupported = false;
// Last quality enum, defined in frameworks mediaprofile
private int mMaxCamcorderQuality = CamcorderProfile.QUALITY_WIDE;
// 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 DELAYED_ONRESUME_FUNCTION: {
delayedOnResume();
break;
}
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;
}
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(false);
stopVideoRecording();
} else if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) {
updateAndShowStorageHint(true);
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), 5000);
} else if (action.equals(Intent.ACTION_MEDIA_SCANNER_FINISHED)) {
updateAndShowStorageHint(true);
}
}
}
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);
}
private void showCameraErrorAndFinish() {
Resources ress = getResources();
Util.showFatalErrorAndFinish(VideoCamera.this,
ress.getString(R.string.camera_error_title),
ress.getString(R.string.cannot_connect_camera));
}
private boolean restartPreview() {
try {
startPreview();
} catch (CameraHardwareException e) {
showCameraErrorAndFinish();
return false;
}
return true;
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
Window win = getWindow();
// Overright the brightness settings if it is automatic
int mode = Settings.System.getInt(
getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS_MODE,
Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
if (mode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
WindowManager.LayoutParams winParams = win.getAttributes();
winParams.screenBrightness = DEFAULT_CAMERA_BRIGHTNESS;
win.setAttributes(winParams);
}
mPreferences = new ComboPreferences(this);
CameraSettings.upgradeGlobalPreferences(mPreferences.getGlobal());
mCameraId = CameraSettings.readPreferredCameraId(mPreferences);
mPreferences.setLocalId(this, mCameraId);
CameraSettings.upgradeLocalPreferences(mPreferences.getLocal());
mNumberOfCameras = CameraHolder.instance().getNumberOfCameras();
readVideoPreferences();
/*
* 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 {
mStartPreviewFail = false;
startPreview();
} catch (CameraHardwareException e) {
// In eng build, we throw the exception so that test tool
// can detect it and report it
if ("eng".equals(Build.TYPE)) {
throw new RuntimeException(e);
}
mStartPreviewFail = true;
}
}
});
startPreviewThread.start();
mContentResolver = getContentResolver();
requestWindowFeature(Window.FEATURE_PROGRESS);
prefs = getSharedPreferences("com.android.camera_preferences", 0);
powerShutter(prefs);
setContentView(R.layout.video_camera);
mPreviewFrameLayout = (PreviewFrameLayout)
findViewById(R.id.frame_layout);
resizeForPreviewAspectRatio();
mVideoPreview = (SurfaceView) findViewById(R.id.camera_preview);
mVideoFrame = (ImageView) findViewById(R.id.video_frame);
// 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.
SurfaceHolder holder = mVideoPreview.getHolder();
holder.addCallback(this);
holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
mIsVideoCaptureIntent = isVideoCaptureIntent();
mQuickCapture = getIntent().getBooleanExtra(EXTRA_QUICK_CAPTURE, false);
mRecordingTimeView = (TextView) findViewById(R.id.recording_time);
mRecordingTimeRect = (RotateRecordingTime) findViewById(R.id.recording_time_rect);
ViewGroup rootView = (ViewGroup) findViewById(R.id.video_camera);
LayoutInflater inflater = this.getLayoutInflater();
if (!mIsVideoCaptureIntent) {
View controlBar = inflater.inflate(
R.layout.camera_control, rootView);
mLastPictureButton =
(ImageView) controlBar.findViewById(R.id.review_thumbnail);
mThumbController = new ThumbnailController(
getResources(), mLastPictureButton, mContentResolver);
mLastPictureButton.setOnClickListener(this);
mThumbController.loadData(ImageManager.getLastVideoThumbPath());
mSwitcher = ((Switcher) findViewById(R.id.camera_switch));
mSwitcher.setOnSwitchListener(this);
mSwitcher.addTouchView(findViewById(R.id.camera_switch_set));
} else {
View controlBar = inflater.inflate(
R.layout.attach_camera_control, rootView);
controlBar.findViewById(R.id.btn_cancel).setOnClickListener(this);
ImageView retake =
(ImageView) controlBar.findViewById(R.id.btn_retake);
retake.setOnClickListener(this);
retake.setImageResource(R.drawable.btn_ic_review_retake_video);
controlBar.findViewById(R.id.btn_play).setOnClickListener(this);
controlBar.findViewById(R.id.btn_done).setOnClickListener(this);
}
mShutterButton = (ShutterButton) findViewById(R.id.shutter_button);
mShutterButton.setImageResource(R.drawable.btn_ic_video_record);
mShutterButton.setOnShutterButtonListener(this);
mShutterButton.requestFocus();
mOrientationListener = new MyOrientationEventListener(VideoCamera.this);
// Make sure preview is started.
try {
startPreviewThread.join();
if (mStartPreviewFail) {
showCameraErrorAndFinish();
return;
}
} catch (InterruptedException ex) {
// ignore
}
initializeZoom();
// Initialize the HeadUpDiplay after startPreview(). We need mParameters
// for HeadUpDisplay and it is initialized in that function.
mHeadUpDisplay = new CamcorderHeadUpDisplay(this);
mHeadUpDisplay.setListener(new MyHeadUpDisplayListener());
initializeHeadUpDisplay();
}
private void changeHeadUpDisplayState() {
// If the camera resumes behind the lock screen, the orientation
// will be portrait. That causes OOM when we try to allocation GPU
// memory for the GLSurfaceView again when the orientation changes. So,
// we delayed initialization of HeadUpDisplay until the orientation
// becomes landscape.
Configuration config = getResources().getConfiguration();
if (config.orientation == Configuration.ORIENTATION_LANDSCAPE
&& !mPausing && mGLRootView == null) {
attachHeadUpDisplay();
} else if (mGLRootView != null) {
detachHeadUpDisplay();
}
}
private void initializeHeadUpDisplay() {
CameraSettings settings = new CameraSettings(this, mParameters,
CameraHolder.instance().getCameraInfo(), mCameraId);
PreferenceGroup group =
settings.getPreferenceGroup(R.xml.video_preferences);
if (mIsVideoCaptureIntent) {
group = filterPreferenceScreenByIntent(group);
}
mZoomSupported = CameraSettings.isVideoZoomSupported(this, mCameraId, mParameters);
mHeadUpDisplay.initialize(this, group,
mZoomSupported ? getZoomRatios() : null,
mOrientationCompensation, mParameters);
if (mZoomSupported) {
mHeadUpDisplay.setZoomListener(new ZoomControllerListener() {
public void onZoomChanged(
int index, float ratio, boolean isMoving) {
onZoomValueChanged(index);
}
});
}
}
private void attachHeadUpDisplay() {
mHeadUpDisplay.setOrientation(mOrientationCompensation);
if (mParameters.isZoomSupported()) {
mHeadUpDisplay.setZoomIndex(mZoomValue);
}
FrameLayout frame = (FrameLayout) findViewById(R.id.framegl);
mGLRootView = new GLRootView(this);
frame.addView(mGLRootView);
mGLRootView.setContentPane(mHeadUpDisplay);
mHeadUpDisplay.setListener(new MyHeadUpDisplayListener());
}
private void detachHeadUpDisplay() {
mHeadUpDisplay.collapse();
((ViewGroup) mGLRootView.getParent()).removeView(mGLRootView);
mGLRootView = null;
}
public static int roundOrientation(int orientation) {
return ((orientation + 45) / 90 * 90) % 360;
}
private class MyOrientationEventListener
extends OrientationEventListener {
public MyOrientationEventListener(Context context) {
super(context);
}
@Override
public void onOrientationChanged(int orientation) {
if (mMediaRecorderRecording) return;
// 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 = roundOrientation(orientation);
// 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 (!mIsVideoCaptureIntent) {
setOrientationIndicator(mOrientationCompensation);
}
mHeadUpDisplay.setOrientation(mOrientationCompensation);
}
}
}
private void setOrientationIndicator(int degree) {
((RotateImageView) findViewById(
R.id.review_thumbnail)).setDegree(degree);
((RotateImageView) findViewById(
R.id.camera_switch_icon)).setDegree(degree);
((RotateImageView) findViewById(
R.id.video_switch_icon)).setDegree(degree);
}
@Override
protected void onStart() {
super.onStart();
if (!mIsVideoCaptureIntent) {
mSwitcher.setSwitch(SWITCH_VIDEO);
}
}
private void startPlayVideoActivity() {
Intent intent = new Intent(Intent.ACTION_VIEW, mCurrentVideoUri);
try {
startActivity(intent);
} catch (android.content.ActivityNotFoundException ex) {
Log.e(TAG, "Couldn't view video " + mCurrentVideoUri, ex);
}
}
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_retake:
deleteCurrentVideo();
hideAlert();
break;
case R.id.btn_play:
startPlayVideoActivity();
break;
case R.id.btn_done:
doReturnToCaller(true);
break;
case R.id.btn_cancel:
stopVideoRecordingAndReturn(false);
break;
case R.id.review_thumbnail:
if (!mMediaRecorderRecording) viewLastVideo();
break;
}
}
public void onShutterButtonFocus(ShutterButton button, boolean pressed) {
// Do nothing (everything happens in onShutterButtonClick).
}
private void onStopVideoRecording(boolean valid) {
if (mIsVideoCaptureIntent) {
if (mQuickCapture) {
stopVideoRecordingAndReturn(valid);
} else {
stopVideoRecordingAndShowAlert();
}
} else {
stopVideoRecordingAndGetThumbnail();
}
}
public void onShutterButtonClick(ShutterButton button) {
switch (button.getId()) {
case R.id.shutter_button:
if (mHeadUpDisplay.collapse()) return;
if (mMediaRecorderRecording) {
onStopVideoRecording(true);
} else {
startVideoRecording();
}
mShutterButton.setEnabled(false);
mHandler.sendEmptyMessageDelayed(
ENABLE_SHUTTER_BUTTON, SHUTTER_BUTTON_TIMEOUT);
break;
}
}
private OnScreenHint mStorageHint;
private void updateAndShowStorageHint(boolean mayHaveSd) {
mStorageStatus = getStorageStatus(mayHaveSd);
showStorageHint();
}
private void showStorageHint() {
String errorMessage = null;
switch (mStorageStatus) {
case STORAGE_STATUS_NONE:
errorMessage = getString(R.string.no_storage);
break;
case STORAGE_STATUS_LOW:
errorMessage = getString(R.string.spaceIsLow_content);
break;
case STORAGE_STATUS_FAIL:
errorMessage = getString(R.string.access_sd_fail);
break;
}
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 int getStorageStatus(boolean mayHaveSd) {
long remaining = mayHaveSd ? getAvailableStorage() : NO_STORAGE_ERROR;
if (remaining == NO_STORAGE_ERROR) {
return STORAGE_STATUS_NONE;
} else if (remaining == CANNOT_STAT_ERROR) {
return STORAGE_STATUS_FAIL;
}
return remaining < LOW_STORAGE_THRESHOLD
? STORAGE_STATUS_LOW
: STORAGE_STATUS_OK;
}
private void readVideoPreferences() {
String quality = mPreferences.getString(
CameraSettings.KEY_VIDEO_QUALITY,
CameraSettings.getDefaultVideoQuality(mCameraId));
int videoQuality = CameraSettings.getVideoQuality(quality);
// Set video quality.
Intent intent = getIntent();
if (intent.hasExtra(MediaStore.EXTRA_VIDEO_QUALITY)) {
videoQuality =
intent.getIntExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0);
if (videoQuality < 0 || videoQuality > mMaxCamcorderQuality) {
videoQuality = CamcorderProfile.QUALITY_HIGH;
}
}
// Double-check to make sure this camera is HD-capable
if (videoQuality == CamcorderProfile.QUALITY_HD &&
!CameraSettings.isHDCapable(mCameraId)) {
videoQuality = CamcorderProfile.QUALITY_HIGH;
}
if (videoQuality == CamcorderProfile.QUALITY_WIDE &&
!getResources().getBoolean(R.bool.supportsWideProfile)) {
videoQuality = CamcorderProfile.QUALITY_HIGH;
}
Log.e(TAG, "videoQuality=" + videoQuality);
videoQuality = CamcorderProfile.QUALITY_HIGH;
Log.e(TAG, "videoQuality=" + videoQuality);
// 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.getVidoeDurationInMillis(quality);
}
try {
mProfile = CamcorderProfile.get(mCameraId, videoQuality);
}
catch (RuntimeException e) {
Log.e(TAG, "Unable to get video profile " + videoQuality, e);
// Fall back to lowest quality if media profile is wrong
mProfile = CamcorderProfile.get(mCameraId, CamcorderProfile.QUALITY_LOW);
}
}
private void resizeForPreviewAspectRatio() {
mPreviewFrameLayout.setAspectRatio(
(double) mProfile.videoFrameWidth / mProfile.videoFrameHeight);
}
@Override
protected void onResume() {
super.onResume();
mPausing = false;
// Start orientation listener as soon as possible because it takes
// some time to get first orientation.
mOrientationListener.enable();
mVideoPreview.setVisibility(View.VISIBLE);
readVideoPreferences();
resizeForPreviewAspectRatio();
if (!mPreviewing && !mStartPreviewFail) {
if (!restartPreview()) return;
}
keepScreenOnAwhile();
changeHeadUpDisplayState();
/* Postpone the non-critical functionality till after the
* activity is displayed, so that the camera frames are
* displayed sooner on the screen.*/
mHandler.sendEmptyMessageDelayed(DELAYED_ONRESUME_FUNCTION, 200);
}
private void delayedOnResume() {
// 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);
mStorageStatus = getStorageStatus(true);
mHandler.postDelayed(new Runnable() {
public void run() {
showStorageHint();
}
}, 200);
updateThumbnailButton();
}
private void setPreviewDisplay(SurfaceHolder holder) {
try {
mCameraDevice.setPreviewDisplay(holder);
} catch (Throwable ex) {
closeCamera();
throw new RuntimeException("setPreviewDisplay failed", ex);
}
}
private void startPreview() throws CameraHardwareException {
Log.v(TAG, "startPreview xxx");
if (mCameraDevice == null) {
// If the activity is paused and resumed, camera device has been
// released and we need to open the camera.
mCameraDevice = CameraHolder.instance().open(mCameraId);
}
if (mPreviewing == true) {
mCameraDevice.stopPreview();
mPreviewing = false;
}
setPreviewDisplay(mSurfaceHolder);
Util.setCameraDisplayOrientation(this, mCameraId, mCameraDevice);
Log.v(TAG, "before set parameters"); //joy
setCameraParameters();
CameraSettings.setContinuousAf(mParameters, false);
// Enable higher framerate recording on some tegra 2 devices
CameraSettings.enableHighFrameRateFHD(mParameters);
CameraSettings.setVideoMode(mParameters, true);
setCameraHardwareParameters();
try {
mCameraDevice.startPreview();
mPreviewing = true;
} catch (Throwable ex) {
closeCamera();
throw new RuntimeException("startPreview failed", ex);
}
if (CameraSettings.isCamcoderFocusAtStart()) {
mCameraDevice.autoFocus(null);
}
}
private void closeCamera() {
Log.v(TAG, "closeCamera");
if (mCameraDevice == null) {
Log.d(TAG, "already stopped.");
return;
}
releaseMediaRecorder();
mCameraDevice.lock();
CameraHolder.instance().release();
mCameraDevice = null;
mPreviewing = false;
}
@Override
protected void onPause() {
super.onPause();
mPausing = true;
changeHeadUpDisplayState();
// Hide the preview now. Otherwise, the preview may be rotated during
// onPause and it is annoying to users.
mVideoPreview.setVisibility(View.INVISIBLE);
// This is similar to what mShutterButton.performClick() does,
// but not quite the same.
if (mMediaRecorderRecording) {
if (mIsVideoCaptureIntent) {
stopVideoRecording();
showAlert();
} else {
stopVideoRecordingAndGetThumbnail();
}
} else {
stopVideoRecording();
}
closeCamera();
if (mReceiver != null) {
unregisterReceiver(mReceiver);
mReceiver = null;
}
resetScreenOn();
if (!mIsVideoCaptureIntent) {
mThumbController.storeData(ImageManager.getLastVideoThumbPath());
}
if (mStorageHint != null) {
mStorageHint.cancel();
mStorageHint = null;
}
mOrientationListener.disable();
}
@Override
public void onUserInteraction() {
super.onUserInteraction();
if (!mMediaRecorderRecording) keepScreenOnAwhile();
}
@Override
public void onBackPressed() {
if (mPausing) return;
if (mMediaRecorderRecording) {
onStopVideoRecording(false);
} else if (mHeadUpDisplay == null || !mHeadUpDisplay.collapse()) {
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) {
onStopVideoRecording(true);
return true;
}
break;
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
if (prefs.getBoolean("vol_zoom_enabled", false)) {
if (mZoomSupported) {
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP && mZoomValue < mZoomMax) {
mZoomValue++;
onZoomValueChanged(mZoomValue);
mHeadUpDisplay.setZoomIndex(mZoomValue);
}
else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN && mZoomValue > 0) {
mZoomValue--;
onZoomValueChanged(mZoomValue);
mHeadUpDisplay.setZoomIndex(mZoomValue);
}
}
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;
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
if (prefs.getBoolean("vol_zoom_enabled", false) || mMediaRecorderRecording) {
return true;
}
break;
case KeyEvent.KEYCODE_POWER:
if (powerShutter(prefs)){
if (mMediaRecorderRecording){
onStopVideoRecording(true);
}else{
startVideoRecording();
}
}
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;
}
mSurfaceHolder = holder;
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.
if (holder.isCreating()) {
setPreviewDisplay(holder);
} else {
stopVideoRecording();
restartPreview();
}
}
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;
}
setResult(resultCode, resultIntent);
finish();
}
/**
* Returns
*
* @return number of bytes available, or an ERROR code.
*/
private long getAvailableStorage() {
try {
if (!ImageManager.hasStorage()) {
return NO_STORAGE_ERROR;
} else {
String storageDirectory =
ImageManager.getStorageDirectory();
StatFs stat = new StatFs(storageDirectory);
return (long) stat.getAvailableBlocks()
* (long) stat.getBlockSize();
}
} catch (Exception ex) {
// if we can't stat the filesystem then we don't know how many
// free bytes exist. It might be zero but just leave it
// blank since we really don't know.
Log.e(TAG, "Fail to access sdcard", ex);
return CANNOT_STAT_ERROR;
}
}
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;
}
}
}
private android.hardware.Camera mCameraDevice;
// 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;
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);
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
mMediaRecorder.setProfile(mProfile);
mMediaRecorder.setMaxDuration(mMaxVideoDurationInMs);
// Set output file.
if (mStorageStatus != STORAGE_STATUS_OK) {
mMediaRecorder.setOutputFile("/dev/null");
} else {
// Try Uri in the intent first. If it doesn't exist, use our own
// instead.
if (mVideoFileDescriptor != null) {
mMediaRecorder.setOutputFile(mVideoFileDescriptor.getFileDescriptor());
try {
mVideoFileDescriptor.close();
} catch (IOException e) {
Log.e(TAG, "Fail to close fd", e);
}
} else {
createVideoPath();
mMediaRecorder.setOutputFile(mVideoFilename);
}
}
mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
// Set maximum file size.
// remaining >= LOW_STORAGE_THRESHOLD at this point, reserve a quarter
// of that to make it more likely that recording can complete
// successfully.
long maxFileSize = getAvailableStorage() - LOW_STORAGE_THRESHOLD / 4;
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.
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);
mOrientationHint = rotation;
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 releaseMediaRecorder() {
Log.d(TAG, "Releasing media recorder.");
if (mMediaRecorder != null) {
cleanupEmptyFile();
Log.d(TAG, "xxxxxxxxx reset recorder");
mMediaRecorder.reset();
Log.d(TAG, "xxxxxxxxx release recorder");
mMediaRecorder.release();
mMediaRecorder = null;
}
// Take back the camera object control from media recorder. Camera
// device may be null if the activity is paused.
if (mCameraDevice != null) mCameraDevice.lock();
}
private void createVideoPath() {
long dateTaken = System.currentTimeMillis();
String title = createName(dateTaken);
String filename = title +
(MediaRecorder.OutputFormat.MPEG_4 == mProfile.fileFormat ? ".m4v" : ".3gp"); // Used when emailing.
String cameraDirPath = ImageManager.getCameraImageDirectory();
String filePath = cameraDirPath + "/" + filename;
File cameraDir = new File(cameraDirPath);
cameraDir.mkdirs();
ContentValues values = new ContentValues(7);
values.put(Video.Media.TITLE, title);
values.put(Video.Media.DISPLAY_NAME, filename);
values.put(Video.Media.DATE_TAKEN, dateTaken);
values.put(Video.Media.MIME_TYPE, "video/" +
(MediaRecorder.OutputFormat.MPEG_4 == mProfile.fileFormat ? "mp4" : "3gpp"));
values.put(Video.Media.DATA, filePath);
mVideoFilename = filePath;
Log.v(TAG, "Current camera video filename: " + mVideoFilename);
mCurrentVideoValues = values;
}
private void registerVideo() {
if (mVideoFileDescriptor == null) {
Uri videoTable = Uri.parse("content://media/external/video/media");
mCurrentVideoValues.put(Video.Media.SIZE,
new File(mCurrentVideoFilename).length());
try {
mCurrentVideoUri = mContentResolver.insert(videoTable,
mCurrentVideoValues);
} 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() {
if (mCurrentVideoFilename != null) {
deleteVideoFile(mCurrentVideoFilename);
mCurrentVideoFilename = null;
}
if (mCurrentVideoUri != null) {
mContentResolver.delete(mCurrentVideoUri, null, null);
mCurrentVideoUri = null;
}
updateAndShowStorageHint(true);
}
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, false, new Runnable() {
public void run() {
switchToCameraMode();
}
});
MenuItem gallery = menu.add(Menu.NONE, Menu.NONE,
MenuHelper.POSITION_GOTO_GALLERY,
R.string.camera_gallery_photos_text)
.setOnMenuItemClickListener(
new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
gotoGallery();
return true;
}
});
gallery.setIcon(android.R.drawable.ic_menu_gallery);
mGalleryItems.add(gallery);
if (mNumberOfCameras > 1) {
menu.add(Menu.NONE, Menu.NONE,
MenuHelper.POSITION_SWITCH_CAMERA_ID,
R.string.switch_camera_id)
.setOnMenuItemClickListener(new OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
switchCameraId((mCameraId + 1) % mNumberOfCameras);
return true;
}
}).setIcon(android.R.drawable.ic_menu_camera);
}
}
private void switchCameraId(int cameraId) {
if (mPausing) return;
mCameraId = cameraId;
CameraSettings.writePreferredCameraId(mPreferences, cameraId);
// This is similar to what mShutterButton.performClick() does,
// but not quite the same.
if (mMediaRecorderRecording) {
if (mIsVideoCaptureIntent) {
stopVideoRecording();
showAlert();
} else {
stopVideoRecordingAndGetThumbnail();
}
} else {
stopVideoRecording();
}
closeCamera();
// Reload the preferences.
mPreferences.setLocalId(this, mCameraId);
CameraSettings.upgradeLocalPreferences(mPreferences.getLocal());
// Read media profile again because camera id is changed.
readVideoPreferences();
resizeForPreviewAspectRatio();
restartPreview();
// Reload the UI.
initializeHeadUpDisplay();
}
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) {
if (what == MediaRecorder.MEDIA_RECORDER_ERROR_UNKNOWN) {
// We may have run out of space on the sdcard.
stopVideoRecording();
updateAndShowStorageHint(true);
}
}
// 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(VideoCamera.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);
}
private void startVideoRecording() {
Log.v(TAG, "startVideoRecording");
if (mStorageStatus != STORAGE_STATUS_OK) {
Log.v(TAG, "Storage issue, ignore the start request");
return;
}
if (CameraSettings.isCamcoderFocusAtStart()) {
mCameraDevice.autoFocus(null);
}
CameraSettings.setContinuousAf(mParameters, true);
setCameraHardwareParameters();
initializeRecorder();
if (mMediaRecorder == null) {
Log.e(TAG, "Fail to initialize media recorder");
return;
}
pauseAudioPlayback();
try {
mMediaRecorder.start(); // Recording is now started
} catch (RuntimeException e) {
Log.e(TAG, "Could not start media recorder. ", e);
releaseMediaRecorder();
return;
}
mHeadUpDisplay.setVideoQualityControlsEnabled(false);
mMediaRecorderRecording = true;
mRecordingStartTime = SystemClock.uptimeMillis();
updateRecordingIndicator(false);
// Rotate the recording time.
mRecordingTimeRect.setOrientation(mOrientationCompensation);
mRecordingTimeView.setText("");
mRecordingTimeView.setVisibility(View.VISIBLE);
updateRecordingTime();
keepScreenOn();
}
private void updateRecordingIndicator(boolean showRecording) {
int drawableId =
showRecording ? R.drawable.btn_ic_video_record
: R.drawable.btn_ic_video_record_stop;
Drawable drawable = getResources().getDrawable(drawableId);
mShutterButton.setImageDrawable(drawable);
}
private void stopVideoRecordingAndGetThumbnail() {
stopVideoRecording();
acquireVideoThumb();
}
private void stopVideoRecordingAndReturn(boolean valid) {
stopVideoRecording();
doReturnToCaller(valid);
}
private void stopVideoRecordingAndShowAlert() {
stopVideoRecording();
showAlert();
}
private void showAlert() {
fadeOut(findViewById(R.id.shutter_button));
if (mCurrentVideoFilename != null) {
Bitmap src = ThumbnailUtils.createVideoThumbnail(
mCurrentVideoFilename, Video.Thumbnails.MINI_KIND);
// MetadataRetriever already rotates the thumbnail. We should rotate
// it back (and mirror if it is front-facing camera).
CameraInfo[] info = CameraHolder.instance().getCameraInfo();
if (info[mCameraId].facing == CameraInfo.CAMERA_FACING_BACK) {
src = Util.rotateAndMirror(src, -mOrientationHint, false);
} else {
src = Util.rotateAndMirror(src, -mOrientationHint, true);
}
mVideoFrame.setImageBitmap(src);
mVideoFrame.setVisibility(View.VISIBLE);
}
int[] pickIds = {R.id.btn_retake, R.id.btn_done, R.id.btn_play};
for (int id : pickIds) {
View button = findViewById(id);
fadeIn(((View) button.getParent()));
}
}
private void hideAlert() {
mVideoFrame.setVisibility(View.INVISIBLE);
fadeIn(findViewById(R.id.shutter_button));
int[] pickIds = {R.id.btn_retake, R.id.btn_done, R.id.btn_play};
for (int id : pickIds) {
View button = findViewById(id);
fadeOut(((View) button.getParent()));
}
}
private static void fadeIn(View view) {
view.setVisibility(View.VISIBLE);
Animation animation = new AlphaAnimation(0F, 1F);
animation.setDuration(500);
view.startAnimation(animation);
}
private static void fadeOut(View view) {
view.setVisibility(View.INVISIBLE);
Animation animation = new AlphaAnimation(1F, 0F);
animation.setDuration(500);
view.startAnimation(animation);
}
private boolean isAlertVisible() {
return this.mVideoFrame.getVisibility() == View.VISIBLE;
}
private void viewLastVideo() {
Intent intent = null;
if (mThumbController.isUriValid()) {
intent = new Intent(Util.REVIEW_ACTION, mThumbController.getUri());
try {
startActivity(intent);
} catch (ActivityNotFoundException ex) {
try {
intent = new Intent(Intent.ACTION_VIEW, mThumbController.getUri());
startActivity(intent);
} catch (ActivityNotFoundException e) {
Log.e(TAG, "review video fail", e);
}
}
} else {
Log.e(TAG, "Can't view last video.");
}
}
private void stopVideoRecording() {
Log.v(TAG, "stopVideoRecording");
if (mMediaRecorderRecording) {
boolean needToRegisterRecording = false;
mMediaRecorder.setOnErrorListener(null);
mMediaRecorder.setOnInfoListener(null);
try {
mMediaRecorder.stop();
mCurrentVideoFilename = mVideoFilename;
Log.v(TAG, "Setting current video filename: "
+ mCurrentVideoFilename);
needToRegisterRecording = true;
} catch (RuntimeException e) {
Log.e(TAG, "stop fail: " + e.getMessage());
deleteVideoFile(mVideoFilename);
}
mMediaRecorderRecording = false;
mHeadUpDisplay.setVideoQualityControlsEnabled(true);
updateRecordingIndicator(true);
mRecordingTimeView.setVisibility(View.GONE);
keepScreenOnAwhile();
if (needToRegisterRecording && mStorageStatus == STORAGE_STATUS_OK) {
registerVideo();
}
mVideoFilename = null;
mVideoFileDescriptor = null;
}
releaseMediaRecorder(); // always release media recorder
}
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 acquireVideoThumb() {
Bitmap videoFrame = ThumbnailUtils.createVideoThumbnail(
mCurrentVideoFilename, Video.Thumbnails.MINI_KIND);
mThumbController.setData(mCurrentVideoUri, videoFrame);
mThumbController.updateDisplayIfNeeded();
}
private static ImageManager.DataLocation dataLocation() {
return ImageManager.DataLocation.EXTERNAL;
}
private void updateThumbnailButton() {
// Update the last video thumbnail.
if (!mIsVideoCaptureIntent) {
if (!mThumbController.isUriValid()) {
updateLastVideo();
}
mThumbController.updateDisplayIfNeeded();
}
}
private void updateLastVideo() {
IImageList list = ImageManager.makeImageList(
mContentResolver,
dataLocation(),
ImageManager.INCLUDE_VIDEOS,
ImageManager.SORT_ASCENDING,
ImageManager.getCameraImageBucketId());
int count = list.getCount();
if (count > 0) {
IImage image = list.getImageAt(count - 1);
Uri uri = image.fullSizeImageUri();
mThumbController.setData(uri, image.miniThumbBitmap());
} else {
mThumbController.setData(null, null);
}
list.close();
}
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 next_update_delay = 1000 - (delta % 1000);
long seconds;
if (countdownRemainingTime) {
delta = Math.max(0, mMaxVideoDurationInMs - delta);
seconds = (delta + 999) / 1000;
} else {
seconds = delta / 1000; // round to nearest
}
long minutes = seconds / 60;
long hours = minutes / 60;
long remainderMinutes = minutes - (hours * 60);
long remainderSeconds = seconds - (minutes * 60);
String secondsString = Long.toString(remainderSeconds);
if (secondsString.length() < 2) {
secondsString = "0" + secondsString;
}
String minutesString = Long.toString(remainderMinutes);
if (minutesString.length() < 2) {
minutesString = "0" + minutesString;
}
String text = minutesString + ":" + secondsString;
if (hours > 0) {
String hoursString = Long.toString(hours);
if (hoursString.length() < 2) {
hoursString = "0" + hoursString;
}
text = hoursString + ":" + text;
}
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);
}
mHandler.sendEmptyMessageDelayed(
UPDATE_RECORD_TIME, next_update_delay);
}
private void setCameraParameters() {
if (mMediaRecorder == null) {
mParameters = mCameraDevice.getParameters();
}
mProfile.videoFrameWidth = 640;//joy
mProfile.videoFrameHeight = 480;//joy
Log.v(TAG, " preview format YUY2");
mParameters.setPreviewFormat(ImageFormat.YUY2); //joy
mParameters.setPreviewSize(mProfile.videoFrameWidth, mProfile.videoFrameHeight);
mParameters.setPreviewFrameRate(mProfile.videoFrameRate);
Log.v(TAG, " pic size 640x480");
mParameters.setPictureSize(640, 480);
// 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);
}
}
setCommonParameters();
setWhiteBalance();
try {
setCameraHardwareParameters();
} catch (Exception e) {
// Some phones with dual cameras fail to report the actual parameters
// on the FFC. Filtering is device-specific but would be better.
Log.e(TAG, "Error setting parameters: " + e.getMessage());
}
}
private void setCameraHardwareParameters() {
CameraSettings.dumpParameters(mParameters);
if (mMediaRecorder != null) {
Log.d(TAG, "*** SET PARAMS VIA MEDIARECORDER!");
mMediaRecorder.setCameraParameters(mParameters.flatten());
} else {
mCameraDevice.setParameters(mParameters);
}
}
private boolean switchToCameraMode() {
if (isFinishing() || mMediaRecorderRecording) return false;
MenuHelper.gotoCameraMode(this);
finish();
return true;
}
public boolean onSwitchChanged(Switcher source, boolean onOff) {
if (onOff == SWITCH_CAMERA) {
return switchToCameraMode();
} else {
return true;
}
}
@Override
public void onConfigurationChanged(Configuration config) {
super.onConfigurationChanged(config);
// If the camera resumes behind the lock screen, the orientation
// will be portrait. That causes OOM when we try to allocation GPU
// memory for the GLSurfaceView again when the orientation changes. So,
// we delayed initialization of HeadUpDisplay until the orientation
// becomes landscape.
changeHeadUpDisplayState();
}
private void resetCameraParameters() {
// We need to restart the preview if preview size is changed.
Size size = mParameters.getPreviewSize();
boolean sizeChanged = true;
if (mProfile != null) {
sizeChanged = size.width != mProfile.videoFrameWidth
|| size.height != mProfile.videoFrameHeight;
}
if (sizeChanged) {
// It is assumed media recorder is released before
// onSharedPreferenceChanged, so we can close the camera here.
mCameraDevice.stopPreview();
releaseMediaRecorder();
closeCamera();
resizeForPreviewAspectRatio();
restartPreview(); // Parameters will be set in startPreview().
initializeHeadUpDisplay();
} else {
setCameraParameters();
}
}
private class MyHeadUpDisplayListener implements HeadUpDisplay.Listener {
public void onSharedPreferencesChanged() {
mHandler.post(new Runnable() {
public void run() {
VideoCamera.this.onSharedPreferencesChanged();
}
});
}
public void onRestorePreferencesClicked() {
mHandler.post(new Runnable() {
public void run() {
VideoCamera.this.onRestorePreferencesClicked();
}
});
}
public void onPopupWindowVisibilityChanged(final int visibility) {
}
}
private void onRestorePreferencesClicked() {
Runnable runnable = new Runnable() {
public void run() {
mHeadUpDisplay.restorePreferences(mParameters);
}
};
MenuHelper.confirmAction(this,
getString(R.string.confirm_restore_title),
getString(R.string.confirm_restore_message),
runnable);
}
private void onSharedPreferencesChanged() {
// ignore the events after "onPause()" or preview has not started yet
if (mPausing) return;
synchronized (mPreferences) {
readVideoPreferences();
// If mCameraDevice is not ready then we can set the parameter in
// startPreview().
if (mCameraDevice == null) return;
// Check if camera id is changed.
int cameraId = CameraSettings.readPreferredCameraId(mPreferences);
if (mCameraId != cameraId) {
switchCameraId(cameraId);
} else {
resetCameraParameters();
}
}
}
private class ZoomGestureListener extends GestureDetector.SimpleOnGestureListener {
@Override
public boolean onDoubleTap(MotionEvent e) {
// Perform zoom only when preview is started and snapshot is not in
// progress.
if (mPausing || !mPreviewing || mHeadUpDisplay == null) {
return false;
}
if (mZoomValue < mZoomMax) {
// Zoom in to the maximum.
mZoomValue = mZoomMax;
} else {
mZoomValue = 0;
}
setCameraParameters();
mHeadUpDisplay.setZoomIndex(mZoomValue);
return true;
}
}
private void initializeZoom() {
if (!mParameters.isZoomSupported()) return;
// Maximum zoom value may change after preview size is set. Get the
// latest parameters here.
mZoomMax = mParameters.getMaxZoom();
mGestureDetector = new GestureDetector(this, new ZoomGestureListener());
mCameraDevice.setZoomChangeListener(mZoomListener);
}
private void onZoomValueChanged(int index) {
Log.d(TAG, "VideoZoom: " + index);
mZoomValue = index;
mParameters.setZoom(index);
setCameraHardwareParameters();
Log.d(TAG, "params after zoom: " + mParameters.flatten());
}
private float[] getZoomRatios() {
List<Integer> zoomRatios = mParameters.getZoomRatios();
if (mParameters.get("taking-picture-zoom") != null) {
// HTC camera zoom
float result[] = new float[mZoomMax + 1];
for (int i = 0, n = result.length; i < n; ++i) {
result[i] = 1 + i * 0.2f;
}
return result;
} else if (zoomRatios != null) {
float result[] = new float[zoomRatios.size()];
for (int i = 0, n = result.length; i < n; ++i) {
result[i] = (float) zoomRatios.get(i) / 100f;
}
return result;
}
float[] result = new float[1];
result[0] = 0.0f;
return result;
}
@Override
public boolean dispatchTouchEvent(MotionEvent m) {
if (!super.dispatchTouchEvent(m) && mGestureDetector != null) {
return mGestureDetector.onTouchEvent(m);
}
return true;
}
private final class ZoomListener implements android.hardware.Camera.OnZoomChangeListener {
public void onZoomChange(int value, boolean stopped, android.hardware.Camera camera) {
Log.d(TAG, "Zoom changed: value=" + value + ". stopped=" + stopped);
mZoomValue = 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);
}
}
}