import android.provider.MediaStore;
import android.provider.MediaStore.MediaColumns;
import android.provider.MediaStore.Video;
-import android.util.Log;
import android.view.KeyEvent;
import android.view.OrientationEventListener;
import android.view.View;
import com.android.camera.app.MediaSaver;
import com.android.camera.app.MemoryManager;
import com.android.camera.app.MemoryManager.MemoryListener;
+import com.android.camera.debug.Log;
import com.android.camera.exif.ExifInterface;
import com.android.camera.hardware.HardwareSpec;
import com.android.camera.hardware.HardwareSpecImpl;
import com.android.camera.module.ModuleController;
import com.android.camera.settings.SettingsManager;
import com.android.camera.settings.SettingsUtil;
-import com.android.camera.util.AccessibilityUtils;
import com.android.camera.util.ApiHelper;
import com.android.camera.util.CameraUtil;
import com.android.camera.util.UsageStatistics;
MediaRecorder.OnErrorListener,
MediaRecorder.OnInfoListener, FocusOverlayManager.Listener {
- private static final String TAG = "VideoModule";
+ private static final Log.Tag TAG = new Log.Tag("VideoModule");
// Messages defined for the UI thread handler.
private static final int MSG_CHECK_DISPLAY_ROTATION = 4;
private int mMaxVideoDurationInMs;
// Time Lapse parameters.
- private boolean mCaptureTimeLapse = false;
+ private final boolean mCaptureTimeLapse = false;
// Default 0. If it is larger than 0, the camcorder is in time lapse mode.
- private int mTimeBetweenTimeLapseFrameCaptureMs = 0;
+ private final int mTimeBetweenTimeLapseFrameCaptureMs = 0;
boolean mPreviewing = false; // True if preview is started.
// The display rotation in degrees. This is only valid when mPreviewing is
null, null, null, new JpegPictureCallback(loc));
showVideoSnapshotUI(true);
mSnapshotInProgress = true;
- UsageStatistics.captureEvent(eventprotos.NavigationChange.Mode.VIDEO_STILL,
- null, null);
+ UsageStatistics.instance().captureEvent(
+ eventprotos.NavigationChange.Mode.VIDEO_STILL, null, null, null);
}
}
}
/**
+ * @return Whether the currently active camera is front-facing.
+ */
+ private boolean isCameraFrontFacing() {
+ CameraInfo info = mAppController.getCameraProvider().getCameraInfo()[mCameraId];
+ return info.facing == CameraInfo.CAMERA_FACING_FRONT;
+ }
+
+ /**
* The focus manager gets initialized after camera is available.
*/
private void initializeFocusManager() {
if (mFocusManager != null) {
mFocusManager.removeMessages();
} else {
- CameraInfo info = mAppController.getCameraProvider().getCameraInfo()[mCameraId];
- mMirror = (info.facing == CameraInfo.CAMERA_FACING_FRONT);
+ mMirror = isCameraFrontFacing();
String[] defaultFocusModes = mActivity.getResources().getStringArray(
R.array.pref_camera_focusmode_default_array);
mFocusManager = new FocusOverlayManager(mActivity.getSettingsManager(),
};
@Override
+ public void hardResetSettings(SettingsManager settingsManager) {
+ // VideoModule does not need to hard reset any settings.
+ }
+
+ @Override
public HardwareSpec getHardwareSpec() {
return (mParameters != null ? new HardwareSpecImpl(mParameters) : null);
}
// The preference stores values from ListPreference and is thus string type for all values.
// We need to convert it to int manually.
SettingsManager settingsManager = mActivity.getSettingsManager();
- if (!settingsManager.isSet(SettingsManager.SETTING_VIDEO_QUALITY)) {
- settingsManager.setDefault(SettingsManager.SETTING_VIDEO_QUALITY);
+ if (!settingsManager.isSet(SettingsManager.SETTING_VIDEO_QUALITY_BACK)) {
+ settingsManager.setDefault(SettingsManager.SETTING_VIDEO_QUALITY_BACK);
+ }
+ if (!settingsManager.isSet(SettingsManager.SETTING_VIDEO_QUALITY_FRONT)) {
+ settingsManager.setDefault(SettingsManager.SETTING_VIDEO_QUALITY_FRONT);
}
- String videoQuality = settingsManager.get(SettingsManager.SETTING_VIDEO_QUALITY);
+ String videoQuality = settingsManager
+ .get(isCameraFrontFacing() ? SettingsManager.SETTING_VIDEO_QUALITY_FRONT
+ : SettingsManager.SETTING_VIDEO_QUALITY_BACK);
int quality = SettingsUtil.getVideoQuality(videoQuality, mCameraId);
Log.d(TAG, "Selected video quality for '" + videoQuality + "' is " + quality);
mMaxVideoDurationInMs = CameraSettings.getMaxVideoDuration(mActivity);
}
- // Read time lapse recording interval.
+ // TODO: Uncomment this block to re-enable time-lapse.
+ /* // Read time lapse recording interval.
String frameIntervalStr = settingsManager.get(
SettingsManager.SETTING_VIDEO_TIME_LAPSE_FRAME_INTERVAL);
mTimeBetweenTimeLapseFrameCaptureMs = Integer.parseInt(frameIntervalStr);
// TODO: This should be checked instead directly +1000.
if (mCaptureTimeLapse) {
quality += 1000;
- }
+ } */
// If quality is not supported, request QUALITY_HIGH which is always supported.
if (CamcorderProfile.hasProfile(mCameraId, quality) == false) {
return;
}
- mCameraDevice.setErrorCallback(mErrorCallback);
+ mCameraDevice.setErrorCallback(mHandler, mErrorCallback);
if (mPreviewing == true) {
stopPreview();
}
return;
}
mCameraDevice.setZoomChangeListener(null);
- mCameraDevice.setErrorCallback(null);
+ mCameraDevice.setErrorCallback(null, null);
mActivity.getCameraProvider().releaseCamera(mCameraDevice.getCameraId());
mCameraDevice = null;
mPreviewing = false;
mUI.clickShutter();
return true;
}
- break;
case KeyEvent.KEYCODE_DPAD_CENTER:
if (event.getRepeatCount() == 0) {
mUI.clickShutter();
return true;
}
- break;
case KeyEvent.KEYCODE_MENU:
- if (mMediaRecorderRecording) {
- return true;
- }
- break;
+ // Consume menu button presses during capture.
+ return mMediaRecorderRecording;
}
return false;
}
case KeyEvent.KEYCODE_CAMERA:
mUI.pressShutter(false);
return true;
+ case KeyEvent.KEYCODE_MENU:
+ // Consume menu button presses during capture.
+ return mMediaRecorderRecording;
}
return false;
}
int rotation = 0;
if (mOrientation != OrientationEventListener.ORIENTATION_UNKNOWN) {
CameraInfo info = mActivity.getCameraProvider().getCameraInfo()[mCameraId];
- if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
+ if (isCameraFrontFacing()) {
rotation = (info.orientation - mOrientation + 360) % 360;
} else { // back-facing camera
rotation = (info.orientation + mOrientation) % 360;
mCurrentVideoValues.put(MediaColumns.DATE_MODIFIED, dateTaken / 1000);
mCurrentVideoValues.put(Video.Media.MIME_TYPE, mime);
mCurrentVideoValues.put(Video.Media.DATA, path);
+ mCurrentVideoValues.put(Video.Media.WIDTH, mProfile.videoFrameWidth);
+ mCurrentVideoValues.put(Video.Media.HEIGHT, mProfile.videoFrameHeight);
mCurrentVideoValues.put(Video.Media.RESOLUTION,
Integer.toString(mProfile.videoFrameWidth) + "x" +
Integer.toString(mProfile.videoFrameHeight));
mUI.showFocusUI(false);
mUI.showVideoRecordingHints(false);
- // A special case of mode options closing: during capture it should
- // not be possible to change mode state.
- mAppController.getCameraAppUI().hideModeOptions();
- mAppController.getCameraAppUI().animateBottomBarToCircle(R.drawable.ic_stop);
-
mActivity.updateStorageSpaceAndHint();
if (mActivity.getStorageSpaceBytes() <= Storage.LOW_STORAGE_THRESHOLD_BYTES) {
Log.v(TAG, "Storage issue, ignore the start request");
}
mAppController.getCameraAppUI().setSwipeEnabled(false);
- // Make sure the video recording has started before announcing
- // this in accessibility.
- AccessibilityUtils.makeAnnouncement(mUI.getShutterButton(),
- mActivity.getString(R.string.video_recording_started));
-
// The parameters might have been altered by MediaRecorder already.
// We need to force mCameraDevice to refresh before getting it.
mCameraDevice.refreshParameters();
mMediaRecorderRecording = true;
mActivity.lockOrientation();
mRecordingStartTime = SystemClock.uptimeMillis();
+
+ // A special case of mode options closing: during capture it should
+ // not be possible to change mode state.
+ mAppController.getCameraAppUI().hideModeOptions();
+ mAppController.getCameraAppUI().animateBottomBarToVideoStop(R.drawable.ic_stop);
mUI.showRecordingUI(true);
setFocusParameters();
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 = mActivity.getCameraProvider().getCameraInfo();
- boolean mirror = (info[mCameraId].facing == CameraInfo.CAMERA_FACING_FRONT);
- bitmap = CameraUtil.rotateAndMirror(bitmap, 0, mirror);
+ bitmap = CameraUtil.rotateAndMirror(bitmap, 0, isCameraFrontFacing());
}
return bitmap;
}
mUI.showFocusUI(true);
mUI.showVideoRecordingHints(true);
- mAppController.getCameraAppUI().showModeOptions();
- mAppController.getCameraAppUI().animateBottomBarToFullSize(mShutterIconId);
-
boolean fail = false;
if (mMediaRecorderRecording) {
boolean shouldAddToMediaStoreNow = false;
String statisticFilename = (mCurrentVideoFilename == null
? "INTENT"
: mCurrentVideoFilename);
- UsageStatistics.captureEvent(eventprotos.NavigationChange.Mode.VIDEO_CAPTURE,
- statisticFilename, mParameters, duration);
- AccessibilityUtils.makeAnnouncement(mUI.getShutterButton(),
- mActivity.getAndroidContext().getString(R.string
- .video_recording_stopped));
+ UsageStatistics.instance().captureEvent(
+ eventprotos.NavigationChange.Mode.VIDEO_CAPTURE, statisticFilename,
+ mParameters, duration);
} catch (RuntimeException e) {
Log.e(TAG, "stop fail", e);
if (mVideoFilename != null) {
}
// release media recorder
releaseMediaRecorder();
+
+ mAppController.getCameraAppUI().showModeOptions();
+ mAppController.getCameraAppUI().animateBottomBarToFullSize(mShutterIconId);
if (!mPaused) {
setFocusParameters();
mCameraDevice.lock();
enableTorchMode(settingsManager.isCameraBackFacing());
- // Set white balance parameter.
- String whiteBalance = settingsManager.get(SettingsManager.SETTING_WHITE_BALANCE);
- 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);
mHandler.sendEmptyMessageDelayed(MSG_CHECK_DISPLAY_ROTATION, 100);
}
- UsageStatistics.changeScreen(eventprotos.NavigationChange.Mode.VIDEO_CAPTURE,
+ UsageStatistics.instance().changeScreen(eventprotos.NavigationChange.Mode.VIDEO_CAPTURE,
eventprotos.CameraEvent.InteractionCause.BUTTON);
getServices().getMemoryManager().addListener(this);
}
closeCamera();
requestCamera(mCameraId);
- CameraInfo info = mActivity.getCameraProvider().getCameraInfo()[mCameraId];
- mMirror = (info.facing == CameraInfo.CAMERA_FACING_FRONT);
+ mMirror = isCameraFrontFacing();
if (mFocusManager != null) {
mFocusManager.setMirror(mMirror);
}
OSDN Git Service
