/* * 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 java.io.File; import java.io.FileDescriptor; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import android.app.Activity; 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.database.Cursor; import android.graphics.Bitmap; import android.graphics.drawable.Drawable; import android.location.LocationManager; import android.media.MediaRecorder; import android.net.Uri; import android.os.Bundle; import android.os.Environment; import android.os.Handler; import android.os.Message; import android.os.StatFs; import android.os.SystemClock; import android.preference.PreferenceManager; import android.provider.MediaStore; import android.provider.MediaStore.Video; import android.text.format.DateFormat; import android.util.Log; import android.view.KeyEvent; import android.view.Menu; import android.view.MenuItem; import android.view.SurfaceHolder; import android.view.View; import android.view.Window; import android.view.WindowManager; import android.view.MenuItem.OnMenuItemClickListener; import android.view.animation.AlphaAnimation; import android.view.animation.Animation; import android.widget.ImageView; import android.widget.TextView; import android.widget.Toast; public class VideoCamera extends Activity implements View.OnClickListener, ShutterButton.OnShutterButtonListener, SurfaceHolder.Callback, MediaRecorder.OnErrorListener, MediaRecorder.OnInfoListener { private static final String TAG = "videocamera"; private static final boolean DEBUG = true; private static final boolean DEBUG_SUPPRESS_AUDIO_RECORDING = DEBUG && false; private static final int CLEAR_SCREEN_DELAY = 4; private static final int UPDATE_RECORD_TIME = 5; private static final int SCREEN_DELAY = 2 * 60 * 1000; 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 long SHARE_FILE_LENGTH_LIMIT = 3L * 1024L * 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; public static final int MENU_SETTINGS = 6; public static final int MENU_GALLERY_PHOTOS = 7; public static final int MENU_GALLERY_VIDEOS = 8; public static final int MENU_SAVE_GALLERY_PHOTO = 34; public static final int MENU_SAVE_PLAY_VIDEO = 35; public static final int MENU_SAVE_SELECT_VIDEO = 36; public static final int MENU_SAVE_NEW_VIDEO = 37; SharedPreferences mPreferences; private static final float VIDEO_ASPECT_RATIO = 176.0f / 144.0f; VideoPreview mVideoPreview; SurfaceHolder mSurfaceHolder = null; ImageView mVideoFrame; private boolean mIsVideoCaptureIntent; // mLastPictureButton and mThumbController // are non-null only if isVideoCaptureIntent() is true; private ImageView mLastPictureButton; private ThumbnailController mThumbController; private static final int MAX_RECORDING_DURATION_MS = 10 * 60 * 1000; 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 mCameraVideoFilename; private FileDescriptor mCameraVideoFileDescriptor; // The video file that has already been recorded, and that is being // examined by the user. private String mCurrentVideoFilename; private long mCurrentVideoFileLength = 0L; private Uri mCurrentVideoUri; private ContentValues mCurrentVideoValues; boolean mPausing = false; static ContentResolver mContentResolver; int mCurrentZoomIndex = 0; private ShutterButton mShutterButton; private TextView mRecordingTimeView; private boolean mRecordingTimeCountsDown = false; ArrayList mGalleryItems = new ArrayList(); View mPostPictureAlert; LocationManager mLocationManager = null; private Handler mHandler = new MainHandler(); /** 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 CLEAR_SCREEN_DELAY: { clearScreenOnFlag(); break; } case UPDATE_RECORD_TIME: { if (mMediaRecorderRecording) { 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 countdown_remaining_time = (delta >= MAX_RECORDING_DURATION_MS - 60000); if (countdown_remaining_time) { delta = Math.max(0, MAX_RECORDING_DURATION_MS - delta); } long seconds = (delta + 500) / 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 != countdown_remaining_time) { // Avoid setting the color on every update, do it only // when it needs changing. mRecordingTimeCountsDown = countdown_remaining_time; int color = getResources().getColor( countdown_remaining_time ? R.color.recording_time_remaining_text : R.color.recording_time_elapsed_text); mRecordingTimeView.setTextColor(color); } // Work around a limitation of the T-Mobile G1: The T-Mobile // hardware blitter can't pixel-accurately scale and clip at the same time, // and the SurfaceFlinger doesn't attempt to work around this limitation. // In order to avoid visual corruption we must manually refresh the entire // surface view when changing any overlapping view's contents. mVideoPreview.invalidate(); mHandler.sendEmptyMessageDelayed(UPDATE_RECORD_TIME, 1000); } break; } default: Log.v(TAG, "Unhandled message: " + msg.what); break; } } }; private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (action.equals(Intent.ACTION_MEDIA_EJECT)) { updateAndShowStorageHint(false); stopVideoRecording(); initializeVideo(); } else if (action.equals(Intent.ACTION_MEDIA_MOUNTED)) { updateAndShowStorageHint(true); initializeVideo(); } 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); } } }; static private String createName(long dateTaken) { return DateFormat.format("yyyy-MM-dd kk.mm.ss", dateTaken).toString(); } /** Called with the activity is first created. */ @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE); mPreferences = PreferenceManager.getDefaultSharedPreferences(this); mContentResolver = getContentResolver(); //setDefaultKeyMode(DEFAULT_KEYS_SHORTCUT); requestWindowFeature(Window.FEATURE_PROGRESS); setContentView(R.layout.video_camera); mVideoPreview = (VideoPreview) findViewById(R.id.camera_preview); mVideoPreview.setAspectRatio(VIDEO_ASPECT_RATIO); // 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); mPostPictureAlert = findViewById(R.id.post_picture_panel); int[] ids = new int[]{R.id.play, R.id.share, R.id.discard, R.id.cancel, R.id.attach}; for (int id : ids) { findViewById(id).setOnClickListener(this); } mShutterButton = (ShutterButton) findViewById(R.id.shutter_button); mShutterButton.setOnShutterButtonListener(this); mRecordingTimeView = (TextView) findViewById(R.id.recording_time); mVideoFrame = (ImageView) findViewById(R.id.video_frame); mIsVideoCaptureIntent = isVideoCaptureIntent(); if (!mIsVideoCaptureIntent) { mLastPictureButton = (ImageView) findViewById(R.id.last_picture_button); mLastPictureButton.setOnClickListener(this); Drawable frame = getResources().getDrawable(R.drawable.frame_thumbnail); mThumbController = new ThumbnailController(mLastPictureButton, frame, mContentResolver); mThumbController.loadData(ImageManager.getLastVideoThumbPath()); } } private void startShareVideoActivity() { if (mCurrentVideoFileLength > SHARE_FILE_LENGTH_LIMIT) { Toast.makeText(VideoCamera.this, R.string.too_large_to_attach, Toast.LENGTH_LONG).show(); return; } Intent intent = new Intent(); intent.setAction(Intent.ACTION_SEND); intent.setType("video/3gpp"); intent.putExtra(Intent.EXTRA_STREAM, mCurrentVideoUri); try { startActivity(Intent.createChooser(intent, getText(R.string.sendVideo))); } catch (android.content.ActivityNotFoundException ex) { Toast.makeText(VideoCamera.this, R.string.no_way_to_share_video, Toast.LENGTH_SHORT).show(); } } public void onClick(View v) { switch (v.getId()) { case R.id.gallery: MenuHelper.gotoCameraVideoGallery(this); break; case R.id.attach: doReturnToCaller(true); break; case R.id.cancel: doReturnToCaller(false); break; case R.id.discard: { Runnable deleteCallback = new Runnable() { public void run() { discardCurrentVideoAndStartPreview(); } }; MenuHelper.deleteVideo(this, deleteCallback); break; } case R.id.share: { startShareVideoActivity(); break; } case R.id.play: { doPlayCurrentVideo(); break; } case R.id.last_picture_button: { stopVideoRecordingAndShowAlert(); break; } } } public void onShutterButtonFocus(ShutterButton button, boolean pressed) { // Do nothing (everything happens in onShutterButtonClick). } public void onShutterButtonClick(ShutterButton button) { switch (button.getId()) { case R.id.shutter_button: if (mMediaRecorderRecording) { if (mIsVideoCaptureIntent) { stopVideoRecordingAndShowAlert(); } else { stopVideoRecordingAndGetThumbnail(); initializeVideo(); } } else if (isAlertVisible()) { if (mIsVideoCaptureIntent) { discardCurrentVideoAndStartPreview(); } else { hideAlertAndStartVideoRecording(); } } else { startVideoRecording(); } break; } } private void doPlayCurrentVideo() { Log.e(TAG, "Playing current video: " + mCurrentVideoUri); 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); } } private void discardCurrentVideoAndStartPreview() { deleteCurrentVideo(); hideAlertAndStartPreview(); } 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); } 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; } return remaining < LOW_STORAGE_THRESHOLD ? STORAGE_STATUS_LOW : STORAGE_STATUS_OK; } @Override public void onResume() { super.onResume(); setScreenTimeoutLong(); mPausing = false; // 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"); registerReceiver(mReceiver, intentFilter); mStorageStatus = getStorageStatus(true); mHandler.postDelayed(new Runnable() { public void run() { showStorageHint(); } }, 200); initializeVideo(); } @Override public void onStop() { setScreenTimeoutSystemDefault(); super.onStop(); } @Override protected void onPause() { super.onPause(); // This is similar to what mShutterButton.performClick() does, // but not quite the same. if (mMediaRecorderRecording) { if (mIsVideoCaptureIntent) { stopVideoRecordingAndShowAlert(); } else { stopVideoRecordingAndGetThumbnail(); } } else { stopVideoRecording(); } mPausing = true; unregisterReceiver(mReceiver); setScreenTimeoutSystemDefault(); if (!mIsVideoCaptureIntent) { mThumbController.storeData(ImageManager.getLastVideoThumbPath()); } if (mStorageHint != null) { mStorageHint.cancel(); mStorageHint = null; } } @Override public boolean onKeyDown(int keyCode, KeyEvent event) { setScreenTimeoutLong(); switch (keyCode) { case KeyEvent.KEYCODE_BACK: if (mMediaRecorderRecording) { mShutterButton.performClick(); return true; } else if(isAlertVisible()) { hideAlertAndStartPreview(); return true; } break; 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) { mShutterButton.performClick(); 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) { 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; } stopVideoRecording(); initializeVideo(); } public void surfaceCreated(SurfaceHolder holder) { mSurfaceHolder = holder; } public void surfaceDestroyed(SurfaceHolder holder) { mSurfaceHolder = null; } void gotoGallery() { MenuHelper.gotoCameraVideoGallery(this); } @Override public boolean onPrepareOptionsMenu(Menu menu) { super.onPrepareOptionsMenu(menu); for (int i = 1; i <= MenuHelper.MENU_ITEM_MAX; i++) { if (i != MenuHelper.GENERIC_ITEM) { menu.setGroupVisible(i, false); } } menu.setGroupVisible(MenuHelper.VIDEO_MODE_ITEM, true); return true; } @Override public boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu); if (mIsVideoCaptureIntent) { // No options menu for attach mode. return false; } else { addBaseMenuItems(menu); int menuFlags = MenuHelper.INCLUDE_ALL & ~MenuHelper.INCLUDE_ROTATE_MENU & ~MenuHelper.INCLUDE_DETAILS_MENU; MenuHelper.addImageMenuItems( menu, menuFlags, false, VideoCamera.this, mHandler, // Handler for deletion new Runnable() { public void run() { // What do we do here? // mContentResolver.delete(uri, null, null); } }, new MenuHelper.MenuInvoker() { public void run(final MenuHelper.MenuCallback cb) { } }); MenuItem gallery = menu.add(MenuHelper.IMAGE_SAVING_ITEM, MENU_SAVE_GALLERY_PHOTO, 0, R.string.camera_gallery_photos_text).setOnMenuItemClickListener( new MenuItem.OnMenuItemClickListener() { public boolean onMenuItemClick(MenuItem item) { gotoGallery(); return true; } }); gallery.setIcon(android.R.drawable.ic_menu_gallery); } return true; } private boolean isVideoCaptureIntent() { String action = getIntent().getAction(); return (MediaStore.ACTION_VIDEO_CAPTURE.equals(action)); } private void doReturnToCaller(boolean success) { Intent resultIntent = new Intent(); int resultCode; if (success) { 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 static long getAvailableStorage() { try { if (!ImageManager.hasStorage()) { return NO_STORAGE_ERROR; } else { String storageDirectory = Environment.getExternalStorageDirectory().toString(); 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. return CANNOT_STAT_ERROR; } } private void cleanupEmptyFile() { if (mCameraVideoFilename != null) { File f = new File(mCameraVideoFilename); if (f.length() == 0 && f.delete()) { Log.v(TAG, "Empty video file deleted: " + mCameraVideoFilename); mCameraVideoFilename = null; } } } // initializeVideo() starts preview and prepare media recorder. // Returns false if initializeVideo fails private boolean initializeVideo() { Log.v(TAG, "initializeVideo"); // We will call initializeVideo() again when the alert is hidden. if (isAlertVisible()) return false; Intent intent = getIntent(); Bundle myExtras = intent.getExtras(); if (mIsVideoCaptureIntent && myExtras != null) { Uri saveUri = (Uri) myExtras.getParcelable(MediaStore.EXTRA_OUTPUT); if (saveUri != null) { try { mCameraVideoFileDescriptor = mContentResolver. openFileDescriptor(saveUri, "rw").getFileDescriptor(); mCurrentVideoUri = saveUri; } catch (java.io.FileNotFoundException ex) { // invalid uri Log.e(TAG, ex.toString()); } } } releaseMediaRecorder(); if (mSurfaceHolder == null) { Log.v(TAG, "SurfaceHolder is null"); return false; } mMediaRecorder = new MediaRecorder(); if (DEBUG_SUPPRESS_AUDIO_RECORDING) { Log.v(TAG, "DEBUG_SUPPRESS_AUDIO_RECORDING is true."); } else { mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); } mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); mMediaRecorder.setMaxDuration(MAX_RECORDING_DURATION_MS); if (mStorageStatus != STORAGE_STATUS_OK) { mMediaRecorder.setOutputFile("/dev/null"); } else { // We try Uri in intent first. If it doesn't work, use our own instead. if (mCameraVideoFileDescriptor != null) { mMediaRecorder.setOutputFile(mCameraVideoFileDescriptor); } else { createVideoPath(); mMediaRecorder.setOutputFile(mCameraVideoFilename); } } boolean videoQualityHigh = getBooleanPreference(CameraSettings.KEY_VIDEO_QUALITY, CameraSettings.DEFAULT_VIDEO_QUALITY_VALUE); if (intent.hasExtra(MediaStore.EXTRA_VIDEO_QUALITY)) { int extraVideoQuality = intent.getIntExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0); videoQualityHigh = (extraVideoQuality > 0); } // Use the same frame rate for both, since internally // if the frame rate is too large, it can cause camera to become // unstable. We need to fix the MediaRecorder to disable the support // of setting frame rate for now. mMediaRecorder.setVideoFrameRate(20); if (videoQualityHigh) { mMediaRecorder.setVideoSize(352,288); } else { mMediaRecorder.setVideoSize(176,144); } mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263); if (!DEBUG_SUPPRESS_AUDIO_RECORDING) { mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); } mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface()); long remaining = getAvailableStorage(); // remaining >= LOW_STORAGE_THRESHOLD at this point, reserve a quarter // of that to make it more likely that recording can complete successfully. try { mMediaRecorder.setMaxFileSize(remaining - LOW_STORAGE_THRESHOLD / 4); } 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. } try { mMediaRecorder.prepare(); } catch (IOException exception) { Log.e(TAG, "prepare failed for " + mCameraVideoFilename); releaseMediaRecorder(); // TODO: add more exception handling logic here return false; } mMediaRecorderRecording = false; if (!mIsVideoCaptureIntent && !mThumbController.isUriValid()) { updateLastVideo(); } if (!mIsVideoCaptureIntent) { mThumbController.updateDisplayIfNeeded(); } return true; } private void releaseMediaRecorder() { Log.v(TAG, "Releasing media recorder."); if (mMediaRecorder != null) { cleanupEmptyFile(); mMediaRecorder.reset(); mMediaRecorder.release(); mMediaRecorder = null; } } private int getIntPreference(String key, int defaultValue) { String s = mPreferences.getString(key, ""); int result = defaultValue; try { result = Integer.parseInt(s); } catch (NumberFormatException e) { // Ignore, result is already the default value. } return result; } private boolean getBooleanPreference(String key, boolean defaultValue) { return getIntPreference(key, defaultValue ? 1 : 0) != 0; } private void createVideoPath() { long dateTaken = System.currentTimeMillis(); String title = createName(dateTaken); String displayName = title + ".3gp"; // Used when emailing. String cameraDirPath = ImageManager.CAMERA_IMAGE_BUCKET_NAME; File cameraDir = new File(cameraDirPath); cameraDir.mkdirs(); SimpleDateFormat dateFormat = new SimpleDateFormat( getString(R.string.video_file_name_format)); Date date = new Date(dateTaken); String filepart = dateFormat.format(date); String filename = cameraDirPath + "/" + filepart + ".3gp"; ContentValues values = new ContentValues(7); values.put(Video.Media.TITLE, title); values.put(Video.Media.DISPLAY_NAME, displayName); values.put(Video.Media.DESCRIPTION, ""); values.put(Video.Media.DATE_TAKEN, dateTaken); values.put(Video.Media.MIME_TYPE, "video/3gpp"); values.put(Video.Media.DATA, filename); mCameraVideoFilename = filename; Log.v(TAG, "Current camera video filename: " + mCameraVideoFilename); mCurrentVideoValues = values; } private void registerVideo() { if (mCameraVideoFileDescriptor == null) { Uri videoTable = Uri.parse("content://media/external/video/media"); mCurrentVideoUri = mContentResolver.insert(videoTable, mCurrentVideoValues); 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, this, false); { MenuItem gallery = menu.add(MenuHelper.IMAGE_MODE_ITEM, MENU_GALLERY_PHOTOS, 0, 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); } { MenuItem gallery = menu.add(MenuHelper.VIDEO_MODE_ITEM, MENU_GALLERY_VIDEOS, 0, 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); } MenuItem item = menu.add(MenuHelper.GENERIC_ITEM, MENU_SETTINGS, 0, R.string.settings).setOnMenuItemClickListener(new OnMenuItemClickListener() { public boolean onMenuItemClick(MenuItem item) { Intent intent = new Intent(); intent.setClass(VideoCamera.this, CameraSettings.class); startActivity(intent); return true; } }); item.setIcon(android.R.drawable.ic_menu_preferences); } // 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) { mShutterButton.performClick(); } else if (what == MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED) { mShutterButton.performClick(); updateAndShowStorageHint(true); } } /* * 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 (!mMediaRecorderRecording) { if (mStorageStatus != STORAGE_STATUS_OK) { Log.v(TAG, "Storage issue, ignore the start request"); return; } // Check mMediaRecorder to see whether it is initialized or not. if (mMediaRecorder == null && initializeVideo() == false ) { Log.e(TAG, "Initialize video (MediaRecorder) failed."); return; } pauseAudioPlayback(); try { mMediaRecorder.setOnErrorListener(this); mMediaRecorder.setOnInfoListener(this); mMediaRecorder.start(); // Recording is now started } catch (RuntimeException e) { Log.e(TAG, "Could not start media recorder. ", e); return; } mMediaRecorderRecording = true; mRecordingStartTime = SystemClock.uptimeMillis(); updateRecordingIndicator(true); mRecordingTimeView.setText(""); mRecordingTimeView.setVisibility(View.VISIBLE); mHandler.sendEmptyMessage(UPDATE_RECORD_TIME); setScreenTimeoutInfinite(); hideLastPictureButton(); } } private void updateRecordingIndicator(boolean showRecording) { int drawableId = showRecording ? R.drawable.ic_camera_bar_indicator_record : R.drawable.ic_camera_indicator_video; Drawable drawable = getResources().getDrawable(drawableId); mShutterButton.setImageDrawable(drawable); } private void stopVideoRecordingAndGetThumbnail() { stopVideoRecording(); acquireVideoThumb(); } private void stopVideoRecordingAndShowAlert() { stopVideoRecording(); showAlert(); } private void showAlert() { int[] pickIds = {R.id.attach, R.id.cancel}; int[] normalIds = {R.id.gallery, R.id.share, R.id.discard}; int[] alwaysOnIds = {R.id.play}; int[] hideIds = pickIds; int[] connectIds = normalIds; if (mIsVideoCaptureIntent) { hideIds = normalIds; connectIds = pickIds; } for(int id : hideIds) { mPostPictureAlert.findViewById(id).setVisibility(View.GONE); } ActionMenuButton shareButton = (ActionMenuButton) mPostPictureAlert.findViewById(R.id.share); shareButton.setRestricted( mCurrentVideoFileLength > SHARE_FILE_LENGTH_LIMIT); connectAndFadeIn(connectIds); connectAndFadeIn(alwaysOnIds); hideLastPictureButton(); mPostPictureAlert.setVisibility(View.VISIBLE); // There are two cases we are here: // (1) We are in a capture video intent, and we are reviewing the video // we just taken. // (2) The thumbnail button is clicked: we review the video associated // with the thumbnail. // For the second case, we copy the associated URI and filename to // mCurrentVideoUri and mCurrentVideoFilename, so the video frame shown // and the target for actions (play, delete, ...) will be correct. if (!mIsVideoCaptureIntent) { mCurrentVideoUri = mThumbController.getUri(); mCurrentVideoFilename = getDataPath(mCurrentVideoUri); } String path = mCurrentVideoFilename; if (path != null) { Bitmap videoFrame = ImageManager.createVideoThumbnail(path); mVideoFrame.setImageBitmap(videoFrame); mVideoFrame.setVisibility(View.VISIBLE); } } private void hideAlert() { mVideoFrame.setVisibility(View.INVISIBLE); mPostPictureAlert.setVisibility(View.INVISIBLE); showLastPictureButton(); } private void connectAndFadeIn(int[] connectIds) { for(int id : connectIds) { View view = mPostPictureAlert.findViewById(id); view.setOnClickListener(this); Animation animation = new AlphaAnimation(0F, 1F); animation.setDuration(500); view.startAnimation(animation); } } private boolean isAlertVisible() { return mPostPictureAlert.getVisibility() == View.VISIBLE; } private void stopVideoRecording() { Log.v(TAG, "stopVideoRecording"); boolean needToRegisterRecording = false; if (mMediaRecorderRecording || mMediaRecorder != null) { if (mMediaRecorderRecording && mMediaRecorder != null) { try { mMediaRecorder.setOnErrorListener(null); mMediaRecorder.setOnInfoListener(null); mMediaRecorder.stop(); } catch (RuntimeException e) { Log.e(TAG, "stop fail: " + e.getMessage()); } mCurrentVideoFilename = mCameraVideoFilename; try { mCurrentVideoFileLength = new File(mCurrentVideoFilename).length(); } catch (RuntimeException e) { Log.e(TAG, "get file length fail: " + e.getMessage()); mCurrentVideoFileLength = 0; } Log.v(TAG, "Setting current video filename: " + mCurrentVideoFilename); needToRegisterRecording = true; mMediaRecorderRecording = false; } releaseMediaRecorder(); updateRecordingIndicator(false); mRecordingTimeView.setVisibility(View.GONE); setScreenTimeoutLong(); } if (needToRegisterRecording && mStorageStatus == STORAGE_STATUS_OK) { registerVideo(); } mCameraVideoFilename = null; mCameraVideoFileDescriptor = null; } private void setScreenTimeoutSystemDefault() { mHandler.removeMessages(CLEAR_SCREEN_DELAY); clearScreenOnFlag(); } private void setScreenTimeoutLong() { mHandler.removeMessages(CLEAR_SCREEN_DELAY); setScreenOnFlag(); mHandler.sendEmptyMessageDelayed(CLEAR_SCREEN_DELAY, SCREEN_DELAY); } private void setScreenTimeoutInfinite() { mHandler.removeMessages(CLEAR_SCREEN_DELAY); setScreenOnFlag(); } private void clearScreenOnFlag() { Window w = getWindow(); final int keepScreenOnFlag = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; if ((w.getAttributes().flags & keepScreenOnFlag) != 0) { w.clearFlags(keepScreenOnFlag); } } private void setScreenOnFlag() { Window w = getWindow(); final int keepScreenOnFlag = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; if ((w.getAttributes().flags & keepScreenOnFlag) == 0) { w.addFlags(keepScreenOnFlag); } } private void hideAlertAndStartPreview() { hideAlert(); initializeVideo(); } private void hideAlertAndStartVideoRecording() { hideAlert(); startVideoRecording(); } private void acquireVideoThumb() { Bitmap videoFrame = ImageManager.createVideoThumbnail(mCurrentVideoFilename); mThumbController.setData(mCurrentVideoUri, videoFrame); } private void showLastPictureButton() { if (!mIsVideoCaptureIntent) { mLastPictureButton.setVisibility(View.VISIBLE); } } private void hideLastPictureButton() { if (!mIsVideoCaptureIntent) { mLastPictureButton.setVisibility(View.INVISIBLE); } } private static ImageManager.DataLocation dataLocation() { return ImageManager.DataLocation.EXTERNAL; } private void updateLastVideo() { ImageManager.IImageList list = ImageManager.instance().allImages( this, mContentResolver, dataLocation(), ImageManager.INCLUDE_VIDEOS, ImageManager.SORT_ASCENDING, ImageManager.CAMERA_IMAGE_BUCKET_ID); int count = list.getCount(); if (count > 0) { ImageManager.IImage image = list.getImageAt(count-1); Uri uri = image.fullSizeImageUri(); mThumbController.setData(uri, image.miniThumbBitmap()); } else { mThumbController.setData(null, null); } list.deactivate(); } private static final String[] DATA_PATH_PROJECTION = new String[] { "_data" }; private String getDataPath(Uri uri) { Cursor c = null; try { c = mContentResolver.query(uri, DATA_PATH_PROJECTION, null, null, null); if (c != null && c.moveToFirst()) { return c.getString(0); } else { return null; } } finally { if (c != null) c.close(); } } }