| /* |
| * 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.List; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.media.AudioManager; |
| import android.media.videoeditor.AudioTrack; |
| import android.media.videoeditor.MediaItem; |
| import android.media.videoeditor.MediaVideoItem; |
| import android.media.videoeditor.Transition; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.util.Log; |
| import android.widget.Toast; |
| |
| import com.android.videoeditor.service.ApiService; |
| import com.android.videoeditor.service.ApiServiceListener; |
| import com.android.videoeditor.service.MovieAudioTrack; |
| import com.android.videoeditor.service.MovieEffect; |
| import com.android.videoeditor.service.MovieMediaItem; |
| import com.android.videoeditor.service.MovieOverlay; |
| import com.android.videoeditor.service.MovieTransition; |
| import com.android.videoeditor.service.VideoEditorProject; |
| import com.android.videoeditor.widgets.AudioTrackLinearLayout; |
| import com.android.videoeditor.widgets.MediaLinearLayout; |
| import com.android.videoeditor.widgets.OverlayLinearLayout; |
| |
| /** |
| * This activity handles callbacks from the service and manages the project |
| */ |
| public abstract class VideoEditorBaseActivity extends Activity { |
| // Logging |
| private static final String TAG = "VideoEditorBase"; |
| |
| protected static final int DIALOG_DELETE_BAD_PROJECT_ID = 100; |
| |
| // State keys |
| private static final String STATE_PROJECT_PATH = "path"; |
| private static final String STATE_EXPORT_FILENAME = "export_filename"; |
| |
| // Dialog parameters |
| protected static final String PARAM_PROJECT_PATH = "path"; |
| |
| // Instance variables |
| private final ServiceListener mServiceListener = new ServiceListener(); |
| protected String mProjectPath; |
| protected VideoEditorProject mProject; |
| protected String mPendingExportFilename; |
| private boolean mProjectEditState; |
| |
| /** |
| * The service listener |
| */ |
| private class ServiceListener extends ApiServiceListener { |
| |
| @Override |
| public void onProjectEditState(String projectPath, boolean projectEdited) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProjectEditState != projectEdited) { |
| mProjectEditState = projectEdited; |
| onProjectEditStateChange(projectEdited); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorCreated(String projectPath, VideoEditorProject project, |
| List<MediaItem> mediaItems, List<AudioTrack> audioTracks, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| // Check if an error occurred |
| if (exception != null) { |
| // Invalidate the project path |
| mProjectPath = null; |
| |
| enterDisabledState(R.string.editor_no_project); |
| // Display an error |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_create_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| enterReadyState(); |
| |
| mProject = project; |
| initializeFromProject(true); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorLoaded(String projectPath, VideoEditorProject project, |
| List<MediaItem> mediaItems, List<AudioTrack> audioTracks, Exception exception) { |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| // Check if an error occurred |
| if (exception != null || project == null) { |
| mProjectPath = null; |
| |
| enterDisabledState(R.string.editor_no_project); |
| |
| final Bundle bundle = new Bundle(); |
| bundle.putString(VideoEditorActivity.PARAM_PROJECT_PATH, projectPath); |
| showDialog(DIALOG_DELETE_BAD_PROJECT_ID, bundle); |
| } else { |
| // The project may be loaded already. This can happen when we |
| // create a new project |
| if (mProject == null) { |
| mProject = project; |
| initializeFromProject(true); |
| } |
| } |
| } |
| |
| @Override |
| public void onVideoEditorAspectRatioSet(String projectPath, int aspectRatio, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_aspect_ratio_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| // The aspect ratio has changed |
| setAspectRatio(aspectRatio); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorThemeApplied(String projectPath, String theme, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_apply_theme_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().addMediaItems(mProject.getMediaItems()); |
| getOverlayLayout().addMediaItems(mProject.getMediaItems()); |
| getAudioTrackLayout().addAudioTracks(mProject.getAudioTracks()); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorGeneratePreviewProgress(String projectPath, String className, |
| String itemId, int action, int progress) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, "onVideoEditorGeneratePreviewProgress: " + className + " " + progress); |
| } |
| |
| if (className == null) { // Last callback (after all items are generated) |
| if (action == ApiService.ACTION_UPDATE_FRAME) { |
| showPreviewFrame(); |
| } |
| } else if (MediaItem.class.getCanonicalName().equals(className)) { |
| getMediaLayout().onGeneratePreviewMediaItemProgress(itemId, action, progress); |
| } else if (Transition.class.getCanonicalName().equals(className)) { |
| getMediaLayout().onGeneratePreviewTransitionProgress(itemId, action, progress); |
| } else if (AudioTrack.class.getCanonicalName().equals(className)) { |
| getAudioTrackLayout().onGeneratePreviewProgress(itemId, action, progress); |
| } else { |
| Log.w(TAG, "Unsupported storyboard item type: " + className); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorExportProgress(String projectPath, String filename, |
| int progress) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (!filename.equals(mPendingExportFilename)) { |
| return; |
| } |
| |
| // Update the export progress |
| onExportProgress(progress); |
| } |
| |
| @Override |
| public void onVideoEditorExportComplete(String projectPath, String filename, |
| Exception exception, boolean cancelled) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (!filename.equals(mPendingExportFilename)) { |
| return; |
| } |
| |
| onExportComplete(); |
| |
| mPendingExportFilename = null; |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_export_error, |
| Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorSaved(String projectPath, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_saved_error, |
| Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorReleased(String projectPath, Exception exception) { |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_release_error, |
| Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onVideoEditorDeleted(String projectPath, Exception exception) { |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_delete_error, |
| Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onMediaItemAdded(String projectPath, String mediaItemId, |
| MovieMediaItem mediaItem, String afterMediaItemId, Class<?> mediaItemClass, |
| Integer newAspectRatio, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting. |
| if (!projectPath.equals(mProjectPath) || mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| if (mediaItemClass.getCanonicalName().equals( |
| MediaVideoItem.class.getCanonicalName())) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_add_video_clip_error, Toast.LENGTH_LONG).show(); |
| } else { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_add_image_error, |
| Toast.LENGTH_LONG).show(); |
| } |
| } else { |
| getMediaLayout().insertMediaItem(mediaItem, afterMediaItemId); |
| getOverlayLayout().insertMediaItem(mediaItem, afterMediaItemId); |
| |
| if (newAspectRatio != null) { |
| // The aspect ratio has changed |
| setAspectRatio(newAspectRatio); |
| } |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onMediaLoaded(String projectPath, Uri mediaIUri, String mimeType, |
| String filename, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_media_load_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| // Update the status of the downloaded item in the user interface |
| } |
| } |
| |
| @Override |
| public void onMediaItemMoved(String projectPath, String mediaItemId, |
| String afterMediaItemId, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_move_media_item_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| // Update the entire timeline |
| getMediaLayout().addMediaItems(mProject.getMediaItems()); |
| getOverlayLayout().addMediaItems(mProject.getMediaItems()); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onMediaItemRemoved(String projectPath, String mediaItemId, |
| MovieTransition transition, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_remove_media_item_error, Toast.LENGTH_LONG).show(); |
| } else { |
| // Remove the media item and bounding transitions |
| getMediaLayout().removeMediaItem(mediaItemId, transition); |
| getOverlayLayout().removeMediaItem(mediaItemId); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onMediaItemRenderingModeSet(String projectPath, String mediaItemId, |
| int renderingMode, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_rendering_mode_error, Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onMediaItemDurationSet(String projectPath, String mediaItemId, |
| long durationMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_media_item_duration_error, Toast.LENGTH_LONG).show(); |
| } else { |
| final MovieMediaItem mediaItem = mProject.getMediaItem(mediaItemId); |
| // Update the media item |
| getMediaLayout().updateMediaItem(mediaItem); |
| getOverlayLayout().updateMediaItem(mediaItem); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onMediaItemBoundariesSet(String projectPath, String mediaItemId, |
| long beginBoundaryMs, long endBoundaryMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_media_item_boundaries_error, Toast.LENGTH_LONG).show(); |
| } else { |
| final MovieMediaItem mediaItem = mProject.getMediaItem(mediaItemId); |
| getMediaLayout().updateMediaItem(mediaItem); |
| getOverlayLayout().updateMediaItem(mediaItem); |
| |
| // Place the cursor at the beginning of the trimmed media item |
| //movePlayhead(mProject.getMediaItemBeginTime(mediaItemId)); |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public boolean onMediaItemThumbnail(String projectPath, String mediaItemId, |
| Bitmap thumbnail, int index, int token, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return false; |
| } |
| |
| if (mProject == null) { |
| return false; |
| } |
| |
| if (exception != null) { |
| return false; |
| } else { |
| return getMediaLayout().setMediaItemThumbnail( |
| mediaItemId, thumbnail, index, token); |
| } |
| } |
| |
| @Override |
| public void onTransitionInserted(String projectPath, MovieTransition transition, |
| String afterMediaId, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_add_transition_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().addTransition(transition, afterMediaId); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onTransitionRemoved(String projectPath, String transitionId, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_remove_transition_error, Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().removeTransition(transitionId); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public void onTransitionDurationSet(String projectPath, String transitionId, |
| long durationMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_transition_duration_error, Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().updateTransition(transitionId); |
| getOverlayLayout().refresh(); |
| |
| updateTimelineDuration(); |
| } |
| } |
| |
| @Override |
| public boolean onTransitionThumbnails(String projectPath, String transitionId, |
| Bitmap[] thumbnails, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return false; |
| } |
| |
| if (mProject == null) { |
| return false; |
| } |
| |
| if (exception != null) { |
| return false; |
| } else { |
| return getMediaLayout().setTransitionThumbnails(transitionId, thumbnails); |
| } |
| } |
| |
| @Override |
| public void onOverlayAdded(String projectPath, MovieOverlay overlay, |
| String mediaItemId, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_add_overlay_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().invalidateActionBar(); |
| getOverlayLayout().addOverlay(mediaItemId, overlay); |
| } |
| } |
| |
| @Override |
| public void onOverlayRemoved(String projectPath, String overlayId, |
| String mediaItemId, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_remove_overlay_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getOverlayLayout().removeOverlay(mediaItemId, overlayId); |
| } |
| } |
| |
| @Override |
| public void onOverlayStartTimeSet(String projectPath, String overlayId, |
| String mediaItemId, long startTimeMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_start_time_overlay_error, Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onOverlayDurationSet(String projectPath, String overlayId, |
| String mediaItemId, long durationMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_duration_overlay_error, Toast.LENGTH_LONG).show(); |
| } |
| } |
| |
| @Override |
| public void onOverlayUserAttributesSet(String projectPath, String overlayId, |
| String mediaItemId, Bundle userAttributes, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_user_attributes_overlay_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getOverlayLayout().updateOverlayAttributes(mediaItemId, overlayId, userAttributes); |
| } |
| } |
| |
| @Override |
| public void onEffectAdded(String projectPath, MovieEffect effect, String mediaItemId, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_add_effect_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getMediaLayout().updateMediaItem(mProject.getMediaItem(mediaItemId)); |
| } |
| } |
| |
| @Override |
| public void onEffectRemoved(String projectPath, String effectId, String mediaItemId, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_remove_effect_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| // Remove the effect |
| getMediaLayout().updateMediaItem(mProject.getMediaItem(mediaItemId)); |
| } |
| } |
| |
| @Override |
| public void onAudioTrackAdded(String projectPath, MovieAudioTrack audioTrack, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, R.string.editor_add_audio_track_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getAudioTrackLayout().addAudioTrack(audioTrack); |
| } |
| } |
| |
| @Override |
| public void onAudioTrackRemoved(String projectPath, String audioTrackId, |
| Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_remove_audio_track_error, Toast.LENGTH_LONG).show(); |
| } else { |
| getAudioTrackLayout().removeAudioTrack(audioTrackId); |
| } |
| } |
| |
| @Override |
| public void onAudioTrackBoundariesSet(String projectPath, String audioTrackId, |
| long beginBoundaryMs, long endBoundaryMs, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception != null) { |
| Toast.makeText(VideoEditorBaseActivity.this, |
| R.string.editor_set_audio_track_boundaries_error, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| getAudioTrackLayout().updateAudioTrack(audioTrackId); |
| } |
| } |
| |
| @Override |
| public void onAudioTrackExtractAudioWaveformProgress(String projectPath, |
| String audioTrackId, int progress) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| getAudioTrackLayout().setWaveformExtractionProgress(audioTrackId, progress); |
| } |
| |
| @Override |
| public void onAudioTrackExtractAudioWaveformComplete(String projectPath, |
| String audioTrackId, Exception exception) { |
| // Check if the VideoEditor is the one we are expecting |
| if (!projectPath.equals(mProjectPath)) { |
| return; |
| } |
| |
| if (mProject == null) { |
| return; |
| } |
| |
| if (exception == null) { |
| getAudioTrackLayout().setWaveformExtractionComplete(audioTrackId); |
| } |
| } |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.video_editor); |
| |
| if (savedInstanceState != null) { |
| mProjectPath = savedInstanceState.getString(STATE_PROJECT_PATH); |
| mPendingExportFilename = savedInstanceState.getString(STATE_EXPORT_FILENAME); |
| } else { |
| final Intent intent = getIntent(); |
| mProjectPath = intent.getStringExtra(ProjectsActivity.PARAM_OPEN_PROJECT_PATH); |
| if (Intent.ACTION_INSERT.equals(intent.getAction())) { |
| ApiService.createVideoEditor(this, mProjectPath, |
| intent.getStringExtra(ProjectsActivity.PARAM_CREATE_PROJECT_NAME), |
| new String[0], new String[0], null); |
| } |
| } |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| mProjectEditState = ApiService.isProjectBeingEdited(mProjectPath); |
| onProjectEditStateChange(mProjectEditState); |
| |
| ApiService.registerListener(mServiceListener); |
| |
| // Check if we need to load the project |
| if (mProjectPath != null) { |
| if (mProject == null) { |
| // We need to load the project |
| ApiService.loadVideoEditor(this, mProjectPath); |
| enterTransitionalState(R.string.editor_loading_project); |
| } else { // The project is already loaded |
| initializeFromProject(false); |
| } |
| } else { |
| enterDisabledState(R.string.editor_no_project); |
| } |
| |
| // Request the audio focus so that other apps can pause playback. |
| final AudioManager audioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE); |
| audioManager.requestAudioFocus(null, AudioManager.STREAM_MUSIC, |
| AudioManager.AUDIOFOCUS_GAIN); |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| ApiService.unregisterListener(mServiceListener); |
| |
| if (mProject != null) { |
| // Mark the project as clean. If/when we resume the activity |
| // we can check this flag in order to refresh the UI for changes |
| // which may had occurred when the activity was paused. |
| mProject.setClean(true); |
| // Save the contents of the current project |
| ApiService.saveVideoEditor(this, mProjectPath); |
| } |
| |
| // Release the audio focus |
| final AudioManager audioManager = (AudioManager)getSystemService(Context.AUDIO_SERVICE); |
| audioManager.abandonAudioFocus(null); |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| |
| // If we have an active project release the VideoEditor |
| if (mProjectPath != null) { |
| if (!isChangingConfigurations()) { |
| ApiService.releaseVideoEditor(this, mProjectPath); |
| } |
| |
| mProjectPath = null; |
| } |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| |
| outState.putString(STATE_PROJECT_PATH, mProjectPath); |
| outState.putString(STATE_EXPORT_FILENAME, mPendingExportFilename); |
| } |
| |
| /** |
| * @return true if the project is edited |
| */ |
| protected boolean isProjectEdited() { |
| return mProjectEditState; |
| } |
| |
| /** |
| * Enter the disabled state |
| * |
| * @param statusStringId The status string id |
| */ |
| protected abstract void enterDisabledState(int statusStringId); |
| |
| /** |
| * Enter the transitional state |
| * |
| * @param statusStringId The status string id |
| */ |
| protected abstract void enterTransitionalState(int statusStringId); |
| |
| /** |
| * Enter the ready state |
| */ |
| protected abstract void enterReadyState(); |
| |
| /** |
| * Show the preview frame at the current playhead position |
| * |
| * @return true if the surface is created, false otherwise. |
| */ |
| protected abstract boolean showPreviewFrame(); |
| |
| /** |
| * The duration of the timeline has changed |
| */ |
| protected abstract void updateTimelineDuration(); |
| |
| /** |
| * Move the playhead to the specified position |
| * |
| * @param timeMs The time position |
| */ |
| protected abstract void movePlayhead(long timeMs); |
| |
| /** |
| * Change the aspect ratio |
| * |
| * @param aspectRatio The new aspect ratio |
| */ |
| protected abstract void setAspectRatio(int aspectRatio); |
| |
| /** |
| * Initialize the project when restored from storage. |
| * |
| * @param updateUI true to update the UI |
| * |
| * Note that this method may be called also after the project was loaded |
| */ |
| protected abstract void initializeFromProject(boolean updateUI); |
| |
| /** |
| * @return The media layout |
| */ |
| protected abstract MediaLinearLayout getMediaLayout(); |
| |
| /** |
| * @return The overlay layout |
| */ |
| protected abstract OverlayLinearLayout getOverlayLayout(); |
| |
| /** |
| * @return The audio layout |
| */ |
| protected abstract AudioTrackLinearLayout getAudioTrackLayout(); |
| |
| /** |
| * The export is progressing |
| */ |
| protected abstract void onExportProgress(int progress); |
| |
| /** |
| * The export has completed |
| */ |
| protected abstract void onExportComplete(); |
| |
| /** |
| * @param projectEdited true if the project is edited |
| */ |
| protected abstract void onProjectEditStateChange(boolean projectEdited); |
| } |
