src/com/android/videoeditor/widgets/MediaItemView.java - platform/packages/apps/VideoEditor - Git at Google

 /*

  * Copyright (C) 2011 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.widgets;

 import com.android.videoeditor.service.ApiService;
 import com.android.videoeditor.service.MovieMediaItem;
 import com.android.videoeditor.R;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.LruCache;
 import android.view.Display;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.WindowManager;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Map;

 /**
  * Media item preview view on the timeline. This class assumes the media item is always put on a
  * MediaLinearLayout and is wrapped with a timeline scroll view.
  */
 public class MediaItemView extends View {
     private static final String TAG = "MediaItemView";

     // Static variables
     private static Drawable sAddTransitionDrawable;
     private static Drawable sEmptyFrameDrawable;
     private static ThumbnailCache sThumbnailCache;

     // Because MediaItemView may be recreated for the same MediaItem (it happens
     // when the device orientation is changed), we use a globally unique
     // generation counter to reject thumbnail results (passed to setBitmap())
     // requested by a previous incarnation of MediaItemView.
     private static int sGenerationCounter;

     // Instance variables
     private final GestureDetector mGestureDetector;
     private final ScrollViewListener mScrollListener;
     private final Rect mGeneratingEffectProgressDestRect;

     private boolean mIsScrolling;
     private boolean mIsPlaying;

     // Progress of generation of the effect applied on this media item view.
     // -1 indicates the generation is not in progress. 0-100 indicates the
     // generation is in progress. Currently only Ken Burns effect is used with
     // the progress bar.
     private int mGeneratingEffectProgress;

     // The scrolled left pixels of this view.
     private int mScrollX;

     private String mProjectPath;
     private MovieMediaItem mMediaItem;
     // Convenient handle to the parent timeline scroll view.
     private TimelineHorizontalScrollView mScrollView;
     // Convenient handle to the parent timeline linear layout.
     private MediaLinearLayout mTimeline;
     private ItemSimpleGestureListener mGestureListener;
     private int[] mLeftState, mRightState;

     private int mScreenWidth;
     private int mThumbnailWidth, mThumbnailHeight;
     private int mNumberOfThumbnails;
     private long mBeginTimeMs, mEndTimeMs;

     private int mGeneration;
     private HashSet<Integer> mPending;
     private ArrayList<Integer> mWantThumbnails;

     public MediaItemView(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public MediaItemView(Context context) {
         this(context, null, 0);
     }

     public MediaItemView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);

         // Initialize static data
         if (sAddTransitionDrawable == null) {
             sAddTransitionDrawable = getResources().getDrawable(
                     R.drawable.add_transition_selector);
             sEmptyFrameDrawable = getResources().getDrawable(
                     R.drawable.timeline_loading);

             // Initialize the thumbnail cache, limit the memory usage to 3MB
             sThumbnailCache = new ThumbnailCache(3*1024*1024);
         }

         // Get the screen width
         final Display display = ((WindowManager)context.getSystemService(
                 Context.WINDOW_SERVICE)).getDefaultDisplay();
         final DisplayMetrics metrics = new DisplayMetrics();
         display.getMetrics(metrics);
         mScreenWidth = metrics.widthPixels;

         // Setup our gesture detector and scroll listener
         mGestureDetector = new GestureDetector(context, new MyGestureListener());
         mScrollListener = new MyScrollViewListener();

         // Prepare the progress bar rectangles
         final ProgressBar progressBar = ProgressBar.getProgressBar(context);
         final int layoutHeight = (int)(
                 getResources().getDimension(R.dimen.media_layout_height) -
                 getResources().getDimension(R.dimen.media_layout_padding));
         mGeneratingEffectProgressDestRect = new Rect(getPaddingLeft(),
                 layoutHeight - progressBar.getHeight() - getPaddingBottom(), 0,
                 layoutHeight - getPaddingBottom());

         // Initialize the progress value
         mGeneratingEffectProgress = -1;

         // Initialize the "Add transition" indicators state
         mLeftState = View.EMPTY_STATE_SET;
         mRightState = View.EMPTY_STATE_SET;

         // Initialize the thumbnail indices we want to request
         mWantThumbnails = new ArrayList<Integer>();

         // Initialize the set of indices we are waiting
         mPending = new HashSet<Integer>();

         // Initialize the generation number
         mGeneration = sGenerationCounter++;
     }

     private class MyGestureListener extends GestureDetector.SimpleOnGestureListener {
         @Override
         public boolean onSingleTapConfirmed(MotionEvent e) {
             if (mGestureListener == null) {
                 return false;
             }

             int tappedArea = ItemSimpleGestureListener.CENTER_AREA;

             if (hasSpaceForAddTransitionIcons()) {
                 if (mMediaItem.getBeginTransition() == null &&
                         e.getX() < sAddTransitionDrawable.getIntrinsicWidth() +
                         getPaddingLeft()) {
                     tappedArea = ItemSimpleGestureListener.LEFT_AREA;
                 } else if (mMediaItem.getEndTransition() == null &&
                         e.getX() >= getWidth() - getPaddingRight() -
                         sAddTransitionDrawable.getIntrinsicWidth()) {
                     tappedArea = ItemSimpleGestureListener.RIGHT_AREA;
                 }
             }
             return mGestureListener.onSingleTapConfirmed(
                     MediaItemView.this, tappedArea, e);
         }

         @Override
         public void onLongPress(MotionEvent e) {
             if (mGestureListener != null) {
                 mGestureListener.onLongPress(MediaItemView.this, e);
             }
         }
     }

     private class MyScrollViewListener implements ScrollViewListener {
         @Override
         public void onScrollBegin(View view, int scrollX, int scrollY, boolean appScroll) {
             mIsScrolling = true;
         }

         @Override
         public void onScrollProgress(View view, int scrollX, int scrollY, boolean appScroll) {
             mScrollX = scrollX;
             invalidate();
         }

         @Override
         public void onScrollEnd(View view, int scrollX, int scrollY, boolean appScroll) {
             mIsScrolling = false;
             mScrollX = scrollX;
             invalidate();
         }
     }

     @Override
     protected void onAttachedToWindow() {
         mMediaItem = (MovieMediaItem) getTag();

         mScrollView = (TimelineHorizontalScrollView) getRootView().findViewById(
                 R.id.timeline_scroller);
         mScrollView.addScrollListener(mScrollListener);
         // Add the horizontal scroll view listener
         mScrollX = mScrollView.getScrollX();

         mTimeline = (MediaLinearLayout) getRootView().findViewById(R.id.timeline_media);
     }

     @Override
     protected void onDetachedFromWindow() {
         mScrollView.removeScrollListener(mScrollListener);
         // Release the cached bitmaps
         releaseBitmapsAndClear();
     }

     /**
      * @return The shadow builder
      */
     public DragShadowBuilder getShadowBuilder() {
         return new MediaItemShadowBuilder(this);
     }

     /**
      * Shadow builder for the media item
      */
     private class MediaItemShadowBuilder extends DragShadowBuilder {
         private final Drawable mFrame;

         public MediaItemShadowBuilder(View view) {
             super(view);
             mFrame = view.getContext().getResources().getDrawable(
                     R.drawable.timeline_item_pressed);
         }

         @Override
         public void onProvideShadowMetrics(Point shadowSize, Point shadowTouchPoint) {
             shadowSize.set(getShadowWidth(), getShadowHeight());
             shadowTouchPoint.set(shadowSize.x / 2, shadowSize.y);
         }

         @Override
         public void onDrawShadow(Canvas canvas) {
             mFrame.setBounds(0, 0, getShadowWidth(), getShadowHeight());
             mFrame.draw(canvas);

             Bitmap bitmap = getOneThumbnail();
             if (bitmap != null) {
                 final View view = getView();
                 canvas.drawBitmap(bitmap, view.getPaddingLeft(),
                         view.getPaddingTop(), null);
             }
         }
     }

     /**
      * @return The shadow width
      */
     private int getShadowWidth() {
         final int thumbnailHeight = getHeight() - getPaddingTop() - getPaddingBottom();
         final int thumbnailWidth = (thumbnailHeight * mMediaItem.getWidth()) /
             mMediaItem.getHeight();
         return thumbnailWidth + getPaddingLeft() + getPaddingRight();
     }

     /**
      * @return The shadow height
      */
     private int getShadowHeight() {
         return getHeight();
     }

     private Bitmap getOneThumbnail() {
         ThumbnailKey key = new ThumbnailKey();
         key.mediaItemId = mMediaItem.getId();

         // Find any one cached thumbnail
         for (int i = 0; i < mNumberOfThumbnails; i++) {
             key.index = i;
             Bitmap bitmap = sThumbnailCache.get(key);
             if (bitmap != null) {
                 return bitmap;
             }
         }

         return null;
     }

     /**
      * @param projectPath The project path
      */
     public void setProjectPath(String projectPath) {
         mProjectPath = projectPath;
     }

     /**
      * @param listener The gesture listener
      */
     public void setGestureListener(ItemSimpleGestureListener listener) {
         mGestureListener = listener;
     }

     /**
      * A view enters or exits the playback mode
      *
      * @param playback true if playback is in progress
      */
     public void setPlaybackMode(boolean playback) {
         mIsPlaying = playback;
         invalidate();
     }

     /**
      * Resets the effect generation progress status.
      */
     public void resetGeneratingEffectProgress() {
         setGeneratingEffectProgress(-1);
     }

     /**
      * Sets the effect generation progress of this view.
      */
     public void setGeneratingEffectProgress(int progress) {
         if (progress == 0) {
             mGeneratingEffectProgress = progress;
             // Release the current set of bitmaps. New content is being generated.
             releaseBitmapsAndClear();
         } else if (progress == 100) {
             mGeneratingEffectProgress = -1;
         } else {
             mGeneratingEffectProgress = progress;
         }

         invalidate();
     }

     /**
      * The view has been layout out.
      *
      * @param oldLeft The old left position
      * @param oldRight The old right position
      */
     public void onLayoutPerformed(int oldLeft, int oldRight) {
         // Compute the thumbnail width and height
         mThumbnailHeight = getHeight() - getPaddingTop() - getPaddingBottom();
         mThumbnailWidth = (mThumbnailHeight * mMediaItem.getWidth()) / mMediaItem.getHeight();

         // We are not able to display a bitmap with width or height > 2048.
         while (mThumbnailWidth > 2048 || mThumbnailHeight > 2048) {
             mThumbnailHeight /= 2;
             mThumbnailWidth /= 2;
         }

         int usableWidth = getWidth() - getPaddingLeft() - getPaddingRight();
         // Compute the ceiling of (usableWidth / mThumbnailWidth).
         mNumberOfThumbnails = (usableWidth + mThumbnailWidth - 1) / mThumbnailWidth;
         mBeginTimeMs = mMediaItem.getAppBoundaryBeginTime();
         mEndTimeMs = mMediaItem.getAppBoundaryEndTime();

         releaseBitmapsAndClear();
         invalidate();
     }

     /**
      * @return True if the effect generation is in progress
      */
     public boolean isGeneratingEffect() {
         return (mGeneratingEffectProgress >= 0);
     }

     public boolean setBitmap(Bitmap bitmap, int index, int token) {
         // Ignore results from previous requests
         if (token != mGeneration) {
             return false;
         }
         if (!mPending.contains(index)) {
             Log.e(TAG, "received unasked bitmap, index = " + index);
             return false;
         }
         if (bitmap == null) {
             Log.w(TAG, "receive null bitmap for index = " + index);
             // We keep this request in mPending, so we won't request it again.
             return false;
         }
         mPending.remove(index);
         ThumbnailKey key = new ThumbnailKey(mMediaItem.getId(), index);
         sThumbnailCache.put(key, bitmap);

         invalidate();
         return true;
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         if (mGeneratingEffectProgress >= 0) {
             ProgressBar.getProgressBar(getContext()).draw(
                     canvas, mGeneratingEffectProgress, mGeneratingEffectProgressDestRect,
                     getPaddingLeft(), getWidth() - getPaddingRight());
         } else {
             // Do not draw in the padding area
             canvas.clipRect(getPaddingLeft(), getPaddingTop(),
                     getWidth() - getPaddingRight(),
                     getHeight() - getPaddingBottom());

             // Draw thumbnails
             drawThumbnails(canvas);

             // Draw the "Add transition" indicators
             if (isSelected()) {
                 drawAddTransitionIcons(canvas);
             } else if (mTimeline.hasItemSelected()) {
                 // Dim myself if some view on the timeline is selected but not me
                 // by drawing a transparent black overlay.
                 final Paint paint = new Paint();
                 paint.setColor(Color.BLACK);
                 paint.setAlpha(192);
                 canvas.drawPaint(paint);
             }

             // Request thumbnails if things are not moving
             boolean isBusy = mIsPlaying || mTimeline.isTrimming() || mIsScrolling;
             if (!isBusy && !mWantThumbnails.isEmpty()) {
                 requestThumbnails();
             }
         }
     }

     // Draws the thumbnails, also put unavailable thumbnail indices in
     // mWantThumbnails.
     private void drawThumbnails(Canvas canvas) {
         mWantThumbnails.clear();

         // The screen coordinate of the left edge of the usable area.
         int left = getLeft() + getPaddingLeft() - mScrollX;
         // The screen coordinate of the right edge of the usable area.
         int right = getRight() - getPaddingRight() - mScrollX;
         // Return if the usable area is not on screen.
         if (left >= mScreenWidth || right <= 0 || left >= right) {
             return;
         }

         // Map [0, mScreenWidth - 1] to the indices of the thumbnail.
         int startIdx = (0 - left) / mThumbnailWidth;
         int endIdx = (mScreenWidth - 1 - left) / mThumbnailWidth;

         startIdx = clamp(startIdx, 0, mNumberOfThumbnails - 1);
         endIdx = clamp(endIdx, 0, mNumberOfThumbnails - 1);

         // Prepare variables used in the loop
         ThumbnailKey key = new ThumbnailKey();
         key.mediaItemId = mMediaItem.getId();
         int x = getPaddingLeft() + startIdx * mThumbnailWidth;
         int y = getPaddingTop();

         // Center the thumbnail vertically
         int spacing = (getHeight() - getPaddingTop() - getPaddingBottom() -
                 mThumbnailHeight) / 2;
         y += spacing;

         // Loop through the thumbnails on screen and draw it
         for (int i = startIdx; i <= endIdx; i++) {
             key.index = i;
             Bitmap bitmap = sThumbnailCache.get(key);
             if (bitmap == null) {
                 // Draw a frame placeholder
                 sEmptyFrameDrawable.setBounds(
                         x, y, x + mThumbnailWidth, y + mThumbnailHeight);
                 sEmptyFrameDrawable.draw(canvas);
                 if (!mPending.contains(i)) {
                     mWantThumbnails.add(Integer.valueOf(i));
                 }
             } else {
                 canvas.drawBitmap(bitmap, x, y, null);
             }
             x += mThumbnailWidth;
         }
     }

     /**
      * Draws the "Add transition" icons at the beginning and end of the media item.
      *
      * @param canvas Canvas to be drawn
      */
     private void drawAddTransitionIcons(Canvas canvas) {
         if (hasSpaceForAddTransitionIcons()) {
             if (mMediaItem.getBeginTransition() == null) {
                 sAddTransitionDrawable.setState(mLeftState);
                 sAddTransitionDrawable.setBounds(getPaddingLeft(), getPaddingTop(),
                         sAddTransitionDrawable.getIntrinsicWidth() + getPaddingLeft(),
                         getPaddingTop() + sAddTransitionDrawable.getIntrinsicHeight());
                 sAddTransitionDrawable.draw(canvas);
             }

             if (mMediaItem.getEndTransition() == null) {
                 sAddTransitionDrawable.setState(mRightState);
                 sAddTransitionDrawable.setBounds(
                         getWidth() - getPaddingRight() -
                         sAddTransitionDrawable.getIntrinsicWidth(),
                         getPaddingTop(), getWidth() - getPaddingRight(),
                         getPaddingTop() + sAddTransitionDrawable.getIntrinsicHeight());
                 sAddTransitionDrawable.draw(canvas);
             }
         }
     }

     /**
      * @return true if the visible area of this view is big enough to display
      *      "add transition" icons on both sides; false otherwise.
      */
     private boolean hasSpaceForAddTransitionIcons() {
         if (mTimeline.isTrimming()) {
             return false;
         }

         return (getWidth() - getPaddingLeft() - getPaddingRight() >=
                 2 * sAddTransitionDrawable.getIntrinsicWidth());
     }

     /**
      * Clamps the input value v to the range [low, high].
      */
     private static int clamp(int v, int low, int high) {
         return Math.min(Math.max(v, low), high);
     }

     /**
      * Requests the thumbnails in mWantThumbnails (which is filled by onDraw).
      */
     private void requestThumbnails() {
         // Copy mWantThumbnails to an array
         int indices[] = new int[mWantThumbnails.size()];
         for (int i = 0; i < mWantThumbnails.size(); i++) {
             indices[i] = mWantThumbnails.get(i);
         }

         // Put them in the pending set
         mPending.addAll(mWantThumbnails);

         ApiService.getMediaItemThumbnails(getContext(), mProjectPath,
                 mMediaItem.getId(), mThumbnailWidth, mThumbnailHeight,
                 mBeginTimeMs, mEndTimeMs, mNumberOfThumbnails, mGeneration,
                 indices);
     }

     @Override
     public boolean onTouchEvent(MotionEvent ev) {
         // Let the gesture detector inspect all events.
         mGestureDetector.onTouchEvent(ev);
         super.onTouchEvent(ev);

         switch (ev.getAction()) {
             case MotionEvent.ACTION_DOWN: {
                 mLeftState = View.EMPTY_STATE_SET;
                 mRightState = View.EMPTY_STATE_SET;
                 if (isSelected() && hasSpaceForAddTransitionIcons()) {
                     if (ev.getX() < sAddTransitionDrawable.getIntrinsicWidth() +
                             getPaddingLeft()) {
                         if (mMediaItem.getBeginTransition() == null) {
                             mLeftState = View.PRESSED_WINDOW_FOCUSED_STATE_SET;
                         }
                     } else if (ev.getX() >= getWidth() - getPaddingRight() -
                             sAddTransitionDrawable.getIntrinsicWidth()) {
                         if (mMediaItem.getEndTransition() == null) {
                             mRightState = View.PRESSED_WINDOW_FOCUSED_STATE_SET;
                         }
                     }
                 }
                 invalidate();
                 break;
             }

             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_CANCEL: {
                 mRightState = View.EMPTY_STATE_SET;
                 mLeftState = View.EMPTY_STATE_SET;
                 invalidate();
                 break;
             }

             default: {
                 break;
             }
         }

         return true;
     }

     private void releaseBitmapsAndClear() {
         sThumbnailCache.clearForMediaItemId(mMediaItem.getId());
         mPending.clear();
         mGeneration = sGenerationCounter++;
     }
 }

 class ThumbnailKey {
     public String mediaItemId;
     public int index;

     public ThumbnailKey() {
     }

     public ThumbnailKey(String id, int idx) {
         mediaItemId = id;
         index = idx;
     }

     @Override
     public boolean equals(Object o) {
         if (!(o instanceof ThumbnailKey)) {
             return false;
         }
         ThumbnailKey key = (ThumbnailKey) o;
         return index == key.index && mediaItemId.equals(key.mediaItemId);
     }

     @Override
     public int hashCode() {
         return mediaItemId.hashCode() ^ index;
     }
 }

 class ThumbnailCache {
     private LruCache<ThumbnailKey, Bitmap> mCache;

     public ThumbnailCache(int size) {
         mCache = new LruCache<ThumbnailKey, Bitmap>(size) {
             @Override
             protected int sizeOf(ThumbnailKey key, Bitmap value) {
                 return value.getByteCount();
             }
         };
     }

     void put(ThumbnailKey key, Bitmap value) {
         mCache.put(key, value);
     }

     Bitmap get(ThumbnailKey key) {
         return mCache.get(key);
     }

     void clearForMediaItemId(String id) {
         Map<ThumbnailKey, Bitmap> map = mCache.snapshot();
         for (ThumbnailKey key : map.keySet()) {
             if (key.mediaItemId.equals(id)) {
                 mCache.remove(key);
             }
         }
     }
 }
	/*

	* Copyright (C) 2011 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.widgets;

	import com.android.videoeditor.service.ApiService;
	import com.android.videoeditor.service.MovieMediaItem;
	import com.android.videoeditor.R;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Point;
	import android.graphics.Rect;
	import android.graphics.drawable.Drawable;
	import android.util.AttributeSet;
	import android.util.DisplayMetrics;
	import android.util.Log;
	import android.util.LruCache;
	import android.view.Display;
	import android.view.GestureDetector;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.WindowManager;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Map;

	/**
	* Media item preview view on the timeline. This class assumes the media item is always put on a
	* MediaLinearLayout and is wrapped with a timeline scroll view.
	*/
	public class MediaItemView extends View {
	private static final String TAG = "MediaItemView";

	// Static variables
	private static Drawable sAddTransitionDrawable;
	private static Drawable sEmptyFrameDrawable;
	private static ThumbnailCache sThumbnailCache;

	// Because MediaItemView may be recreated for the same MediaItem (it happens
	// when the device orientation is changed), we use a globally unique
	// generation counter to reject thumbnail results (passed to setBitmap())
	// requested by a previous incarnation of MediaItemView.
	private static int sGenerationCounter;

	// Instance variables
	private final GestureDetector mGestureDetector;
	private final ScrollViewListener mScrollListener;
	private final Rect mGeneratingEffectProgressDestRect;

	private boolean mIsScrolling;
	private boolean mIsPlaying;

	// Progress of generation of the effect applied on this media item view.
	// -1 indicates the generation is not in progress. 0-100 indicates the
	// generation is in progress. Currently only Ken Burns effect is used with
	// the progress bar.
	private int mGeneratingEffectProgress;

	// The scrolled left pixels of this view.
	private int mScrollX;

	private String mProjectPath;
	private MovieMediaItem mMediaItem;
	// Convenient handle to the parent timeline scroll view.
	private TimelineHorizontalScrollView mScrollView;
	// Convenient handle to the parent timeline linear layout.
	private MediaLinearLayout mTimeline;
	private ItemSimpleGestureListener mGestureListener;
	private int[] mLeftState, mRightState;

	private int mScreenWidth;
	private int mThumbnailWidth, mThumbnailHeight;
	private int mNumberOfThumbnails;
	private long mBeginTimeMs, mEndTimeMs;

	private int mGeneration;
	private HashSet<Integer> mPending;
	private ArrayList<Integer> mWantThumbnails;

	public MediaItemView(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public MediaItemView(Context context) {
	this(context, null, 0);
	}

	public MediaItemView(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);

	// Initialize static data
	if (sAddTransitionDrawable == null) {
	sAddTransitionDrawable = getResources().getDrawable(
	R.drawable.add_transition_selector);
	sEmptyFrameDrawable = getResources().getDrawable(
	R.drawable.timeline_loading);

	// Initialize the thumbnail cache, limit the memory usage to 3MB
	sThumbnailCache = new ThumbnailCache(310241024);
	}

	// Get the screen width
	final Display display = ((WindowManager)context.getSystemService(
	Context.WINDOW_SERVICE)).getDefaultDisplay();
	final DisplayMetrics metrics = new DisplayMetrics();
	display.getMetrics(metrics);
	mScreenWidth = metrics.widthPixels;

	// Setup our gesture detector and scroll listener
	mGestureDetector = new GestureDetector(context, new MyGestureListener());
	mScrollListener = new MyScrollViewListener();

	// Prepare the progress bar rectangles
	final ProgressBar progressBar = ProgressBar.getProgressBar(context);
	final int layoutHeight = (int)(
	getResources().getDimension(R.dimen.media_layout_height) -
	getResources().getDimension(R.dimen.media_layout_padding));
	mGeneratingEffectProgressDestRect = new Rect(getPaddingLeft(),
	layoutHeight - progressBar.getHeight() - getPaddingBottom(), 0,
	layoutHeight - getPaddingBottom());

	// Initialize the progress value
	mGeneratingEffectProgress = -1;

	// Initialize the "Add transition" indicators state
	mLeftState = View.EMPTY_STATE_SET;
	mRightState = View.EMPTY_STATE_SET;

	// Initialize the thumbnail indices we want to request
	mWantThumbnails = new ArrayList<Integer>();

	// Initialize the set of indices we are waiting
	mPending = new HashSet<Integer>();

	// Initialize the generation number
	mGeneration = sGenerationCounter++;
	}

	private class MyGestureListener extends GestureDetector.SimpleOnGestureListener {
	@Override
	public boolean onSingleTapConfirmed(MotionEvent e) {
	if (mGestureListener == null) {
	return false;
	}

	int tappedArea = ItemSimpleGestureListener.CENTER_AREA;

	if (hasSpaceForAddTransitionIcons()) {
	if (mMediaItem.getBeginTransition() == null &&
	e.getX() < sAddTransitionDrawable.getIntrinsicWidth() +
	getPaddingLeft()) {
	tappedArea = ItemSimpleGestureListener.LEFT_AREA;
	} else if (mMediaItem.getEndTransition() == null &&
	e.getX() >= getWidth() - getPaddingRight() -
	sAddTransitionDrawable.getIntrinsicWidth()) {
	tappedArea = ItemSimpleGestureListener.RIGHT_AREA;
	}
	}
	return mGestureListener.onSingleTapConfirmed(
	MediaItemView.this, tappedArea, e);
	}

	@Override
	public void onLongPress(MotionEvent e) {
	if (mGestureListener != null) {
	mGestureListener.onLongPress(MediaItemView.this, e);
	}
	}
	}

	private class MyScrollViewListener implements ScrollViewListener {
	@Override
	public void onScrollBegin(View view, int scrollX, int scrollY, boolean appScroll) {
	mIsScrolling = true;
	}

	@Override
	public void onScrollProgress(View view, int scrollX, int scrollY, boolean appScroll) {
	mScrollX = scrollX;
	invalidate();
	}

	@Override
	public void onScrollEnd(View view, int scrollX, int scrollY, boolean appScroll) {
	mIsScrolling = false;
	mScrollX = scrollX;
	invalidate();
	}
	}

	@Override
	protected void onAttachedToWindow() {
	mMediaItem = (MovieMediaItem) getTag();

	mScrollView = (TimelineHorizontalScrollView) getRootView().findViewById(
	R.id.timeline_scroller);
	mScrollView.addScrollListener(mScrollListener);
	// Add the horizontal scroll view listener
	mScrollX = mScrollView.getScrollX();

	mTimeline = (MediaLinearLayout) getRootView().findViewById(R.id.timeline_media);
	}

	@Override
	protected void onDetachedFromWindow() {
	mScrollView.removeScrollListener(mScrollListener);
	// Release the cached bitmaps
	releaseBitmapsAndClear();
	}

	/**
	* @return The shadow builder
	*/
	public DragShadowBuilder getShadowBuilder() {
	return new MediaItemShadowBuilder(this);
	}

	/**
	* Shadow builder for the media item
	*/
	private class MediaItemShadowBuilder extends DragShadowBuilder {
	private final Drawable mFrame;

	public MediaItemShadowBuilder(View view) {
	super(view);
	mFrame = view.getContext().getResources().getDrawable(
	R.drawable.timeline_item_pressed);
	}

	@Override
	public void onProvideShadowMetrics(Point shadowSize, Point shadowTouchPoint) {
	shadowSize.set(getShadowWidth(), getShadowHeight());
	shadowTouchPoint.set(shadowSize.x / 2, shadowSize.y);
	}

	@Override
	public void onDrawShadow(Canvas canvas) {
	mFrame.setBounds(0, 0, getShadowWidth(), getShadowHeight());
	mFrame.draw(canvas);

	Bitmap bitmap = getOneThumbnail();
	if (bitmap != null) {
	final View view = getView();
	canvas.drawBitmap(bitmap, view.getPaddingLeft(),
	view.getPaddingTop(), null);
	}
	}
	}

	/**
	* @return The shadow width
	*/
	private int getShadowWidth() {
	final int thumbnailHeight = getHeight() - getPaddingTop() - getPaddingBottom();
	final int thumbnailWidth = (thumbnailHeight * mMediaItem.getWidth()) /
	mMediaItem.getHeight();
	return thumbnailWidth + getPaddingLeft() + getPaddingRight();
	}

	/**
	* @return The shadow height
	*/
	private int getShadowHeight() {
	return getHeight();
	}

	private Bitmap getOneThumbnail() {
	ThumbnailKey key = new ThumbnailKey();
	key.mediaItemId = mMediaItem.getId();

	// Find any one cached thumbnail
	for (int i = 0; i < mNumberOfThumbnails; i++) {
	key.index = i;
	Bitmap bitmap = sThumbnailCache.get(key);
	if (bitmap != null) {
	return bitmap;
	}
	}

	return null;
	}

	/**
	* @param projectPath The project path
	*/
	public void setProjectPath(String projectPath) {
	mProjectPath = projectPath;
	}

	/**
	* @param listener The gesture listener
	*/
	public void setGestureListener(ItemSimpleGestureListener listener) {
	mGestureListener = listener;
	}

	/**
	* A view enters or exits the playback mode
	*
	* @param playback true if playback is in progress
	*/
	public void setPlaybackMode(boolean playback) {
	mIsPlaying = playback;
	invalidate();
	}

	/**
	* Resets the effect generation progress status.
	*/
	public void resetGeneratingEffectProgress() {
	setGeneratingEffectProgress(-1);
	}

	/**
	* Sets the effect generation progress of this view.
	*/
	public void setGeneratingEffectProgress(int progress) {
	if (progress == 0) {
	mGeneratingEffectProgress = progress;
	// Release the current set of bitmaps. New content is being generated.
	releaseBitmapsAndClear();
	} else if (progress == 100) {
	mGeneratingEffectProgress = -1;
	} else {
	mGeneratingEffectProgress = progress;
	}

	invalidate();
	}

	/**
	* The view has been layout out.
	*
	* @param oldLeft The old left position
	* @param oldRight The old right position
	*/
	public void onLayoutPerformed(int oldLeft, int oldRight) {
	// Compute the thumbnail width and height
	mThumbnailHeight = getHeight() - getPaddingTop() - getPaddingBottom();
	mThumbnailWidth = (mThumbnailHeight * mMediaItem.getWidth()) / mMediaItem.getHeight();

	// We are not able to display a bitmap with width or height > 2048.
	while (mThumbnailWidth > 2048 \|\| mThumbnailHeight > 2048) {
	mThumbnailHeight /= 2;
	mThumbnailWidth /= 2;
	}

	int usableWidth = getWidth() - getPaddingLeft() - getPaddingRight();
	// Compute the ceiling of (usableWidth / mThumbnailWidth).
	mNumberOfThumbnails = (usableWidth + mThumbnailWidth - 1) / mThumbnailWidth;
	mBeginTimeMs = mMediaItem.getAppBoundaryBeginTime();
	mEndTimeMs = mMediaItem.getAppBoundaryEndTime();

	releaseBitmapsAndClear();
	invalidate();
	}

	/**
	* @return True if the effect generation is in progress
	*/
	public boolean isGeneratingEffect() {
	return (mGeneratingEffectProgress >= 0);
	}

	public boolean setBitmap(Bitmap bitmap, int index, int token) {
	// Ignore results from previous requests
	if (token != mGeneration) {
	return false;
	}
	if (!mPending.contains(index)) {
	Log.e(TAG, "received unasked bitmap, index = " + index);
	return false;
	}
	if (bitmap == null) {
	Log.w(TAG, "receive null bitmap for index = " + index);
	// We keep this request in mPending, so we won't request it again.
	return false;
	}
	mPending.remove(index);
	ThumbnailKey key = new ThumbnailKey(mMediaItem.getId(), index);
	sThumbnailCache.put(key, bitmap);

	invalidate();
	return true;
	}

	@Override
	protected void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	if (mGeneratingEffectProgress >= 0) {
	ProgressBar.getProgressBar(getContext()).draw(
	canvas, mGeneratingEffectProgress, mGeneratingEffectProgressDestRect,
	getPaddingLeft(), getWidth() - getPaddingRight());
	} else {
	// Do not draw in the padding area
	canvas.clipRect(getPaddingLeft(), getPaddingTop(),
	getWidth() - getPaddingRight(),
	getHeight() - getPaddingBottom());

	// Draw thumbnails
	drawThumbnails(canvas);

	// Draw the "Add transition" indicators
	if (isSelected()) {
	drawAddTransitionIcons(canvas);
	} else if (mTimeline.hasItemSelected()) {
	// Dim myself if some view on the timeline is selected but not me
	// by drawing a transparent black overlay.
	final Paint paint = new Paint();
	paint.setColor(Color.BLACK);
	paint.setAlpha(192);
	canvas.drawPaint(paint);
	}

	// Request thumbnails if things are not moving
	boolean isBusy = mIsPlaying \|\| mTimeline.isTrimming() \|\| mIsScrolling;
	if (!isBusy && !mWantThumbnails.isEmpty()) {
	requestThumbnails();
	}
	}
	}

	// Draws the thumbnails, also put unavailable thumbnail indices in
	// mWantThumbnails.
	private void drawThumbnails(Canvas canvas) {
	mWantThumbnails.clear();

	// The screen coordinate of the left edge of the usable area.
	int left = getLeft() + getPaddingLeft() - mScrollX;
	// The screen coordinate of the right edge of the usable area.
	int right = getRight() - getPaddingRight() - mScrollX;
	// Return if the usable area is not on screen.
	if (left >= mScreenWidth \|\| right <= 0 \|\| left >= right) {
	return;
	}

	// Map [0, mScreenWidth - 1] to the indices of the thumbnail.
	int startIdx = (0 - left) / mThumbnailWidth;
	int endIdx = (mScreenWidth - 1 - left) / mThumbnailWidth;

	startIdx = clamp(startIdx, 0, mNumberOfThumbnails - 1);
	endIdx = clamp(endIdx, 0, mNumberOfThumbnails - 1);

	// Prepare variables used in the loop
	ThumbnailKey key = new ThumbnailKey();
	key.mediaItemId = mMediaItem.getId();
	int x = getPaddingLeft() + startIdx * mThumbnailWidth;
	int y = getPaddingTop();

	// Center the thumbnail vertically
	int spacing = (getHeight() - getPaddingTop() - getPaddingBottom() -
	mThumbnailHeight) / 2;
	y += spacing;

	// Loop through the thumbnails on screen and draw it
	for (int i = startIdx; i <= endIdx; i++) {
	key.index = i;
	Bitmap bitmap = sThumbnailCache.get(key);
	if (bitmap == null) {
	// Draw a frame placeholder
	sEmptyFrameDrawable.setBounds(
	x, y, x + mThumbnailWidth, y + mThumbnailHeight);
	sEmptyFrameDrawable.draw(canvas);
	if (!mPending.contains(i)) {
	mWantThumbnails.add(Integer.valueOf(i));
	}
	} else {
	canvas.drawBitmap(bitmap, x, y, null);
	}
	x += mThumbnailWidth;
	}
	}

	/**
	* Draws the "Add transition" icons at the beginning and end of the media item.
	*
	* @param canvas Canvas to be drawn
	*/
	private void drawAddTransitionIcons(Canvas canvas) {
	if (hasSpaceForAddTransitionIcons()) {
	if (mMediaItem.getBeginTransition() == null) {
	sAddTransitionDrawable.setState(mLeftState);
	sAddTransitionDrawable.setBounds(getPaddingLeft(), getPaddingTop(),
	sAddTransitionDrawable.getIntrinsicWidth() + getPaddingLeft(),
	getPaddingTop() + sAddTransitionDrawable.getIntrinsicHeight());
	sAddTransitionDrawable.draw(canvas);
	}

	if (mMediaItem.getEndTransition() == null) {
	sAddTransitionDrawable.setState(mRightState);
	sAddTransitionDrawable.setBounds(
	getWidth() - getPaddingRight() -
	sAddTransitionDrawable.getIntrinsicWidth(),
	getPaddingTop(), getWidth() - getPaddingRight(),
	getPaddingTop() + sAddTransitionDrawable.getIntrinsicHeight());
	sAddTransitionDrawable.draw(canvas);
	}
	}
	}

	/**
	* @return true if the visible area of this view is big enough to display
	* "add transition" icons on both sides; false otherwise.
	*/
	private boolean hasSpaceForAddTransitionIcons() {
	if (mTimeline.isTrimming()) {
	return false;
	}

	return (getWidth() - getPaddingLeft() - getPaddingRight() >=
	2 * sAddTransitionDrawable.getIntrinsicWidth());
	}

	/**
	* Clamps the input value v to the range [low, high].
	*/
	private static int clamp(int v, int low, int high) {
	return Math.min(Math.max(v, low), high);
	}

	/**
	* Requests the thumbnails in mWantThumbnails (which is filled by onDraw).
	*/
	private void requestThumbnails() {
	// Copy mWantThumbnails to an array
	int indices[] = new int[mWantThumbnails.size()];
	for (int i = 0; i < mWantThumbnails.size(); i++) {
	indices[i] = mWantThumbnails.get(i);
	}

	// Put them in the pending set
	mPending.addAll(mWantThumbnails);

	ApiService.getMediaItemThumbnails(getContext(), mProjectPath,
	mMediaItem.getId(), mThumbnailWidth, mThumbnailHeight,
	mBeginTimeMs, mEndTimeMs, mNumberOfThumbnails, mGeneration,
	indices);
	}

	@Override
	public boolean onTouchEvent(MotionEvent ev) {
	// Let the gesture detector inspect all events.
	mGestureDetector.onTouchEvent(ev);
	super.onTouchEvent(ev);

	switch (ev.getAction()) {
	case MotionEvent.ACTION_DOWN: {
	mLeftState = View.EMPTY_STATE_SET;
	mRightState = View.EMPTY_STATE_SET;
	if (isSelected() && hasSpaceForAddTransitionIcons()) {
	if (ev.getX() < sAddTransitionDrawable.getIntrinsicWidth() +
	getPaddingLeft()) {
	if (mMediaItem.getBeginTransition() == null) {
	mLeftState = View.PRESSED_WINDOW_FOCUSED_STATE_SET;
	}
	} else if (ev.getX() >= getWidth() - getPaddingRight() -
	sAddTransitionDrawable.getIntrinsicWidth()) {
	if (mMediaItem.getEndTransition() == null) {
	mRightState = View.PRESSED_WINDOW_FOCUSED_STATE_SET;
	}
	}
	}
	invalidate();
	break;
	}

	case MotionEvent.ACTION_UP:
	case MotionEvent.ACTION_CANCEL: {
	mRightState = View.EMPTY_STATE_SET;
	mLeftState = View.EMPTY_STATE_SET;
	invalidate();
	break;
	}

	default: {
	break;
	}
	}

	return true;
	}

	private void releaseBitmapsAndClear() {
	sThumbnailCache.clearForMediaItemId(mMediaItem.getId());
	mPending.clear();
	mGeneration = sGenerationCounter++;
	}
	}

	class ThumbnailKey {
	public String mediaItemId;
	public int index;

	public ThumbnailKey() {
	}

	public ThumbnailKey(String id, int idx) {
	mediaItemId = id;
	index = idx;
	}

	@Override
	public boolean equals(Object o) {
	if (!(o instanceof ThumbnailKey)) {
	return false;
	}
	ThumbnailKey key = (ThumbnailKey) o;
	return index == key.index && mediaItemId.equals(key.mediaItemId);
	}

	@Override
	public int hashCode() {
	return mediaItemId.hashCode() ^ index;
	}
	}

	class ThumbnailCache {
	private LruCache<ThumbnailKey, Bitmap> mCache;

	public ThumbnailCache(int size) {
	mCache = new LruCache<ThumbnailKey, Bitmap>(size) {
	@Override
	protected int sizeOf(ThumbnailKey key, Bitmap value) {
	return value.getByteCount();
	}
	};
	}

	void put(ThumbnailKey key, Bitmap value) {
	mCache.put(key, value);
	}

	Bitmap get(ThumbnailKey key) {
	return mCache.get(key);
	}

	void clearForMediaItemId(String id) {
	Map<ThumbnailKey, Bitmap> map = mCache.snapshot();
	for (ThumbnailKey key : map.keySet()) {
	if (key.mediaItemId.equals(id)) {
	mCache.remove(key);
	}
	}
	}
	}