| /* |
| * Copyright (C) 2010 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.videoeditor; |
| |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.Locale; |
| import java.util.NoSuchElementException; |
| import java.util.Queue; |
| import java.util.concurrent.LinkedBlockingQueue; |
| import java.text.SimpleDateFormat; |
| |
| import android.app.ActionBar; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.ProgressDialog; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.graphics.Color; |
| import android.graphics.Rect; |
| import android.graphics.Bitmap.Config; |
| import android.media.videoeditor.MediaItem; |
| import android.media.videoeditor.MediaProperties; |
| import android.media.videoeditor.VideoEditor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.PowerManager; |
| import android.provider.MediaStore; |
| import android.text.InputType; |
| import android.util.DisplayMetrics; |
| import android.util.Log; |
| import android.view.Display; |
| import android.view.GestureDetector; |
| import android.view.Menu; |
| import android.view.MenuInflater; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.ScaleGestureDetector; |
| import android.view.SurfaceHolder; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.WindowManager; |
| import android.widget.FrameLayout; |
| import android.widget.ImageButton; |
| import android.widget.ImageView; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.videoeditor.service.ApiService; |
| import com.android.videoeditor.service.MovieMediaItem; |
| import com.android.videoeditor.service.VideoEditorProject; |
| import com.android.videoeditor.util.FileUtils; |
| import com.android.videoeditor.util.MediaItemUtils; |
| import com.android.videoeditor.util.StringUtils; |
| import com.android.videoeditor.widgets.AudioTrackLinearLayout; |
| import com.android.videoeditor.widgets.MediaLinearLayout; |
| import com.android.videoeditor.widgets.MediaLinearLayoutListener; |
| import com.android.videoeditor.widgets.OverlayLinearLayout; |
| import com.android.videoeditor.widgets.PlayheadView; |
| import com.android.videoeditor.widgets.PreviewSurfaceView; |
| import com.android.videoeditor.widgets.ScrollViewListener; |
| import com.android.videoeditor.widgets.TimelineHorizontalScrollView; |
| import com.android.videoeditor.widgets.TimelineRelativeLayout; |
| import com.android.videoeditor.widgets.ZoomControl; |
| |
| /** |
| * Main activity of the video editor. It handles video editing of |
| * a project. |
| */ |
| public class VideoEditorActivity extends VideoEditorBaseActivity |
| implements SurfaceHolder.Callback { |
| private static final String TAG = "VideoEditorActivity"; |
| |
| // State keys |
| private static final String STATE_INSERT_AFTER_MEDIA_ITEM_ID = "insert_after_media_item_id"; |
| private static final String STATE_PLAYING = "playing"; |
| private static final String STATE_CAPTURE_URI = "capture_uri"; |
| private static final String STATE_SELECTED_POS_ID = "selected_pos_id"; |
| |
| private static final String DCIM = |
| Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).toString(); |
| private static final String DIRECTORY = DCIM + "/Camera"; |
| |
| // Dialog ids |
| private static final int DIALOG_DELETE_PROJECT_ID = 1; |
| private static final int DIALOG_EDIT_PROJECT_NAME_ID = 2; |
| private static final int DIALOG_CHOOSE_ASPECT_RATIO_ID = 3; |
| private static final int DIALOG_EXPORT_OPTIONS_ID = 4; |
| |
| public static final int DIALOG_REMOVE_MEDIA_ITEM_ID = 10; |
| public static final int DIALOG_REMOVE_TRANSITION_ID = 11; |
| public static final int DIALOG_CHANGE_RENDERING_MODE_ID = 12; |
| public static final int DIALOG_REMOVE_OVERLAY_ID = 13; |
| public static final int DIALOG_REMOVE_EFFECT_ID = 14; |
| public static final int DIALOG_REMOVE_AUDIO_TRACK_ID = 15; |
| |
| // Dialog parameters |
| private static final String PARAM_ASPECT_RATIOS_LIST = "aspect_ratios"; |
| private static final String PARAM_CURRENT_ASPECT_RATIO_INDEX = "current_aspect_ratio"; |
| |
| // Request codes |
| private static final int REQUEST_CODE_IMPORT_VIDEO = 1; |
| private static final int REQUEST_CODE_IMPORT_IMAGE = 2; |
| private static final int REQUEST_CODE_IMPORT_MUSIC = 3; |
| private static final int REQUEST_CODE_CAPTURE_VIDEO = 4; |
| private static final int REQUEST_CODE_CAPTURE_IMAGE = 5; |
| |
| public static final int REQUEST_CODE_EDIT_TRANSITION = 10; |
| public static final int REQUEST_CODE_PICK_TRANSITION = 11; |
| public static final int REQUEST_CODE_PICK_OVERLAY = 12; |
| public static final int REQUEST_CODE_KEN_BURNS = 13; |
| |
| // The maximum zoom level |
| private static final int MAX_ZOOM_LEVEL = 120; |
| private static final int ZOOM_STEP = 2; |
| |
| // Threshold in width dip for showing title in action bar. |
| private static final int SHOW_TITLE_THRESHOLD_WIDTH_DIP = 1000; |
| |
| private final TimelineRelativeLayout.LayoutCallback mLayoutCallback = |
| new TimelineRelativeLayout.LayoutCallback() { |
| |
| @Override |
| public void onLayoutComplete() { |
| // Scroll the timeline such that the specified position |
| // is in the center of the screen. |
| movePlayhead(mProject.getPlayheadPos(), false); |
| } |
| }; |
| |
| // Instance variables |
| private PreviewSurfaceView mSurfaceView; |
| private SurfaceHolder mSurfaceHolder; |
| private boolean mHaveSurface; |
| |
| // The width and height of the preview surface. They are defined only if |
| // mHaveSurface is true. If the values are still unknown (before |
| // surfaceChanged() is called), mSurfaceWidth is set to -1. |
| private int mSurfaceWidth, mSurfaceHeight; |
| |
| private boolean mResumed; |
| private ImageView mOverlayView; |
| private PreviewThread mPreviewThread; |
| private View mEditorProjectView; |
| private View mEditorEmptyView; |
| private TimelineHorizontalScrollView mTimelineScroller; |
| private TimelineRelativeLayout mTimelineLayout; |
| private OverlayLinearLayout mOverlayLayout; |
| private AudioTrackLinearLayout mAudioTrackLayout; |
| private MediaLinearLayout mMediaLayout; |
| private int mMediaLayoutSelectedPos; |
| private PlayheadView mPlayheadView; |
| private TextView mTimeView; |
| private ImageButton mPreviewPlayButton; |
| private ImageButton mPreviewRewindButton, mPreviewNextButton, mPreviewPrevButton; |
| private int mActivityWidth; |
| private String mInsertMediaItemAfterMediaItemId; |
| private long mCurrentPlayheadPosMs; |
| private ProgressDialog mExportProgressDialog; |
| private ZoomControl mZoomControl; |
| private PowerManager.WakeLock mCpuWakeLock; |
| |
| // Variables used in onActivityResult |
| private Uri mAddMediaItemVideoUri; |
| private Uri mAddMediaItemImageUri; |
| private Uri mAddAudioTrackUri; |
| private String mAddTransitionAfterMediaId; |
| private int mAddTransitionType; |
| private long mAddTransitionDurationMs; |
| private String mEditTransitionAfterMediaId, mEditTransitionId; |
| private int mEditTransitionType; |
| private long mEditTransitionDurationMs; |
| private String mAddOverlayMediaItemId; |
| private Bundle mAddOverlayUserAttributes; |
| private String mEditOverlayMediaItemId; |
| private String mEditOverlayId; |
| private Bundle mEditOverlayUserAttributes; |
| private String mAddEffectMediaItemId; |
| private int mAddEffectType; |
| private Rect mAddKenBurnsStartRect; |
| private Rect mAddKenBurnsEndRect; |
| private boolean mRestartPreview; |
| private Uri mCaptureMediaUri; |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| |
| final ActionBar actionBar = getActionBar(); |
| DisplayMetrics displayMetrics = new DisplayMetrics(); |
| getWindowManager().getDefaultDisplay().getMetrics(displayMetrics); |
| // Only show title on large screens (width >= 1000 dip). |
| int widthDip = (int) (displayMetrics.widthPixels / displayMetrics.scaledDensity); |
| if (widthDip >= SHOW_TITLE_THRESHOLD_WIDTH_DIP) { |
| actionBar.setDisplayOptions(actionBar.getDisplayOptions() | ActionBar.DISPLAY_SHOW_TITLE); |
| actionBar.setTitle(R.string.full_app_name); |
| } |
| |
| // Prepare the surface holder |
| mSurfaceView = (PreviewSurfaceView) findViewById(R.id.video_view); |
| mSurfaceHolder = mSurfaceView.getHolder(); |
| mSurfaceHolder.addCallback(this); |
| mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); |
| |
| mOverlayView = (ImageView)findViewById(R.id.overlay_layer); |
| |
| mEditorProjectView = findViewById(R.id.editor_project_view); |
| mEditorEmptyView = findViewById(R.id.empty_project_view); |
| |
| mTimelineScroller = (TimelineHorizontalScrollView)findViewById(R.id.timeline_scroller); |
| mTimelineLayout = (TimelineRelativeLayout)findViewById(R.id.timeline); |
| mMediaLayout = (MediaLinearLayout)findViewById(R.id.timeline_media); |
| mOverlayLayout = (OverlayLinearLayout)findViewById(R.id.timeline_overlays); |
| mAudioTrackLayout = (AudioTrackLinearLayout)findViewById(R.id.timeline_audio_tracks); |
| mPlayheadView = (PlayheadView)findViewById(R.id.timeline_playhead); |
| |
| mPreviewPlayButton = (ImageButton)findViewById(R.id.editor_play); |
| mPreviewRewindButton = (ImageButton)findViewById(R.id.editor_rewind); |
| mPreviewNextButton = (ImageButton)findViewById(R.id.editor_next); |
| mPreviewPrevButton = (ImageButton)findViewById(R.id.editor_prev); |
| |
| mTimeView = (TextView)findViewById(R.id.editor_time); |
| |
| actionBar.setDisplayHomeAsUpEnabled(true); |
| |
| mMediaLayout.setListener(new MediaLinearLayoutListener() { |
| @Override |
| public void onRequestScrollBy(int scrollBy, boolean smooth) { |
| mTimelineScroller.appScrollBy(scrollBy, smooth); |
| } |
| |
| @Override |
| public void onRequestMovePlayhead(long scrollToTime, boolean smooth) { |
| movePlayhead(scrollToTime); |
| } |
| |
| @Override |
| public void onAddMediaItem(String afterMediaItemId) { |
| mInsertMediaItemAfterMediaItemId = afterMediaItemId; |
| final Intent intent = new Intent(Intent.ACTION_PICK); |
| intent.setData(MediaStore.Video.Media.EXTERNAL_CONTENT_URI); |
| startActivityForResult(intent, REQUEST_CODE_IMPORT_VIDEO); |
| } |
| |
| @Override |
| public void onTrimMediaItemBegin(MovieMediaItem mediaItem) { |
| onProjectEditStateChange(true); |
| } |
| |
| @Override |
| public void onTrimMediaItem(MovieMediaItem mediaItem, long timeMs) { |
| updateTimelineDuration(); |
| if (mProject != null && isPreviewPlaying()) { |
| if (mediaItem.isVideoClip()) { |
| if (timeMs >= 0) { |
| mPreviewThread.renderMediaItemFrame(mediaItem, timeMs); |
| } |
| } else { |
| mPreviewThread.previewFrame(mProject, |
| mProject.getMediaItemBeginTime(mediaItem.getId()) + timeMs, |
| mProject.getMediaItemCount() == 0); |
| } |
| } |
| } |
| |
| @Override |
| public void onTrimMediaItemEnd(MovieMediaItem mediaItem, long timeMs) { |
| onProjectEditStateChange(false); |
| // We need to repaint the timeline layout to clear the old |
| // playhead position (the one drawn during trimming). |
| mTimelineLayout.invalidate(); |
| showPreviewFrame(); |
| } |
| }); |
| |
| mAudioTrackLayout.setListener(new AudioTrackLinearLayout.AudioTracksLayoutListener() { |
| @Override |
| public void onAddAudioTrack() { |
| final Intent intent = new Intent(Intent.ACTION_PICK); |
| intent.setData(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI); |
| startActivityForResult(intent, REQUEST_CODE_IMPORT_MUSIC); |
| } |
| }); |
| |
| mTimelineScroller.addScrollListener(new ScrollViewListener() { |
| // Instance variables |
| private int mActiveWidth; |
| private long mDurationMs; |
| |
| @Override |
| public void onScrollBegin(View view, int scrollX, int scrollY, boolean appScroll) { |
| if (!appScroll && mProject != null) { |
| mActiveWidth = mMediaLayout.getWidth() - mActivityWidth; |
| mDurationMs = mProject.computeDuration(); |
| } else { |
| mActiveWidth = 0; |
| } |
| } |
| |
| @Override |
| public void onScrollProgress(View view, int scrollX, int scrollY, boolean appScroll) { |
| } |
| |
| @Override |
| public void onScrollEnd(View view, int scrollX, int scrollY, boolean appScroll) { |
| // We check if the project is valid since the project may |
| // close while scrolling |
| if (!appScroll && mActiveWidth > 0 && mProject != null) { |
| final long timeMs = (scrollX * mDurationMs) / mActiveWidth; |
| if (setPlayhead(timeMs < 0 ? 0 : timeMs)) { |
| showPreviewFrame(); |
| } |
| } |
| } |
| }); |
| |
| mTimelineScroller.setScaleListener(new ScaleGestureDetector.SimpleOnScaleGestureListener() { |
| // Guard against this many scale events in the opposite direction |
| private static final int SCALE_TOLERANCE = 3; |
| |
| private int mLastScaleFactorSign; |
| private float mLastScaleFactor; |
| |
| @Override |
| public boolean onScaleBegin(ScaleGestureDetector detector) { |
| mLastScaleFactorSign = 0; |
| return true; |
| } |
| |
| @Override |
| public boolean onScale(ScaleGestureDetector detector) { |
| if (mProject == null) { |
| return false; |
| } |
| |
| final float scaleFactor = detector.getScaleFactor(); |
| final float deltaScaleFactor = scaleFactor - mLastScaleFactor; |
| if (deltaScaleFactor > 0.01f || deltaScaleFactor < -0.01f) { |
| if (scaleFactor < 1.0f) { |
| if (mLastScaleFactorSign <= 0) { |
| zoomTimeline(mProject.getZoomLevel() - ZOOM_STEP, true); |
| } |
| |
| if (mLastScaleFactorSign > -SCALE_TOLERANCE) { |
| mLastScaleFactorSign--; |
| } |
| } else if (scaleFactor > 1.0f) { |
| if (mLastScaleFactorSign >= 0) { |
| zoomTimeline(mProject.getZoomLevel() + ZOOM_STEP, true); |
| } |
| |
| if (mLastScaleFactorSign < SCALE_TOLERANCE) { |
| mLastScaleFactorSign++; |
| } |
| } |
| } |
| |
| mLastScaleFactor = scaleFactor; |
| return true; |
| } |
| |
| @Override |
| public void onScaleEnd(ScaleGestureDetector detector) { |
| } |
| }); |
| |
| if (savedInstanceState != null) { |
| mInsertMediaItemAfterMediaItemId = savedInstanceState.getString( |
| STATE_INSERT_AFTER_MEDIA_ITEM_ID); |
| mRestartPreview = savedInstanceState.getBoolean(STATE_PLAYING); |
| mCaptureMediaUri = savedInstanceState.getParcelable(STATE_CAPTURE_URI); |
| mMediaLayoutSelectedPos = savedInstanceState.getInt(STATE_SELECTED_POS_ID, -1); |
| } else { |
| mRestartPreview = false; |
| mMediaLayoutSelectedPos = -1; |
| } |
| |
| // Compute the activity width |
| final Display display = getWindowManager().getDefaultDisplay(); |
| mActivityWidth = display.getWidth(); |
| |
| mSurfaceView.setGestureListener(new GestureDetector(this, |
| new GestureDetector.SimpleOnGestureListener() { |
| @Override |
| public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, |
| float velocityY) { |
| if (isPreviewPlaying()) { |
| return false; |
| } |
| |
| mTimelineScroller.fling(-(int)velocityX); |
| return true; |
| } |
| |
| @Override |
| public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, |
| float distanceY) { |
| if (isPreviewPlaying()) { |
| return false; |
| } |
| |
| mTimelineScroller.scrollBy((int)distanceX, 0); |
| return true; |
| } |
| })); |
| |
| mZoomControl = ((ZoomControl)findViewById(R.id.editor_zoom)); |
| mZoomControl.setMax(MAX_ZOOM_LEVEL); |
| mZoomControl.setOnZoomChangeListener(new ZoomControl.OnZoomChangeListener() { |
| |
| @Override |
| public void onProgressChanged(int progress, boolean fromUser) { |
| if (mProject != null) { |
| zoomTimeline(progress, false); |
| } |
| } |
| }); |
| |
| PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); |
| mCpuWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Video Editor Activity CPU Wake Lock"); |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| mResumed = false; |
| |
| // Stop the preview now (we will stop it in surfaceDestroyed(), but |
| // that may be too late for releasing resources to other activities) |
| stopPreviewThread(); |
| |
| // Dismiss the export progress dialog. If the export will still be pending |
| // when we return to this activity, we will display this dialog again. |
| if (mExportProgressDialog != null) { |
| mExportProgressDialog.dismiss(); |
| mExportProgressDialog = null; |
| } |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| mResumed = true; |
| |
| if (mProject != null) { |
| mMediaLayout.onResume(); |
| mAudioTrackLayout.onResume(); |
| } |
| |
| createPreviewThreadIfNeeded(); |
| } |
| |
| private void createPreviewThreadIfNeeded() { |
| // We want to have the preview thread if and only if (1) we have a |
| // surface, and (2) we are resumed. |
| if (mHaveSurface && mResumed && mPreviewThread == null) { |
| mPreviewThread = new PreviewThread(mSurfaceHolder); |
| if (mSurfaceWidth != -1) { |
| mPreviewThread.onSurfaceChanged(mSurfaceWidth, mSurfaceHeight); |
| } |
| restartPreview(); |
| } |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| |
| outState.putString(STATE_INSERT_AFTER_MEDIA_ITEM_ID, mInsertMediaItemAfterMediaItemId); |
| outState.putBoolean(STATE_PLAYING, isPreviewPlaying() || mRestartPreview); |
| outState.putParcelable(STATE_CAPTURE_URI, mCaptureMediaUri); |
| outState.putInt(STATE_SELECTED_POS_ID, mMediaLayout.getSelectedViewPos()); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| MenuInflater inflater = getMenuInflater(); |
| inflater.inflate(R.menu.action_bar_menu, menu); |
| return true; |
| } |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| final boolean haveProject = (mProject != null); |
| final boolean haveMediaItems = haveProject && mProject.getMediaItemCount() > 0; |
| menu.findItem(R.id.menu_item_capture_video).setVisible(haveProject); |
| menu.findItem(R.id.menu_item_capture_image).setVisible(haveProject); |
| menu.findItem(R.id.menu_item_import_video).setVisible(haveProject); |
| menu.findItem(R.id.menu_item_import_image).setVisible(haveProject); |
| menu.findItem(R.id.menu_item_import_audio).setVisible(haveProject && |
| mProject.getAudioTracks().size() == 0 && haveMediaItems); |
| menu.findItem(R.id.menu_item_change_aspect_ratio).setVisible(haveProject && |
| mProject.hasMultipleAspectRatios()); |
| menu.findItem(R.id.menu_item_edit_project_name).setVisible(haveProject); |
| |
| // Check if there is an operation pending or preview is on. |
| boolean enableMenu = haveProject; |
| if (enableMenu && mPreviewThread != null) { |
| // Preview is in progress |
| enableMenu = mPreviewThread.isStopped(); |
| if (enableMenu && mProjectPath != null) { |
| enableMenu = !ApiService.isProjectBeingEdited(mProjectPath); |
| } |
| } |
| |
| menu.findItem(R.id.menu_item_export_movie).setVisible(enableMenu && haveMediaItems); |
| menu.findItem(R.id.menu_item_delete_project).setVisible(enableMenu); |
| menu.findItem(R.id.menu_item_play_exported_movie).setVisible(enableMenu && |
| mProject.getExportedMovieUri() != null); |
| menu.findItem(R.id.menu_item_share_movie).setVisible(enableMenu && |
| mProject.getExportedMovieUri() != null); |
| return true; |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| switch (item.getItemId()) { |
| case android.R.id.home: { |
| // Returns to project picker if user clicks on the app icon in the action bar. |
| final Intent intent = new Intent(this, ProjectsActivity.class); |
| intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); |
| startActivity(intent); |
| finish(); |
| return true; |
| } |
| |
| case R.id.menu_item_capture_video: { |
| mInsertMediaItemAfterMediaItemId = mProject.getLastMediaItemId(); |
| |
| // Create parameters for Intent with filename |
| final ContentValues values = new ContentValues(); |
| String videoFilename = DIRECTORY + '/' + getVideoOutputMediaFileTitle() + ".mp4"; |
| values.put(MediaStore.Video.Media.DATA, videoFilename); |
| mCaptureMediaUri = getContentResolver().insert( |
| MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values); |
| final Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE); |
| intent.putExtra(MediaStore.EXTRA_OUTPUT, mCaptureMediaUri); |
| startActivityForResult(intent, REQUEST_CODE_CAPTURE_VIDEO); |
| return true; |
| } |
| |
| case R.id.menu_item_capture_image: { |
| mInsertMediaItemAfterMediaItemId = mProject.getLastMediaItemId(); |
| |
| // Create parameters for Intent with filename |
| final ContentValues values = new ContentValues(); |
| mCaptureMediaUri = getContentResolver().insert( |
| MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values); |
| final Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); |
| intent.putExtra(MediaStore.EXTRA_OUTPUT, mCaptureMediaUri); |
| startActivityForResult(intent, REQUEST_CODE_CAPTURE_IMAGE); |
| return true; |
| } |
| |
| case R.id.menu_item_import_video: { |
| mInsertMediaItemAfterMediaItemId = mProject.getLastMediaItemId(); |
| final Intent intent = new Intent(Intent.ACTION_PICK); |
| intent.setData(MediaStore.Video.Media.EXTERNAL_CONTENT_URI); |
| startActivityForResult(intent, REQUEST_CODE_IMPORT_VIDEO); |
| return true; |
| } |
| |
| case R.id.menu_item_import_image: { |
| mInsertMediaItemAfterMediaItemId = mProject.getLastMediaItemId(); |
| final Intent intent = new Intent(Intent.ACTION_PICK); |
| intent.setData(MediaStore.Images.Media.EXTERNAL_CONTENT_URI); |
| startActivityForResult(intent, REQUEST_CODE_IMPORT_IMAGE); |
| return true; |
| } |
| |
| case R.id.menu_item_import_audio: { |
| final Intent intent = new Intent(Intent.ACTION_PICK); |
| intent.setData(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI); |
| startActivityForResult(intent, REQUEST_CODE_IMPORT_MUSIC); |
| return true; |
| } |
| |
| case R.id.menu_item_change_aspect_ratio: { |
| final ArrayList<Integer> aspectRatiosList = mProject.getUniqueAspectRatiosList(); |
| final int size = aspectRatiosList.size(); |
| if (size > 1) { |
| final Bundle bundle = new Bundle(); |
| bundle.putIntegerArrayList(PARAM_ASPECT_RATIOS_LIST, aspectRatiosList); |
| |
| // Get the current aspect ratio index |
| final int currentAspectRatio = mProject.getAspectRatio(); |
| int currentAspectRatioIndex = 0; |
| for (int i = 0; i < size; i++) { |
| final int aspectRatio = aspectRatiosList.get(i); |
| if (aspectRatio == currentAspectRatio) { |
| currentAspectRatioIndex = i; |
| break; |
| } |
| } |
| bundle.putInt(PARAM_CURRENT_ASPECT_RATIO_INDEX, currentAspectRatioIndex); |
| showDialog(DIALOG_CHOOSE_ASPECT_RATIO_ID, bundle); |
| } |
| return true; |
| } |
| |
| case R.id.menu_item_edit_project_name: { |
| showDialog(DIALOG_EDIT_PROJECT_NAME_ID); |
| return true; |
| } |
| |
| case R.id.menu_item_delete_project: { |
| // Confirm project delete |
| showDialog(DIALOG_DELETE_PROJECT_ID); |
| return true; |
| } |
| |
| case R.id.menu_item_export_movie: { |
| // Present the user with a dialog to choose export options |
| showDialog(DIALOG_EXPORT_OPTIONS_ID); |
| return true; |
| } |
| |
| case R.id.menu_item_play_exported_movie: { |
| final Intent intent = new Intent(Intent.ACTION_VIEW); |
| intent.setDataAndType(mProject.getExportedMovieUri(), "video/*"); |
| intent.putExtra(MediaStore.EXTRA_FINISH_ON_COMPLETION, false); |
| startActivity(intent); |
| return true; |
| } |
| |
| case R.id.menu_item_share_movie: { |
| final Intent intent = new Intent(Intent.ACTION_SEND); |
| intent.putExtra(Intent.EXTRA_STREAM, mProject.getExportedMovieUri()); |
| intent.setType("video/*"); |
| startActivity(intent); |
| return true; |
| } |
| |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| private String getVideoOutputMediaFileTitle() { |
| long dateTaken = System.currentTimeMillis(); |
| Date date = new Date(dateTaken); |
| SimpleDateFormat dateFormat = new SimpleDateFormat("'VID'_yyyyMMdd_HHmmss", Locale.US); |
| |
| return dateFormat.format(date); |
| } |
| |
| @Override |
| public Dialog onCreateDialog(int id, final Bundle bundle) { |
| switch (id) { |
| case DIALOG_CHOOSE_ASPECT_RATIO_ID: { |
| final AlertDialog.Builder builder = new AlertDialog.Builder(this); |
| builder.setTitle(getString(R.string.editor_change_aspect_ratio)); |
| final ArrayList<Integer> aspectRatios = |
| bundle.getIntegerArrayList(PARAM_ASPECT_RATIOS_LIST); |
| final int count = aspectRatios.size(); |
| final CharSequence[] aspectRatioStrings = new CharSequence[count]; |
| for (int i = 0; i < count; i++) { |
| int aspectRatio = aspectRatios.get(i); |
| switch (aspectRatio) { |
| case MediaProperties.ASPECT_RATIO_11_9: { |
| aspectRatioStrings[i] = getString(R.string.aspect_ratio_11_9); |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_16_9: { |
| aspectRatioStrings[i] = getString(R.string.aspect_ratio_16_9); |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_3_2: { |
| aspectRatioStrings[i] = getString(R.string.aspect_ratio_3_2); |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_4_3: { |
| aspectRatioStrings[i] = getString(R.string.aspect_ratio_4_3); |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_5_3: { |
| aspectRatioStrings[i] = getString(R.string.aspect_ratio_5_3); |
| break; |
| } |
| |
| default: { |
| break; |
| } |
| } |
| } |
| |
| builder.setSingleChoiceItems(aspectRatioStrings, |
| bundle.getInt(PARAM_CURRENT_ASPECT_RATIO_INDEX), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| final int aspectRatio = aspectRatios.get(which); |
| ApiService.setAspectRatio(VideoEditorActivity.this, mProjectPath, |
| aspectRatio); |
| |
| removeDialog(DIALOG_CHOOSE_ASPECT_RATIO_ID); |
| } |
| }); |
| builder.setCancelable(true); |
| builder.setOnCancelListener(new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| removeDialog(DIALOG_CHOOSE_ASPECT_RATIO_ID); |
| } |
| }); |
| return builder.create(); |
| } |
| |
| case DIALOG_DELETE_PROJECT_ID: { |
| return AlertDialogs.createAlert(this, getString(R.string.editor_delete_project), 0, |
| getString(R.string.editor_delete_project_question), |
| getString(R.string.yes), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| ApiService.deleteProject(VideoEditorActivity.this, mProjectPath); |
| mProjectPath = null; |
| mProject = null; |
| enterDisabledState(R.string.editor_no_project); |
| |
| removeDialog(DIALOG_DELETE_PROJECT_ID); |
| finish(); |
| } |
| }, getString(R.string.no), new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| removeDialog(DIALOG_DELETE_PROJECT_ID); |
| } |
| }, new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| removeDialog(DIALOG_DELETE_PROJECT_ID); |
| } |
| }, true); |
| } |
| |
| case DIALOG_DELETE_BAD_PROJECT_ID: { |
| return AlertDialogs.createAlert(this, getString(R.string.editor_delete_project), 0, |
| getString(R.string.editor_load_error), |
| getString(R.string.yes), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| ApiService.deleteProject(VideoEditorActivity.this, |
| bundle.getString(PARAM_PROJECT_PATH)); |
| |
| removeDialog(DIALOG_DELETE_BAD_PROJECT_ID); |
| finish(); |
| } |
| }, getString(R.string.no), new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| removeDialog(DIALOG_DELETE_BAD_PROJECT_ID); |
| } |
| }, new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| removeDialog(DIALOG_DELETE_BAD_PROJECT_ID); |
| } |
| }, true); |
| } |
| |
| case DIALOG_EDIT_PROJECT_NAME_ID: { |
| if (mProject == null) { |
| return null; |
| } |
| |
| return AlertDialogs.createEditDialog(this, |
| getString(R.string.editor_edit_project_name), |
| mProject.getName(), |
| getString(android.R.string.ok), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| final TextView tv = |
| (TextView)((AlertDialog)dialog).findViewById(R.id.text_1); |
| mProject.setProjectName(tv.getText().toString()); |
| getActionBar().setTitle(tv.getText()); |
| removeDialog(DIALOG_EDIT_PROJECT_NAME_ID); |
| } |
| }, |
| getString(android.R.string.cancel), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| removeDialog(DIALOG_EDIT_PROJECT_NAME_ID); |
| } |
| }, |
| new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| removeDialog(DIALOG_EDIT_PROJECT_NAME_ID); |
| } |
| }, |
| InputType.TYPE_NULL, |
| 32, |
| null); |
| } |
| |
| case DIALOG_EXPORT_OPTIONS_ID: { |
| if (mProject == null) { |
| return null; |
| } |
| |
| return ExportOptionsDialog.create(this, |
| new ExportOptionsDialog.ExportOptionsListener() { |
| @Override |
| public void onExportOptions(int movieHeight, int movieBitrate) { |
| mPendingExportFilename = FileUtils.createMovieName( |
| MediaProperties.FILE_MP4); |
| ApiService.exportVideoEditor(VideoEditorActivity.this, mProjectPath, |
| mPendingExportFilename, movieHeight, movieBitrate); |
| |
| removeDialog(DIALOG_EXPORT_OPTIONS_ID); |
| |
| showExportProgress(); |
| } |
| }, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| removeDialog(DIALOG_EXPORT_OPTIONS_ID); |
| } |
| }, new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| removeDialog(DIALOG_EXPORT_OPTIONS_ID); |
| } |
| }, mProject.getAspectRatio()); |
| } |
| |
| case DIALOG_REMOVE_MEDIA_ITEM_ID: { |
| return mMediaLayout.onCreateDialog(id, bundle); |
| } |
| |
| case DIALOG_CHANGE_RENDERING_MODE_ID: { |
| return mMediaLayout.onCreateDialog(id, bundle); |
| } |
| |
| case DIALOG_REMOVE_TRANSITION_ID: { |
| return mMediaLayout.onCreateDialog(id, bundle); |
| } |
| |
| case DIALOG_REMOVE_OVERLAY_ID: { |
| return mOverlayLayout.onCreateDialog(id, bundle); |
| } |
| |
| case DIALOG_REMOVE_EFFECT_ID: { |
| return mMediaLayout.onCreateDialog(id, bundle); |
| } |
| |
| case DIALOG_REMOVE_AUDIO_TRACK_ID: { |
| return mAudioTrackLayout.onCreateDialog(id, bundle); |
| } |
| |
| default: { |
| return null; |
| } |
| } |
| } |
| |
| |
| /** |
| * Called when user clicks on the button in the control panel. |
| * @param target one of the "play", "rewind", "next", |
| * and "prev" buttons in the control panel |
| */ |
| public void onClickHandler(View target) { |
| final long playheadPosMs = mProject.getPlayheadPos(); |
| |
| switch (target.getId()) { |
| case R.id.editor_play: { |
| if (mProject != null && mPreviewThread != null) { |
| if (mPreviewThread.isPlaying()) { |
| mPreviewThread.stopPreviewPlayback(); |
| } else if (mProject.getMediaItemCount() > 0) { |
| mPreviewThread.startPreviewPlayback(mProject, playheadPosMs); |
| } |
| } |
| break; |
| } |
| |
| case R.id.editor_rewind: { |
| if (mProject != null && mPreviewThread != null) { |
| if (mPreviewThread.isPlaying()) { |
| mPreviewThread.stopPreviewPlayback(); |
| movePlayhead(0); |
| mPreviewThread.startPreviewPlayback(mProject, 0); |
| } else { |
| movePlayhead(0); |
| showPreviewFrame(); |
| } |
| } |
| break; |
| } |
| |
| case R.id.editor_next: { |
| if (mProject != null && mPreviewThread != null) { |
| final boolean restartPreview; |
| if (mPreviewThread.isPlaying()) { |
| mPreviewThread.stopPreviewPlayback(); |
| restartPreview = true; |
| } else { |
| restartPreview = false; |
| } |
| |
| final MovieMediaItem mediaItem = mProject.getNextMediaItem(playheadPosMs); |
| if (mediaItem != null) { |
| movePlayhead(mProject.getMediaItemBeginTime(mediaItem.getId())); |
| if (restartPreview) { |
| mPreviewThread.startPreviewPlayback(mProject, |
| mProject.getPlayheadPos()); |
| } else { |
| showPreviewFrame(); |
| } |
| } else { // Move to the end of the timeline |
| movePlayhead(mProject.computeDuration()); |
| showPreviewFrame(); |
| } |
| } |
| break; |
| } |
| |
| case R.id.editor_prev: { |
| if (mProject != null && mPreviewThread != null) { |
| final boolean restartPreview; |
| if (mPreviewThread.isPlaying()) { |
| mPreviewThread.stopPreviewPlayback(); |
| restartPreview = true; |
| } else { |
| restartPreview = false; |
| } |
| |
| final MovieMediaItem mediaItem = mProject.getPreviousMediaItem(playheadPosMs); |
| if (mediaItem != null) { |
| movePlayhead(mProject.getMediaItemBeginTime(mediaItem.getId())); |
| } else { // Move to the beginning of the timeline |
| movePlayhead(0); |
| } |
| |
| if (restartPreview) { |
| mPreviewThread.startPreviewPlayback(mProject, mProject.getPlayheadPos()); |
| } else { |
| showPreviewFrame(); |
| } |
| } |
| break; |
| } |
| |
| default: { |
| break; |
| } |
| } |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent extras) { |
| super.onActivityResult(requestCode, resultCode, extras); |
| if (resultCode == RESULT_CANCELED) { |
| switch (requestCode) { |
| case REQUEST_CODE_CAPTURE_VIDEO: |
| case REQUEST_CODE_CAPTURE_IMAGE: { |
| if (mCaptureMediaUri != null) { |
| getContentResolver().delete(mCaptureMediaUri, null, null); |
| mCaptureMediaUri = null; |
| } |
| break; |
| } |
| |
| default: { |
| break; |
| } |
| } |
| return; |
| } |
| |
| switch (requestCode) { |
| case REQUEST_CODE_CAPTURE_VIDEO: { |
| if (mProject != null) { |
| ApiService.addMediaItemVideoUri(this, mProjectPath, |
| ApiService.generateId(), mInsertMediaItemAfterMediaItemId, |
| mCaptureMediaUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| mProject.getTheme()); |
| mInsertMediaItemAfterMediaItemId = null; |
| } else { |
| // Add this video after the project loads |
| mAddMediaItemVideoUri = mCaptureMediaUri; |
| } |
| mCaptureMediaUri = null; |
| break; |
| } |
| |
| case REQUEST_CODE_CAPTURE_IMAGE: { |
| if (mProject != null) { |
| ApiService.addMediaItemImageUri(this, mProjectPath, |
| ApiService.generateId(), mInsertMediaItemAfterMediaItemId, |
| mCaptureMediaUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| MediaItemUtils.getDefaultImageDuration(), |
| mProject.getTheme()); |
| mInsertMediaItemAfterMediaItemId = null; |
| } else { |
| // Add this image after the project loads |
| mAddMediaItemImageUri = mCaptureMediaUri; |
| } |
| mCaptureMediaUri = null; |
| break; |
| } |
| |
| case REQUEST_CODE_IMPORT_VIDEO: { |
| final Uri mediaUri = extras.getData(); |
| if (mProject != null) { |
| if ("media".equals(mediaUri.getAuthority())) { |
| ApiService.addMediaItemVideoUri(this, mProjectPath, |
| ApiService.generateId(), mInsertMediaItemAfterMediaItemId, |
| mediaUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| mProject.getTheme()); |
| } else { |
| // Notify the user that this item needs to be downloaded. |
| Toast.makeText(this, getString(R.string.editor_video_load), |
| Toast.LENGTH_LONG).show(); |
| // When the download is complete insert it into the project. |
| ApiService.loadMediaItem(this, mProjectPath, mediaUri, "video/*"); |
| } |
| mInsertMediaItemAfterMediaItemId = null; |
| } else { |
| // Add this video after the project loads |
| mAddMediaItemVideoUri = mediaUri; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_IMPORT_IMAGE: { |
| final Uri mediaUri = extras.getData(); |
| if (mProject != null) { |
| if ("media".equals(mediaUri.getAuthority())) { |
| ApiService.addMediaItemImageUri(this, mProjectPath, |
| ApiService.generateId(), mInsertMediaItemAfterMediaItemId, |
| mediaUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| MediaItemUtils.getDefaultImageDuration(), mProject.getTheme()); |
| } else { |
| // Notify the user that this item needs to be downloaded. |
| Toast.makeText(this, getString(R.string.editor_image_load), |
| Toast.LENGTH_LONG).show(); |
| // When the download is complete insert it into the project. |
| ApiService.loadMediaItem(this, mProjectPath, mediaUri, "image/*"); |
| } |
| mInsertMediaItemAfterMediaItemId = null; |
| } else { |
| // Add this image after the project loads |
| mAddMediaItemImageUri = mediaUri; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_IMPORT_MUSIC: { |
| final Uri data = extras.getData(); |
| if (mProject != null) { |
| ApiService.addAudioTrack(this, mProjectPath, ApiService.generateId(), data, |
| true); |
| } else { |
| mAddAudioTrackUri = data; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_EDIT_TRANSITION: { |
| final int type = extras.getIntExtra(TransitionsActivity.PARAM_TRANSITION_TYPE, -1); |
| final String afterMediaId = extras.getStringExtra( |
| TransitionsActivity.PARAM_AFTER_MEDIA_ITEM_ID); |
| final String transitionId = extras.getStringExtra( |
| TransitionsActivity.PARAM_TRANSITION_ID); |
| final long transitionDurationMs = extras.getLongExtra( |
| TransitionsActivity.PARAM_TRANSITION_DURATION, 500); |
| if (mProject != null) { |
| mMediaLayout.editTransition(afterMediaId, transitionId, type, |
| transitionDurationMs); |
| } else { |
| // Add this transition after you load the project |
| mEditTransitionAfterMediaId = afterMediaId; |
| mEditTransitionId = transitionId; |
| mEditTransitionType = type; |
| mEditTransitionDurationMs = transitionDurationMs; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_PICK_TRANSITION: { |
| final int type = extras.getIntExtra(TransitionsActivity.PARAM_TRANSITION_TYPE, -1); |
| final String afterMediaId = extras.getStringExtra( |
| TransitionsActivity.PARAM_AFTER_MEDIA_ITEM_ID); |
| final long transitionDurationMs = extras.getLongExtra( |
| TransitionsActivity.PARAM_TRANSITION_DURATION, 500); |
| if (mProject != null) { |
| mMediaLayout.addTransition(afterMediaId, type, transitionDurationMs); |
| } else { |
| // Add this transition after you load the project |
| mAddTransitionAfterMediaId = afterMediaId; |
| mAddTransitionType = type; |
| mAddTransitionDurationMs = transitionDurationMs; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_PICK_OVERLAY: { |
| // If there is no overlay id, it means we are adding a new overlay. |
| // Otherwise we generate a unique new id for the new overlay. |
| final String mediaItemId = |
| extras.getStringExtra(OverlayTitleEditor.PARAM_MEDIA_ITEM_ID); |
| final String overlayId = |
| extras.getStringExtra(OverlayTitleEditor.PARAM_OVERLAY_ID); |
| final Bundle bundle = |
| extras.getBundleExtra(OverlayTitleEditor.PARAM_OVERLAY_ATTRIBUTES); |
| if (mProject != null) { |
| final MovieMediaItem mediaItem = mProject.getMediaItem(mediaItemId); |
| if (mediaItem != null) { |
| if (overlayId == null) { |
| ApiService.addOverlay(this, mProject.getPath(), mediaItemId, |
| ApiService.generateId(), bundle, |
| mediaItem.getAppBoundaryBeginTime(), |
| OverlayLinearLayout.DEFAULT_TITLE_DURATION); |
| } else { |
| ApiService.setOverlayUserAttributes(this, mProject.getPath(), |
| mediaItemId, overlayId, bundle); |
| } |
| mOverlayLayout.invalidateCAB(); |
| } |
| } else { |
| // Add this overlay after you load the project. |
| mAddOverlayMediaItemId = mediaItemId; |
| mAddOverlayUserAttributes = bundle; |
| mEditOverlayId = overlayId; |
| } |
| break; |
| } |
| |
| case REQUEST_CODE_KEN_BURNS: { |
| final String mediaItemId = extras.getStringExtra( |
| KenBurnsActivity.PARAM_MEDIA_ITEM_ID); |
| final Rect startRect = extras.getParcelableExtra( |
| KenBurnsActivity.PARAM_START_RECT); |
| final Rect endRect = extras.getParcelableExtra( |
| KenBurnsActivity.PARAM_END_RECT); |
| if (mProject != null) { |
| mMediaLayout.addEffect(EffectType.EFFECT_KEN_BURNS, mediaItemId, |
| startRect, endRect); |
| mMediaLayout.invalidateActionBar(); |
| } else { |
| // Add this effect after you load the project. |
| mAddEffectMediaItemId = mediaItemId; |
| mAddEffectType = EffectType.EFFECT_KEN_BURNS; |
| mAddKenBurnsStartRect = startRect; |
| mAddKenBurnsEndRect = endRect; |
| } |
| break; |
| } |
| |
| default: { |
| break; |
| } |
| } |
| } |
| |
| @Override |
| public void surfaceCreated(SurfaceHolder holder) { |
| logd("surfaceCreated"); |
| |
| mHaveSurface = true; |
| mSurfaceWidth = -1; |
| createPreviewThreadIfNeeded(); |
| } |
| |
| @Override |
| public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { |
| logd("surfaceChanged: " + width + "x" + height); |
| |
| mSurfaceWidth = width; |
| mSurfaceHeight = height; |
| |
| if (mPreviewThread != null) { |
| mPreviewThread.onSurfaceChanged(width, height); |
| } |
| } |
| |
| @Override |
| public void surfaceDestroyed(SurfaceHolder holder) { |
| logd("surfaceDestroyed"); |
| mHaveSurface = false; |
| stopPreviewThread(); |
| } |
| |
| // Stop the preview playback if pending and quit the preview thread |
| private void stopPreviewThread() { |
| if (mPreviewThread != null) { |
| mPreviewThread.stopPreviewPlayback(); |
| mPreviewThread.quit(); |
| mPreviewThread = null; |
| } |
| } |
| |
| @Override |
| protected void enterTransitionalState(int statusStringId) { |
| mEditorProjectView.setVisibility(View.GONE); |
| mEditorEmptyView.setVisibility(View.VISIBLE); |
| |
| ((TextView)findViewById(R.id.empty_project_text)).setText(statusStringId); |
| findViewById(R.id.empty_project_progress).setVisibility(View.VISIBLE); |
| } |
| |
| @Override |
| protected void enterDisabledState(int statusStringId) { |
| mEditorProjectView.setVisibility(View.GONE); |
| mEditorEmptyView.setVisibility(View.VISIBLE); |
| |
| getActionBar().setTitle(R.string.full_app_name); |
| |
| ((TextView)findViewById(R.id.empty_project_text)).setText(statusStringId); |
| findViewById(R.id.empty_project_progress).setVisibility(View.GONE); |
| } |
| |
| @Override |
| protected void enterReadyState() { |
| mEditorProjectView.setVisibility(View.VISIBLE); |
| mEditorEmptyView.setVisibility(View.GONE); |
| } |
| |
| @Override |
| protected boolean showPreviewFrame() { |
| if (mPreviewThread == null) { // The surface is not ready yet. |
| return false; |
| } |
| |
| // Regenerate the preview frame |
| if (mProject != null && !mPreviewThread.isPlaying() && mPendingExportFilename == null) { |
| // Display the preview frame |
| mPreviewThread.previewFrame(mProject, mProject.getPlayheadPos(), |
| mProject.getMediaItemCount() == 0); |
| } |
| |
| return true; |
| } |
| |
| @Override |
| protected void updateTimelineDuration() { |
| if (mProject == null) { |
| return; |
| } |
| |
| final long durationMs = mProject.computeDuration(); |
| |
| // Resize the timeline according to the new timeline duration |
| final int zoomWidth = mActivityWidth + timeToDimension(durationMs); |
| final int childrenCount = mTimelineLayout.getChildCount(); |
| for (int i = 0; i < childrenCount; i++) { |
| final View child = mTimelineLayout.getChildAt(i); |
| final ViewGroup.LayoutParams lp = child.getLayoutParams(); |
| lp.width = zoomWidth; |
| child.setLayoutParams(lp); |
| } |
| |
| mTimelineLayout.requestLayout(mLayoutCallback); |
| |
| // Since the duration has changed make sure that the playhead |
| // position is valid. |
| if (mProject.getPlayheadPos() > durationMs) { |
| movePlayhead(durationMs); |
| } |
| |
| mAudioTrackLayout.updateTimelineDuration(); |
| } |
| |
| /** |
| * Convert the time to dimension |
| * At zoom level 1: one activity width = 1200 seconds |
| * At zoom level 2: one activity width = 600 seconds |
| * ... |
| * At zoom level 100: one activity width = 12 seconds |
| * |
| * At zoom level 1000: one activity width = 1.2 seconds |
| * |
| * @param durationMs The time |
| * |
| * @return The dimension |
| */ |
| private int timeToDimension(long durationMs) { |
| return (int)((mProject.getZoomLevel() * mActivityWidth * durationMs) / 1200000); |
| } |
| |
| /** |
| * Zoom the timeline |
| * |
| * @param level The zoom level |
| * @param updateControl true to set the control position to match the |
| * zoom level |
| */ |
| private int zoomTimeline(int level, boolean updateControl) { |
| if (level < 1 || level > MAX_ZOOM_LEVEL) { |
| return mProject.getZoomLevel(); |
| } |
| |
| mProject.setZoomLevel(level); |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, "zoomTimeline level: " + level + " -> " + timeToDimension(1000) + " pix/s"); |
| } |
| |
| updateTimelineDuration(); |
| |
| if (updateControl) { |
| mZoomControl.setProgress(level); |
| } |
| return level; |
| } |
| |
| @Override |
| protected void movePlayhead(long timeMs) { |
| movePlayhead(timeMs, true); |
| } |
| |
| private void movePlayhead(long timeMs, boolean smooth) { |
| if (mProject == null) { |
| return; |
| } |
| |
| if (setPlayhead(timeMs)) { |
| // Scroll the timeline such that the specified position |
| // is in the center of the screen |
| mTimelineScroller.appScrollTo(timeToDimension(timeMs), smooth); |
| } |
| } |
| |
| /** |
| * Set the playhead at the specified time position |
| * |
| * @param timeMs The time position |
| * |
| * @return true if the playhead was set at the specified time position |
| */ |
| private boolean setPlayhead(long timeMs) { |
| // Check if the position would change |
| if (mCurrentPlayheadPosMs == timeMs) { |
| return false; |
| } |
| |
| // Check if the time is valid. Note that invalid values are common due |
| // to overscrolling the timeline |
| if (timeMs < 0) { |
| return false; |
| } else if (timeMs > mProject.computeDuration()) { |
| return false; |
| } |
| |
| mCurrentPlayheadPosMs = timeMs; |
| |
| mTimeView.setText(StringUtils.getTimestampAsString(this, timeMs)); |
| mProject.setPlayheadPos(timeMs); |
| return true; |
| } |
| |
| @Override |
| protected void setAspectRatio(final int aspectRatio) { |
| final FrameLayout.LayoutParams lp = |
| (FrameLayout.LayoutParams)mSurfaceView.getLayoutParams(); |
| |
| switch (aspectRatio) { |
| case MediaProperties.ASPECT_RATIO_5_3: { |
| lp.width = (lp.height * 5) / 3; |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_4_3: { |
| lp.width = (lp.height * 4) / 3; |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_3_2: { |
| lp.width = (lp.height * 3) / 2; |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_11_9: { |
| lp.width = (lp.height * 11) / 9; |
| break; |
| } |
| |
| case MediaProperties.ASPECT_RATIO_16_9: { |
| lp.width = (lp.height * 16) / 9; |
| break; |
| } |
| |
| default: { |
| break; |
| } |
| } |
| |
| logd("setAspectRatio: " + aspectRatio + ", size: " + lp.width + "x" + lp.height); |
| mSurfaceView.setLayoutParams(lp); |
| mOverlayView.setLayoutParams(lp); |
| } |
| |
| @Override |
| protected MediaLinearLayout getMediaLayout() { |
| return mMediaLayout; |
| } |
| |
| @Override |
| protected OverlayLinearLayout getOverlayLayout() { |
| return mOverlayLayout; |
| } |
| |
| @Override |
| protected AudioTrackLinearLayout getAudioTrackLayout() { |
| return mAudioTrackLayout; |
| } |
| |
| @Override |
| protected void onExportProgress(int progress) { |
| if (mExportProgressDialog != null) { |
| mExportProgressDialog.setProgress(progress); |
| } |
| } |
| |
| @Override |
| protected void onExportComplete() { |
| if (mExportProgressDialog != null) { |
| mExportProgressDialog.dismiss(); |
| mExportProgressDialog = null; |
| } |
| } |
| |
| @Override |
| protected void onProjectEditStateChange(boolean projectEdited) { |
| logd("onProjectEditStateChange: " + projectEdited); |
| |
| mPreviewPlayButton.setAlpha(projectEdited ? 100 : 255); |
| mPreviewPlayButton.setEnabled(!projectEdited); |
| mPreviewRewindButton.setEnabled(!projectEdited); |
| mPreviewNextButton.setEnabled(!projectEdited); |
| mPreviewPrevButton.setEnabled(!projectEdited); |
| |
| mMediaLayout.invalidateActionBar(); |
| mOverlayLayout.invalidateCAB(); |
| invalidateOptionsMenu(); |
| } |
| |
| @Override |
| protected void initializeFromProject(boolean updateUI) { |
| logd("Project was clean: " + mProject.isClean()); |
| |
| if (updateUI || !mProject.isClean()) { |
| getActionBar().setTitle(mProject.getName()); |
| |
| // Clear the media related to the previous project and |
| // add the media for the current project. |
| mMediaLayout.setParentTimelineScrollView(mTimelineScroller); |
| mMediaLayout.setProject(mProject); |
| mOverlayLayout.setProject(mProject); |
| mAudioTrackLayout.setProject(mProject); |
| mPlayheadView.setProject(mProject); |
| |
| // Add the media items to the media item layout |
| mMediaLayout.addMediaItems(mProject.getMediaItems()); |
| mMediaLayout.setSelectedView(mMediaLayoutSelectedPos); |
| |
| // Add the media items to the overlay layout |
| mOverlayLayout.addMediaItems(mProject.getMediaItems()); |
| |
| // Add the audio tracks to the audio tracks layout |
| mAudioTrackLayout.addAudioTracks(mProject.getAudioTracks()); |
| |
| setAspectRatio(mProject.getAspectRatio()); |
| } |
| |
| updateTimelineDuration(); |
| zoomTimeline(mProject.getZoomLevel(), true); |
| |
| // Set the playhead position. We need to wait for the layout to |
| // complete before we can scroll to the playhead position. |
| final Handler handler = new Handler(); |
| handler.post(new Runnable() { |
| private final long DELAY = 100; |
| private final int ATTEMPTS = 20; |
| private int mAttempts = ATTEMPTS; |
| |
| @Override |
| public void run() { |
| // If the surface is not yet created (showPreviewFrame() |
| // returns false) wait for a while (DELAY * ATTEMPTS). |
| if (showPreviewFrame() == false && mAttempts >= 0) { |
| mAttempts--; |
| if (mAttempts >= 0) { |
| handler.postDelayed(this, DELAY); |
| } |
| } |
| } |
| }); |
| |
| if (mAddMediaItemVideoUri != null) { |
| ApiService.addMediaItemVideoUri(this, mProjectPath, ApiService.generateId(), |
| mInsertMediaItemAfterMediaItemId, |
| mAddMediaItemVideoUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| mProject.getTheme()); |
| mAddMediaItemVideoUri = null; |
| mInsertMediaItemAfterMediaItemId = null; |
| } |
| |
| if (mAddMediaItemImageUri != null) { |
| ApiService.addMediaItemImageUri(this, mProjectPath, ApiService.generateId(), |
| mInsertMediaItemAfterMediaItemId, |
| mAddMediaItemImageUri, MediaItem.RENDERING_MODE_BLACK_BORDER, |
| MediaItemUtils.getDefaultImageDuration(), mProject.getTheme()); |
| mAddMediaItemImageUri = null; |
| mInsertMediaItemAfterMediaItemId = null; |
| } |
| |
| if (mAddAudioTrackUri != null) { |
| ApiService.addAudioTrack(this, mProject.getPath(), ApiService.generateId(), |
| mAddAudioTrackUri, true); |
| mAddAudioTrackUri = null; |
| } |
| |
| if (mAddTransitionAfterMediaId != null) { |
| mMediaLayout.addTransition(mAddTransitionAfterMediaId, mAddTransitionType, |
| mAddTransitionDurationMs); |
| mAddTransitionAfterMediaId = null; |
| } |
| |
| if (mEditTransitionId != null) { |
| mMediaLayout.editTransition(mEditTransitionAfterMediaId, mEditTransitionId, |
| mEditTransitionType, mEditTransitionDurationMs); |
| mEditTransitionId = null; |
| mEditTransitionAfterMediaId = null; |
| } |
| |
| if (mAddOverlayMediaItemId != null) { |
| ApiService.addOverlay(this, mProject.getPath(), mAddOverlayMediaItemId, |
| ApiService.generateId(), mAddOverlayUserAttributes, 0, |
| OverlayLinearLayout.DEFAULT_TITLE_DURATION); |
| mAddOverlayMediaItemId = null; |
| mAddOverlayUserAttributes = null; |
| } |
| |
| if (mEditOverlayMediaItemId != null) { |
| ApiService.setOverlayUserAttributes(this, mProject.getPath(), mEditOverlayMediaItemId, |
| mEditOverlayId, mEditOverlayUserAttributes); |
| mEditOverlayMediaItemId = null; |
| mEditOverlayId = null; |
| mEditOverlayUserAttributes = null; |
| } |
| |
| if (mAddEffectMediaItemId != null) { |
| mMediaLayout.addEffect(mAddEffectType, mAddEffectMediaItemId, |
| mAddKenBurnsStartRect, mAddKenBurnsEndRect); |
| mAddEffectMediaItemId = null; |
| } |
| |
| enterReadyState(); |
| |
| if (mPendingExportFilename != null) { |
| if (ApiService.isVideoEditorExportPending(mProjectPath, mPendingExportFilename)) { |
| // The export is still pending |
| // Display the export project dialog |
| showExportProgress(); |
| } else { |
| // The export completed while the Activity was paused |
| mPendingExportFilename = null; |
| } |
| } |
| |
| invalidateOptionsMenu(); |
| |
| restartPreview(); |
| } |
| |
| /** |
| * Restarts preview. |
| */ |
| private void restartPreview() { |
| if (mRestartPreview == false) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (mPreviewThread != null) { |
| mRestartPreview = false; |
| mPreviewThread.startPreviewPlayback(mProject, mProject.getPlayheadPos()); |
| } |
| } |
| |
| /** |
| * Shows progress dialog during export operation. |
| */ |
| private void showExportProgress() { |
| // Keep the CPU on throughout the export operation. |
| mExportProgressDialog = new ProgressDialog(this) { |
| @Override |
| public void onStart() { |
| super.onStart(); |
| mCpuWakeLock.acquire(); |
| } |
| @Override |
| public void onStop() { |
| super.onStop(); |
| mCpuWakeLock.release(); |
| } |
| }; |
| mExportProgressDialog.setTitle(getString(R.string.export_dialog_export)); |
| mExportProgressDialog.setMessage(null); |
| mExportProgressDialog.setIndeterminate(false); |
| // Allow cancellation with BACK button. |
| mExportProgressDialog.setCancelable(true); |
| mExportProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| cancelExport(); |
| } |
| }); |
| mExportProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); |
| mExportProgressDialog.setMax(100); |
| mExportProgressDialog.setCanceledOnTouchOutside(false); |
| mExportProgressDialog.setButton(getString(android.R.string.cancel), |
| new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| cancelExport(); |
| } |
| } |
| ); |
| mExportProgressDialog.setCanceledOnTouchOutside(false); |
| mExportProgressDialog.show(); |
| mExportProgressDialog.setProgressNumberFormat(""); |
| } |
| |
| private void cancelExport() { |
| ApiService.cancelExportVideoEditor(VideoEditorActivity.this, mProjectPath, |
| mPendingExportFilename); |
| mPendingExportFilename = null; |
| mExportProgressDialog = null; |
| } |
| |
| private boolean isPreviewPlaying() { |
| if (mPreviewThread == null) |
| return false; |
| |
| return mPreviewThread.isPlaying(); |
| } |
| |
| /** |
| * The preview thread |
| */ |
| private class PreviewThread extends Thread { |
| // Preview states |
| private final int PREVIEW_STATE_STOPPED = 0; |
| private final int PREVIEW_STATE_STARTING = 1; |
| private final int PREVIEW_STATE_STARTED = 2; |
| private final int PREVIEW_STATE_STOPPING = 3; |
| |
| private final int OVERLAY_DATA_COUNT = 16; |
| |
| private final Handler mMainHandler; |
| private final Queue<Runnable> mQueue; |
| private final SurfaceHolder mSurfaceHolder; |
| private final Queue<VideoEditor.OverlayData> mOverlayDataQueue; |
| private Handler mThreadHandler; |
| private int mPreviewState; |
| private Bitmap mOverlayBitmap; |
| |
| private final Runnable mProcessQueueRunnable = new Runnable() { |
| @Override |
| public void run() { |
| // Process whatever accumulated in the queue |
| Runnable runnable; |
| while ((runnable = mQueue.poll()) != null) { |
| runnable.run(); |
| } |
| } |
| }; |
| |
| /** |
| * Constructor |
| * |
| * @param surfaceHolder The surface holder |
| */ |
| public PreviewThread(SurfaceHolder surfaceHolder) { |
| mMainHandler = new Handler(Looper.getMainLooper()); |
| mQueue = new LinkedBlockingQueue<Runnable>(); |
| mSurfaceHolder = surfaceHolder; |
| mPreviewState = PREVIEW_STATE_STOPPED; |
| |
| mOverlayDataQueue = new LinkedBlockingQueue<VideoEditor.OverlayData>(); |
| for (int i = 0; i < OVERLAY_DATA_COUNT; i++) { |
| mOverlayDataQueue.add(new VideoEditor.OverlayData()); |
| } |
| |
| start(); |
| } |
| |
| /** |
| * Preview the specified frame |
| * |
| * @param project The video editor project |
| * @param timeMs The frame time |
| * @param clear true to clear the output |
| */ |
| public void previewFrame(final VideoEditorProject project, final long timeMs, |
| final boolean clear) { |
| if (mPreviewState == PREVIEW_STATE_STARTING || mPreviewState == PREVIEW_STATE_STARTED) { |
| stopPreviewPlayback(); |
| } |
| |
| logd("Preview frame at: " + timeMs + " " + clear); |
| |
| // We only need to see the last frame |
| mQueue.clear(); |
| |
| mQueue.add(new Runnable() { |
| @Override |
| public void run() { |
| if (clear) { |
| try { |
| project.clearSurface(mSurfaceHolder); |
| } catch (Exception ex) { |
| Log.w(TAG, "Surface cannot be cleared"); |
| } |
| |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| if (mOverlayBitmap != null) { |
| mOverlayBitmap.eraseColor(Color.TRANSPARENT); |
| mOverlayView.invalidate(); |
| } |
| } |
| }); |
| } else { |
| final VideoEditor.OverlayData overlayData; |
| try { |
| overlayData = mOverlayDataQueue.remove(); |
| } catch (NoSuchElementException ex) { |
| Log.e(TAG, "Out of OverlayData elements"); |
| return; |
| } |
| |
| try { |
| if (project.renderPreviewFrame(mSurfaceHolder, timeMs, overlayData) |
| < 0) { |
| logd("Cannot render preview frame at: " + timeMs + |
| " of " + mProject.computeDuration()); |
| |
| mOverlayDataQueue.add(overlayData); |
| } else { |
| if (overlayData.needsRendering()) { |
| mMainHandler.post(new Runnable() { |
| /* |
| * {@inheritDoc} |
| */ |
| @Override |
| public void run() { |
| if (mOverlayBitmap != null) { |
| overlayData.renderOverlay(mOverlayBitmap); |
| mOverlayView.invalidate(); |
| } else { |
| overlayData.release(); |
| } |
| |
| mOverlayDataQueue.add(overlayData); |
| } |
| }); |
| } else { |
| mOverlayDataQueue.add(overlayData); |
| } |
| } |
| } catch (Exception ex) { |
| logd("renderPreviewFrame failed at timeMs: " + timeMs + "\n" + ex); |
| mOverlayDataQueue.add(overlayData); |
| } |
| } |
| } |
| }); |
| |
| if (mThreadHandler != null) { |
| mThreadHandler.post(mProcessQueueRunnable); |
| } |
| } |
| |
| /** |
| * Display the frame at the specified time position |
| * |
| * @param mediaItem The media item |
| * @param timeMs The frame time |
| */ |
| public void renderMediaItemFrame(final MovieMediaItem mediaItem, final long timeMs) { |
| if (mPreviewState == PREVIEW_STATE_STARTING || mPreviewState == PREVIEW_STATE_STARTED) { |
| stopPreviewPlayback(); |
| } |
| |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, "Render media item frame at: " + timeMs); |
| } |
| |
| // We only need to see the last frame |
| mQueue.clear(); |
| |
| mQueue.add(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| if (mProject.renderMediaItemFrame(mSurfaceHolder, mediaItem.getId(), |
| timeMs) < 0) { |
| logd("Cannot render media item frame at: " + timeMs + |
| " of " + mediaItem.getDuration()); |
| } |
| } catch (Exception ex) { |
| logd("Cannot render preview frame at: " + timeMs + "\n" + ex); |
| } |
| } |
| }); |
| |
| if (mThreadHandler != null) { |
| mThreadHandler.post(mProcessQueueRunnable); |
| } |
| } |
| |
| /** |
| * Starts the preview playback. |
| * |
| * @param project The video editor project |
| * @param fromMs Start playing from the specified position |
| */ |
| private void startPreviewPlayback(final VideoEditorProject project, final long fromMs) { |
| if (mPreviewState != PREVIEW_STATE_STOPPED) { |
| logd("Preview did not start: " + mPreviewState); |
| return; |
| } |
| |
| previewStarted(project); |
| logd("Start preview at: " + fromMs); |
| |
| // Clear any pending preview frames |
| mQueue.clear(); |
| mQueue.add(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| project.startPreview(mSurfaceHolder, fromMs, -1, false, 3, |
| new VideoEditor.PreviewProgressListener() { |
| @Override |
| public void onStart(VideoEditor videoEditor) { |
| } |
| |
| @Override |
| public void onProgress(VideoEditor videoEditor, final long timeMs, |
| final VideoEditor.OverlayData overlayData) { |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| if (overlayData != null && overlayData.needsRendering()) { |
| if (mOverlayBitmap != null) { |
| overlayData.renderOverlay(mOverlayBitmap); |
| mOverlayView.invalidate(); |
| } else { |
| overlayData.release(); |
| } |
| } |
| |
| if (mPreviewState == PREVIEW_STATE_STARTED || |
| mPreviewState == PREVIEW_STATE_STOPPING) { |
| movePlayhead(timeMs); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void onStop(VideoEditor videoEditor) { |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| if (mPreviewState == PREVIEW_STATE_STARTED || |
| mPreviewState == PREVIEW_STATE_STOPPING) { |
| previewStopped(false); |
| } |
| } |
| }); |
| } |
| |
| public void onError(VideoEditor videoEditor, int error) { |
| Log.w(TAG, "PreviewProgressListener onError:" + error); |
| |
| // Notify the user that some error happened. |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| String msg = getString(R.string.editor_preview_error); |
| Toast.makeText(VideoEditorActivity.this, msg, |
| Toast.LENGTH_LONG).show(); |
| } |
| }); |
| |
| onStop(videoEditor); |
| } |
| }); |
| |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| mPreviewState = PREVIEW_STATE_STARTED; |
| } |
| }); |
| } catch (Exception ex) { |
| // This exception may occur when trying to play frames |
| // at the end of the timeline |
| // (e.g. when fromMs == clip duration) |
| Log.w(TAG, "Cannot start preview at: " + fromMs + "\n" + ex); |
| |
| mMainHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| mPreviewState = PREVIEW_STATE_STARTED; |
| previewStopped(true); |
| } |
| }); |
| } |
| } |
| }); |
| |
| if (mThreadHandler != null) { |
| mThreadHandler.post(mProcessQueueRunnable); |
| } |
| } |
| |
| /** |
| * The preview started. |
| * This method is always invoked from the UI thread. |
| * |
| * @param project The project |
| */ |
| private void previewStarted(VideoEditorProject project) { |
| // Change the button image back to a pause icon |
| mPreviewPlayButton.setImageResource(R.drawable.btn_playback_ic_pause); |
| |
| mTimelineScroller.enableUserScrolling(false); |
| mMediaLayout.setPlaybackInProgress(true); |
| mOverlayLayout.setPlaybackInProgress(true); |
| mAudioTrackLayout.setPlaybackInProgress(true); |
| |
| mPreviewState = PREVIEW_STATE_STARTING; |
| |
| // Keep the screen on during the preview. |
| VideoEditorActivity.this.getWindow().addFlags( |
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); |
| } |
| |
| /** |
| * Stops the preview. |
| */ |
| private void stopPreviewPlayback() { |
| switch (mPreviewState) { |
| case PREVIEW_STATE_STOPPED: { |
| logd("stopPreviewPlayback: State was PREVIEW_STATE_STOPPED"); |
| return; |
| } |
| |
| case PREVIEW_STATE_STOPPING: { |
| logd("stopPreviewPlayback: State was PREVIEW_STATE_STOPPING"); |
| return; |
| } |
| |
| case PREVIEW_STATE_STARTING: { |
| logd("stopPreviewPlayback: State was PREVIEW_STATE_STARTING " + |
| "now PREVIEW_STATE_STOPPING"); |
| mPreviewState = PREVIEW_STATE_STOPPING; |
| |
| // We need to wait until the preview starts |
| mMainHandler.postDelayed(new Runnable() { |
| @Override |
| public void run() { |
| if (mPreviewState == PREVIEW_STATE_STARTED) { |
| logd("stopPreviewPlayback: Now PREVIEW_STATE_STARTED"); |
| previewStopped(false); |
| } else if (mPreviewState == PREVIEW_STATE_STOPPING) { |
| // Keep waiting |
| mMainHandler.postDelayed(this, 100); |
| logd("stopPreviewPlayback: Waiting for PREVIEW_STATE_STARTED"); |
| } else { |
| logd("stopPreviewPlayback: PREVIEW_STATE_STOPPED while waiting"); |
| } |
| } |
| }, 50); |
| break; |
| } |
| |
| case PREVIEW_STATE_STARTED: { |
| logd("stopPreviewPlayback: State was PREVIEW_STATE_STARTED"); |
| |
| // We need to stop |
| previewStopped(false); |
| return; |
| } |
| |
| default: { |
| throw new IllegalArgumentException("stopPreviewPlayback state: " + |
| mPreviewState); |
| } |
| } |
| } |
| |
| /** |
| * The surface size has changed |
| * |
| * @param width The new surface width |
| * @param height The new surface height |
| */ |
| private void onSurfaceChanged(int width, int height) { |
| if (mOverlayBitmap != null) { |
| if (mOverlayBitmap.getWidth() == width && mOverlayBitmap.getHeight() == height) { |
| // The size has not changed |
| return; |
| } |
| |
| mOverlayView.setImageBitmap(null); |
| mOverlayBitmap.recycle(); |
| mOverlayBitmap = null; |
| } |
| |
| // Create the overlay bitmap |
| logd("Overlay size: " + width + " x " + height); |
| |
| mOverlayBitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888); |
| mOverlayView.setImageBitmap(mOverlayBitmap); |
| } |
| |
| /** |
| * Preview stopped. This method is always invoked from the UI thread. |
| * |
| * @param error true if the preview stopped due to an error |
| */ |
| private void previewStopped(boolean error) { |
| if (mProject == null) { |
| Log.w(TAG, "previewStopped: project was deleted."); |
| return; |
| } |
| |
| if (mPreviewState != PREVIEW_STATE_STARTED) { |
| throw new IllegalStateException("previewStopped in state: " + mPreviewState); |
| } |
| |
| // Change the button image back to a play icon |
| mPreviewPlayButton.setImageResource(R.drawable.btn_playback_ic_play); |
| |
| if (error == false) { |
| // Set the playhead position at the position where the playback stopped |
| final long stopTimeMs = mProject.stopPreview(); |
| movePlayhead(stopTimeMs); |
| logd("PREVIEW_STATE_STOPPED: " + stopTimeMs); |
| } else { |
| logd("PREVIEW_STATE_STOPPED due to error"); |
| } |
| |
| mPreviewState = PREVIEW_STATE_STOPPED; |
| |
| // The playback has stopped |
| mTimelineScroller.enableUserScrolling(true); |
| mMediaLayout.setPlaybackInProgress(false); |
| mAudioTrackLayout.setPlaybackInProgress(false); |
| mOverlayLayout.setPlaybackInProgress(false); |
| |
| // Do not keep the screen on if there is no preview in progress. |
| VideoEditorActivity.this.getWindow().clearFlags( |
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); |
| } |
| |
| /** |
| * @return true if preview playback is in progress |
| */ |
| private boolean isPlaying() { |
| return mPreviewState == PREVIEW_STATE_STARTING || |
| mPreviewState == PREVIEW_STATE_STARTED; |
| } |
| |
| /** |
| * @return true if the preview is stopped |
| */ |
| private boolean isStopped() { |
| return mPreviewState == PREVIEW_STATE_STOPPED; |
| } |
| |
| @Override |
| public void run() { |
| setPriority(MAX_PRIORITY); |
| Looper.prepare(); |
| mThreadHandler = new Handler(); |
| |
| // Ensure that the queued items are processed |
| mThreadHandler.post(mProcessQueueRunnable); |
| |
| // Run the loop |
| Looper.loop(); |
| } |
| |
| /** |
| * Quits the thread |
| */ |
| public void quit() { |
| // Release the overlay bitmap |
| if (mOverlayBitmap != null) { |
| mOverlayView.setImageBitmap(null); |
| mOverlayBitmap.recycle(); |
| mOverlayBitmap = null; |
| } |
| |
| if (mThreadHandler != null) { |
| mThreadHandler.getLooper().quit(); |
| try { |
| // Wait for the thread to quit. An ANR waiting to happen. |
| mThreadHandler.getLooper().getThread().join(); |
| } catch (InterruptedException ex) { |
| } |
| } |
| |
| mQueue.clear(); |
| } |
| } |
| |
| private static void logd(String message) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, message); |
| } |
| } |
| } |
