src/com/android/gallery3d/app/TimeBar.java - platform/packages/apps/Gallery2 - Gitiles

 /*
  * 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.gallery3d.app;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.text.TextUtils;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.MotionEvent;
 import android.view.View;

 import org.codeaurora.gallery.R;
 import com.android.gallery3d.common.Utils;

 import java.util.Locale;

 /**
  * The time bar view, which includes the current and total time, the progress
  * bar, and the scrubber.
  */
 public class TimeBar extends View {

     public interface Listener {
         void onScrubbingStart();

         void onScrubbingMove(int time);

         void onScrubbingEnd(int time, int start, int end);
     }

     // Padding around the scrubber to increase its touch target
     private static final int SCRUBBER_PADDING_IN_DP = 3;

     // The total padding, top plus bottom
     private static final int V_PADDING_IN_DP = 30;

     private static final int TEXT_SIZE_IN_DP = 14;

     private static final String TAG = "Gallery3D/TimeBar";
     private static final boolean LOG = false;
     public static final int UNKNOWN = -1;

     protected final Listener mListener;

     // the bars we use for displaying the progress
     protected final Rect mProgressBar;
     protected final Rect mPlayedBar;

     protected final Paint mProgressPaint;
     protected final Paint mPlayedPaint;
     protected final Paint mTimeTextPaint;

     protected final Bitmap mScrubber;
     protected int mScrubberPadding; // adds some touch tolerance around the
                                     // scrubber

     protected int mScrubberLeft;
     protected int mScrubberTop;
     protected int mScrubberCorrection;
     protected boolean mScrubbing;
     protected boolean mShowTimes;
     protected boolean mShowScrubber;
     private boolean mEnableScrubbing;

     protected int mTotalTime;
     protected int mCurrentTime;

     protected final Rect mTimeBounds;

     protected int mVPaddingInPx;
     private int mLastShowTime = UNKNOWN;

     private ITimeBarSecondaryProgressExt mSecondaryProgressExt = new TimeBarSecondaryProgressExtImpl();
     private ITimeBarInfoExt mInfoExt = new TimeBarInfoExtImpl();
     protected ITimeBarLayoutExt mLayoutExt = new TimeBarLayoutExtImpl();

     public TimeBar(Context context, Listener listener) {
         super(context);
         mListener = Utils.checkNotNull(listener);

         mShowTimes = true;
         mShowScrubber = true;

         mProgressBar = new Rect();
         mPlayedBar = new Rect();

         mProgressPaint = new Paint();
         mProgressPaint.setColor(0xFF808080);
         mPlayedPaint = new Paint();
         mPlayedPaint.setColor(0xFF4F92E9);

         DisplayMetrics metrics = context.getResources().getDisplayMetrics();
         float textSizeInPx = metrics.density * TEXT_SIZE_IN_DP;
         mTimeTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mTimeTextPaint.setColor(0xFFCECECE);
         mTimeTextPaint.setTextSize(textSizeInPx);
         mTimeTextPaint.setTextAlign(Paint.Align.CENTER);

         mTimeBounds = new Rect();
         mTimeTextPaint.getTextBounds("0:00:00", 0, 7, mTimeBounds);

         mScrubber = BitmapFactory.decodeResource(getResources(), R.drawable.scrubber_knob);
         mScrubberPadding = (int) (metrics.density * SCRUBBER_PADDING_IN_DP);

         mVPaddingInPx = (int) (metrics.density * V_PADDING_IN_DP);
         mLayoutExt.init(mScrubberPadding, mVPaddingInPx);
         mInfoExt.init(textSizeInPx);
         mSecondaryProgressExt.init();
     }

     private void update() {
         mPlayedBar.set(mProgressBar);

         if (mTotalTime > 0) {
             if (View.LAYOUT_DIRECTION_RTL == TextUtils
                     .getLayoutDirectionFromLocale(Locale.getDefault())) {
                 // The progress bar should be reversed in RTL.
                 mPlayedBar.left = mPlayedBar.right
                         - (int) ((mProgressBar.width() * (long) mCurrentTime) / mTotalTime);
             } else {
                 mPlayedBar.right = mPlayedBar.left
                         + (int) ((mProgressBar.width() * (long) mCurrentTime) / mTotalTime);
             }
             /*
              * M: if duration is not accurate, here just adjust playedBar we
              * also show the accurate position text to final user.
              */
             if (mPlayedBar.right > mProgressBar.right) {
                 mPlayedBar.right = mProgressBar.right;
             }
         } else {
             if (View.LAYOUT_DIRECTION_RTL == TextUtils
                     .getLayoutDirectionFromLocale(Locale.getDefault())) {
                 // The progress bar should be reversed in RTL.
                 mPlayedBar.left = mProgressBar.right;
             } else {
                 mPlayedBar.right = mProgressBar.left;
             }
         }

         if (!mScrubbing) {
             if (View.LAYOUT_DIRECTION_RTL == TextUtils.getLayoutDirectionFromLocale(
                     Locale.getDefault())) {
                 // The progress bar should be reversed in RTL.
                 mScrubberLeft = mPlayedBar.left - mScrubber.getWidth() / 2;
             } else {
                 mScrubberLeft = mPlayedBar.right - mScrubber.getWidth() / 2;
             }
         }
         // update text bounds when layout changed or time changed
         updateBounds();
         mInfoExt.updateVisibleText(this, mProgressBar, mTimeBounds);
         invalidate();
     }

     /**
      * @return the preferred height of this view, including invisible padding
      */
     public int getPreferredHeight() {
         int preferredHeight = mTimeBounds.height() + mVPaddingInPx + mScrubberPadding;
         return mLayoutExt.getPreferredHeight(preferredHeight, mTimeBounds);
     }

     /**
      * @return the height of the time bar, excluding invisible padding
      */
     public int getBarHeight() {
         int barHeight = mTimeBounds.height() + mVPaddingInPx;
         return mLayoutExt.getBarHeight(barHeight, mTimeBounds);
     }

     public void setTime(int currentTime, int totalTime,
             int trimStartTime, int trimEndTime) {
         if (mCurrentTime == currentTime && mTotalTime == totalTime) {
             return;
         }
         mCurrentTime = currentTime;
         mTotalTime = Math.abs(totalTime);
         if (totalTime <= 0) { /// M: disable scrubbing before mediaplayer ready.
             setScrubbing(false);
         }
         update();
     }

     private boolean inScrubber(float x, float y) {
         int scrubberRight = mScrubberLeft + mScrubber.getWidth();
         int scrubberBottom = mScrubberTop + mScrubber.getHeight();
         return mScrubberLeft - mScrubberPadding < x && x < scrubberRight + mScrubberPadding
                 && mScrubberTop - mScrubberPadding < y && y < scrubberBottom + mScrubberPadding;
     }

     private void clampScrubber() {
         int half = mScrubber.getWidth() / 2;
         int max = mProgressBar.right - half;
         int min = mProgressBar.left - half;
         mScrubberLeft = Math.min(max, Math.max(min, mScrubberLeft));
     }

     private int getScrubberTime() {
         if (View.LAYOUT_DIRECTION_RTL == TextUtils
                 .getLayoutDirectionFromLocale(Locale.getDefault())) {
             // The progress bar's scrubber time should be reversed in RTL.
             return (int) ((long) (mProgressBar.width() - (mScrubberLeft
                     + mScrubber.getWidth() / 2 - mProgressBar.left))
                     * mTotalTime / mProgressBar.width());
         } else {
             return (int) ((long) (mScrubberLeft + mScrubber.getWidth() / 2 - mProgressBar.left)
                     * mTotalTime / mProgressBar.width());
         }
   }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         int w = r - l;
         int h = b - t;
         if (!mShowTimes && !mShowScrubber) {
             mProgressBar.set(0, 0, w, h);
         } else {
             int margin = mScrubber.getWidth() / 3;
             if (mShowTimes) {
                 margin += mTimeBounds.width();
             }
             margin = mLayoutExt.getProgressMargin(margin);
             int progressY = (h + mScrubberPadding) / 2 + mLayoutExt.getProgressOffset(mTimeBounds);
             mScrubberTop = progressY - mScrubber.getHeight() / 2 + 1;
             mProgressBar.set(
                     getPaddingLeft() + margin, progressY,
                     w - getPaddingRight() - margin, progressY + 6);
         }
         update();
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         // draw progress bars
         canvas.drawRect(mProgressBar, mProgressPaint);
         mSecondaryProgressExt.draw(canvas, mProgressBar);
         canvas.drawRect(mPlayedBar, mPlayedPaint);

         // draw scrubber and timers
         if (mShowScrubber) {
             canvas.drawBitmap(mScrubber, mScrubberLeft, mScrubberTop, null);
         }
         if (mShowTimes) {
             if (View.LAYOUT_DIRECTION_RTL == TextUtils
                     .getLayoutDirectionFromLocale(Locale.getDefault())) {
                 // The progress bar's time should be reversed in RTL.
                 canvas.drawText(
                         stringForTime(mCurrentTime),
                         getWidth() - getPaddingRight() - mTimeBounds.width() / 2,
                         mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
                         mTimeTextPaint);
                 canvas.drawText(
                         stringForTime(mTotalTime),
                         mTimeBounds.width() / 2 + getPaddingLeft(),
                         mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
                         mTimeTextPaint);
             } else {
                 canvas.drawText(
                         stringForTime(mCurrentTime),
                         mTimeBounds.width() / 2 + getPaddingLeft(),
                         mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
                         mTimeTextPaint);
                 canvas.drawText(
                         stringForTime(mTotalTime),
                         getWidth() - getPaddingRight() - mTimeBounds.width() / 2,
                         mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
                         mTimeTextPaint);
             }
         }
         mInfoExt.draw(canvas, mLayoutExt.getInfoBounds(this, mTimeBounds));
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         if (LOG) {
             Log.v(TAG, "onTouchEvent() showScrubber=" + mShowScrubber
                     + ", enableScrubbing=" + mEnableScrubbing + ", totalTime="
                     + mTotalTime + ", scrubbing=" + mScrubbing + ", event="
                     + event);
         }
         if (mShowScrubber && mEnableScrubbing) {
             int x = (int) event.getX();
             int y = (int) event.getY();

             switch (event.getAction()) {
                 case MotionEvent.ACTION_DOWN: {
                     mScrubberCorrection = inScrubber(x, y)
                             ? x - mScrubberLeft
                             : mScrubber.getWidth() / 2;
                     mScrubbing = true;
                     mListener.onScrubbingStart();
                 }
                 // fall-through
                 case MotionEvent.ACTION_MOVE: {
                     mScrubberLeft = x - mScrubberCorrection;
                     clampScrubber();
                     mCurrentTime = getScrubberTime();
                     mListener.onScrubbingMove(mCurrentTime);
                     update();
                     invalidate();
                     return true;
                 }
                 case MotionEvent.ACTION_CANCEL:
                 case MotionEvent.ACTION_UP:
                     if (mScrubbing) {
                         mListener.onScrubbingEnd(getScrubberTime(), 0, 0);
                         mScrubbing = false;
                         update();
                         return true;
                     }
                     break;
             }
         }
         return false;
     }

     protected String stringForTime(long millis) {
         int totalSeconds = (int) millis / 1000;
         int seconds = totalSeconds % 60;
         int minutes = (totalSeconds / 60) % 60;
         int hours = totalSeconds / 3600;
         if (hours > 0) {
             return String.format("%d:%02d:%02d", hours, minutes, seconds).toString();
         } else {
             return String.format("%02d:%02d", minutes, seconds).toString();
         }
     }

     public void setSeekable(boolean canSeek) {
         mShowScrubber = canSeek;
     }

     private void updateBounds() {
         int showTime = mTotalTime > mCurrentTime ? mTotalTime : mCurrentTime;
         if (mLastShowTime == showTime) {
             // do not need to recompute the bounds.
             return;
         }
         String durationText = stringForTime(showTime);
         int length = durationText.length();
         mTimeTextPaint.getTextBounds(durationText, 0, length, mTimeBounds);
         mLastShowTime = showTime;
         if (LOG) {
             Log.v(TAG, "updateBounds() durationText=" + durationText + ", timeBounds="
                     + mTimeBounds);
         }
     }

     public void setScrubbing(boolean enable) {
         if (LOG) {
             Log.v(TAG, "setScrubbing(" + enable + ") scrubbing=" + mScrubbing);
         }
         mEnableScrubbing = enable;
         if (mScrubbing) { // if it is scrubbing, change it to false
             mListener.onScrubbingEnd(getScrubberTime(), 0, 0);
             mScrubbing = false;
         }
     }

     public boolean getScrubbing() {
         if (LOG) {
             Log.v(TAG, "mEnableScrubbing=" + mEnableScrubbing);
         }
         return mEnableScrubbing;
     }

     public void setInfo(String info) {
         if (LOG) {
             Log.v(TAG, "setInfo(" + info + ")");
         }
         mInfoExt.setInfo(info);
         mInfoExt.updateVisibleText(this, mProgressBar, mTimeBounds);
         invalidate();
     }

     public void setSecondaryProgress(int percent) {
         if (LOG) {
             Log.v(TAG, "setSecondaryProgress(" + percent + ")");
         }
         mSecondaryProgressExt.setSecondaryProgress(mProgressBar, percent);
         invalidate();
     }
 }

 interface ITimeBarInfoExt {
     void init(float textSizeInPx);

     void setInfo(String info);

     void draw(Canvas canvas, Rect infoBounds);

     void updateVisibleText(View parent, Rect progressBar, Rect timeBounds);
 }

 interface ITimeBarSecondaryProgressExt {
     void init();

     void setSecondaryProgress(Rect progressBar, int percent);

     void draw(Canvas canvas, Rect progressBounds);
 }

 interface ITimeBarLayoutExt {
     void init(int scrubberPadding, int vPaddingInPx);

     int getPreferredHeight(int originalPreferredHeight, Rect timeBounds);

     int getBarHeight(int originalBarHeight, Rect timeBounds);

     int getProgressMargin(int originalMargin);

     int getProgressOffset(Rect timeBounds);

     int getTimeOffset();

     Rect getInfoBounds(View parent, Rect timeBounds);
 }

 class TimeBarInfoExtImpl implements ITimeBarInfoExt {
     private static final String TAG = "TimeBarInfoExtensionImpl";
     private static final boolean LOG = false;
     private static final String ELLIPSE = "...";

     private Paint mInfoPaint;
     private Rect mInfoBounds;
     private String mInfoText;
     private String mVisibleText;
     private int mEllipseLength;

     @Override
     public void init(float textSizeInPx) {
         mInfoPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
         mInfoPaint.setColor(0xFFCECECE);
         mInfoPaint.setTextSize(textSizeInPx);
         mInfoPaint.setTextAlign(Paint.Align.CENTER);

         mEllipseLength = (int) Math.ceil(mInfoPaint.measureText(ELLIPSE));
     }

     @Override
     public void draw(Canvas canvas, Rect infoBounds) {
         if (mInfoText != null && mVisibleText != null) {
             canvas.drawText(mVisibleText, infoBounds.centerX(), infoBounds.centerY(), mInfoPaint);
         }
     }

     @Override
     public void setInfo(String info) {
         mInfoText = info;
     }

     public void updateVisibleText(View parent, Rect progressBar, Rect timeBounds) {
         if (mInfoText == null) {
             mVisibleText = null;
             return;
         }
         float tw = mInfoPaint.measureText(mInfoText);
         float space = progressBar.width() - timeBounds.width() * 2 - parent.getPaddingLeft()
                 - parent.getPaddingRight();
         if (tw > 0 && space > 0 && tw > space) {
             // we need to cut the info text for visible
             float originalNum = mInfoText.length();
             int realNum = (int) ((space - mEllipseLength) * originalNum / tw);
             if (LOG) {
                 Log.v(TAG, "updateVisibleText() infoText=" + mInfoText + " text width=" + tw
                         + ", space=" + space + ", originalNum=" + originalNum + ", realNum="
                         + realNum
                         + ", getPaddingLeft()=" + parent.getPaddingLeft() + ", getPaddingRight()="
                         + parent.getPaddingRight()
                         + ", progressBar=" + progressBar + ", timeBounds=" + timeBounds);
             }
             mVisibleText = mInfoText.substring(0, realNum) + ELLIPSE;
         } else {
             mVisibleText = mInfoText;
         }
         if (LOG) {
             Log.v(TAG, "updateVisibleText() infoText=" + mInfoText + ", visibleText="
                     + mVisibleText
                     + ", text width=" + tw + ", space=" + space);
         }
     }
 }

 class TimeBarSecondaryProgressExtImpl implements ITimeBarSecondaryProgressExt {
     private static final String TAG = "TimeBarSecondaryProgressExtensionImpl";
     private static final boolean LOG = false;

     private int mBufferPercent;
     private Rect mSecondaryBar;
     private Paint mSecondaryPaint;

     @Override
     public void init() {
         mSecondaryBar = new Rect();
         mSecondaryPaint = new Paint();
         mSecondaryPaint.setColor(0xFF5CA0C5);
     }

     @Override
     public void draw(Canvas canvas, Rect progressBounds) {
         if (mBufferPercent >= 0) {
             mSecondaryBar.set(progressBounds);
             mSecondaryBar.right = mSecondaryBar.left
                     + (int) (mBufferPercent * progressBounds.width() / 100);
             canvas.drawRect(mSecondaryBar, mSecondaryPaint);
         }
         if (LOG) {
             Log.v(TAG, "draw() bufferPercent=" + mBufferPercent + ", secondaryBar="
                     + mSecondaryBar);
         }
     }

     @Override
     public void setSecondaryProgress(Rect progressBar, int percent) {
         mBufferPercent = percent;
     }
 }

 class TimeBarLayoutExtImpl implements ITimeBarLayoutExt {
     private static final String TAG = "TimeBarLayoutExtensionImpl";
     private static final boolean LOG = false;

     private int mTextPadding;
     private int mVPaddingInPx;

     @Override
     public void init(int scrubberPadding, int vPaddingInPx) {
         mTextPadding = scrubberPadding / 2;
         mVPaddingInPx = vPaddingInPx;
     }

     @Override
     public int getPreferredHeight(int originalPreferredHeight, Rect timeBounds) {
         return originalPreferredHeight + timeBounds.height() + mTextPadding;
     }

     @Override
     public int getBarHeight(int originalBarHeight, Rect timeBounds) {
         return originalBarHeight + timeBounds.height() + mTextPadding;
     }

     @Override
     public int getProgressMargin(int originalMargin) {
         return 0;
     }

     @Override
     public int getProgressOffset(Rect timeBounds) {
         return (timeBounds.height() + mTextPadding) / 2;
     }

     @Override
     public int getTimeOffset() {
         return mTextPadding - mVPaddingInPx / 2;
     }

     @Override
     public Rect getInfoBounds(View parent, Rect timeBounds) {
         Rect bounds = new Rect(parent.getPaddingLeft(), 0,
                 parent.getWidth() - parent.getPaddingRight(),
                 (timeBounds.height() + mTextPadding * 3 + 1) * 2);
         return bounds;
     }
 }
	/*
	* 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.gallery3d.app;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Canvas;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.text.TextUtils;
	import android.util.DisplayMetrics;
	import android.util.Log;
	import android.view.MotionEvent;
	import android.view.View;

	import org.codeaurora.gallery.R;
	import com.android.gallery3d.common.Utils;

	import java.util.Locale;

	/**
	* The time bar view, which includes the current and total time, the progress
	* bar, and the scrubber.
	*/
	public class TimeBar extends View {

	public interface Listener {
	void onScrubbingStart();

	void onScrubbingMove(int time);

	void onScrubbingEnd(int time, int start, int end);
	}

	// Padding around the scrubber to increase its touch target
	private static final int SCRUBBER_PADDING_IN_DP = 3;

	// The total padding, top plus bottom
	private static final int V_PADDING_IN_DP = 30;

	private static final int TEXT_SIZE_IN_DP = 14;

	private static final String TAG = "Gallery3D/TimeBar";
	private static final boolean LOG = false;
	public static final int UNKNOWN = -1;

	protected final Listener mListener;

	// the bars we use for displaying the progress
	protected final Rect mProgressBar;
	protected final Rect mPlayedBar;

	protected final Paint mProgressPaint;
	protected final Paint mPlayedPaint;
	protected final Paint mTimeTextPaint;

	protected final Bitmap mScrubber;
	protected int mScrubberPadding; // adds some touch tolerance around the
	// scrubber

	protected int mScrubberLeft;
	protected int mScrubberTop;
	protected int mScrubberCorrection;
	protected boolean mScrubbing;
	protected boolean mShowTimes;
	protected boolean mShowScrubber;
	private boolean mEnableScrubbing;

	protected int mTotalTime;
	protected int mCurrentTime;

	protected final Rect mTimeBounds;

	protected int mVPaddingInPx;
	private int mLastShowTime = UNKNOWN;

	private ITimeBarSecondaryProgressExt mSecondaryProgressExt = new TimeBarSecondaryProgressExtImpl();
	private ITimeBarInfoExt mInfoExt = new TimeBarInfoExtImpl();
	protected ITimeBarLayoutExt mLayoutExt = new TimeBarLayoutExtImpl();

	public TimeBar(Context context, Listener listener) {
	super(context);
	mListener = Utils.checkNotNull(listener);

	mShowTimes = true;
	mShowScrubber = true;

	mProgressBar = new Rect();
	mPlayedBar = new Rect();

	mProgressPaint = new Paint();
	mProgressPaint.setColor(0xFF808080);
	mPlayedPaint = new Paint();
	mPlayedPaint.setColor(0xFF4F92E9);

	DisplayMetrics metrics = context.getResources().getDisplayMetrics();
	float textSizeInPx = metrics.density * TEXT_SIZE_IN_DP;
	mTimeTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mTimeTextPaint.setColor(0xFFCECECE);
	mTimeTextPaint.setTextSize(textSizeInPx);
	mTimeTextPaint.setTextAlign(Paint.Align.CENTER);

	mTimeBounds = new Rect();
	mTimeTextPaint.getTextBounds("0:00:00", 0, 7, mTimeBounds);

	mScrubber = BitmapFactory.decodeResource(getResources(), R.drawable.scrubber_knob);
	mScrubberPadding = (int) (metrics.density * SCRUBBER_PADDING_IN_DP);

	mVPaddingInPx = (int) (metrics.density * V_PADDING_IN_DP);
	mLayoutExt.init(mScrubberPadding, mVPaddingInPx);
	mInfoExt.init(textSizeInPx);
	mSecondaryProgressExt.init();
	}

	private void update() {
	mPlayedBar.set(mProgressBar);

	if (mTotalTime > 0) {
	if (View.LAYOUT_DIRECTION_RTL == TextUtils
	.getLayoutDirectionFromLocale(Locale.getDefault())) {
	// The progress bar should be reversed in RTL.
	mPlayedBar.left = mPlayedBar.right
	- (int) ((mProgressBar.width() * (long) mCurrentTime) / mTotalTime);
	} else {
	mPlayedBar.right = mPlayedBar.left
	+ (int) ((mProgressBar.width() * (long) mCurrentTime) / mTotalTime);
	}
	/*
	* M: if duration is not accurate, here just adjust playedBar we
	* also show the accurate position text to final user.
	*/
	if (mPlayedBar.right > mProgressBar.right) {
	mPlayedBar.right = mProgressBar.right;
	}
	} else {
	if (View.LAYOUT_DIRECTION_RTL == TextUtils
	.getLayoutDirectionFromLocale(Locale.getDefault())) {
	// The progress bar should be reversed in RTL.
	mPlayedBar.left = mProgressBar.right;
	} else {
	mPlayedBar.right = mProgressBar.left;
	}
	}

	if (!mScrubbing) {
	if (View.LAYOUT_DIRECTION_RTL == TextUtils.getLayoutDirectionFromLocale(
	Locale.getDefault())) {
	// The progress bar should be reversed in RTL.
	mScrubberLeft = mPlayedBar.left - mScrubber.getWidth() / 2;
	} else {
	mScrubberLeft = mPlayedBar.right - mScrubber.getWidth() / 2;
	}
	}
	// update text bounds when layout changed or time changed
	updateBounds();
	mInfoExt.updateVisibleText(this, mProgressBar, mTimeBounds);
	invalidate();
	}

	/**
	* @return the preferred height of this view, including invisible padding
	*/
	public int getPreferredHeight() {
	int preferredHeight = mTimeBounds.height() + mVPaddingInPx + mScrubberPadding;
	return mLayoutExt.getPreferredHeight(preferredHeight, mTimeBounds);
	}

	/**
	* @return the height of the time bar, excluding invisible padding
	*/
	public int getBarHeight() {
	int barHeight = mTimeBounds.height() + mVPaddingInPx;
	return mLayoutExt.getBarHeight(barHeight, mTimeBounds);
	}

	public void setTime(int currentTime, int totalTime,
	int trimStartTime, int trimEndTime) {
	if (mCurrentTime == currentTime && mTotalTime == totalTime) {
	return;
	}
	mCurrentTime = currentTime;
	mTotalTime = Math.abs(totalTime);
	if (totalTime <= 0) { /// M: disable scrubbing before mediaplayer ready.
	setScrubbing(false);
	}
	update();
	}

	private boolean inScrubber(float x, float y) {
	int scrubberRight = mScrubberLeft + mScrubber.getWidth();
	int scrubberBottom = mScrubberTop + mScrubber.getHeight();
	return mScrubberLeft - mScrubberPadding < x && x < scrubberRight + mScrubberPadding
	&& mScrubberTop - mScrubberPadding < y && y < scrubberBottom + mScrubberPadding;
	}

	private void clampScrubber() {
	int half = mScrubber.getWidth() / 2;
	int max = mProgressBar.right - half;
	int min = mProgressBar.left - half;
	mScrubberLeft = Math.min(max, Math.max(min, mScrubberLeft));
	}

	private int getScrubberTime() {
	if (View.LAYOUT_DIRECTION_RTL == TextUtils
	.getLayoutDirectionFromLocale(Locale.getDefault())) {
	// The progress bar's scrubber time should be reversed in RTL.
	return (int) ((long) (mProgressBar.width() - (mScrubberLeft
	+ mScrubber.getWidth() / 2 - mProgressBar.left))
	* mTotalTime / mProgressBar.width());
	} else {
	return (int) ((long) (mScrubberLeft + mScrubber.getWidth() / 2 - mProgressBar.left)
	* mTotalTime / mProgressBar.width());
	}
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	int w = r - l;
	int h = b - t;
	if (!mShowTimes && !mShowScrubber) {
	mProgressBar.set(0, 0, w, h);
	} else {
	int margin = mScrubber.getWidth() / 3;
	if (mShowTimes) {
	margin += mTimeBounds.width();
	}
	margin = mLayoutExt.getProgressMargin(margin);
	int progressY = (h + mScrubberPadding) / 2 + mLayoutExt.getProgressOffset(mTimeBounds);
	mScrubberTop = progressY - mScrubber.getHeight() / 2 + 1;
	mProgressBar.set(
	getPaddingLeft() + margin, progressY,
	w - getPaddingRight() - margin, progressY + 6);
	}
	update();
	}

	@Override
	protected void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	// draw progress bars
	canvas.drawRect(mProgressBar, mProgressPaint);
	mSecondaryProgressExt.draw(canvas, mProgressBar);
	canvas.drawRect(mPlayedBar, mPlayedPaint);

	// draw scrubber and timers
	if (mShowScrubber) {
	canvas.drawBitmap(mScrubber, mScrubberLeft, mScrubberTop, null);
	}
	if (mShowTimes) {
	if (View.LAYOUT_DIRECTION_RTL == TextUtils
	.getLayoutDirectionFromLocale(Locale.getDefault())) {
	// The progress bar's time should be reversed in RTL.
	canvas.drawText(
	stringForTime(mCurrentTime),
	getWidth() - getPaddingRight() - mTimeBounds.width() / 2,
	mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
	mTimeTextPaint);
	canvas.drawText(
	stringForTime(mTotalTime),
	mTimeBounds.width() / 2 + getPaddingLeft(),
	mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
	mTimeTextPaint);
	} else {
	canvas.drawText(
	stringForTime(mCurrentTime),
	mTimeBounds.width() / 2 + getPaddingLeft(),
	mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
	mTimeTextPaint);
	canvas.drawText(
	stringForTime(mTotalTime),
	getWidth() - getPaddingRight() - mTimeBounds.width() / 2,
	mTimeBounds.height() + mVPaddingInPx / 2 + mScrubberPadding + 1,
	mTimeTextPaint);
	}
	}
	mInfoExt.draw(canvas, mLayoutExt.getInfoBounds(this, mTimeBounds));
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
	if (LOG) {
	Log.v(TAG, "onTouchEvent() showScrubber=" + mShowScrubber
	+ ", enableScrubbing=" + mEnableScrubbing + ", totalTime="
	+ mTotalTime + ", scrubbing=" + mScrubbing + ", event="
	+ event);
	}
	if (mShowScrubber && mEnableScrubbing) {
	int x = (int) event.getX();
	int y = (int) event.getY();

	switch (event.getAction()) {
	case MotionEvent.ACTION_DOWN: {
	mScrubberCorrection = inScrubber(x, y)
	? x - mScrubberLeft
	: mScrubber.getWidth() / 2;
	mScrubbing = true;
	mListener.onScrubbingStart();
	}
	// fall-through
	case MotionEvent.ACTION_MOVE: {
	mScrubberLeft = x - mScrubberCorrection;
	clampScrubber();
	mCurrentTime = getScrubberTime();
	mListener.onScrubbingMove(mCurrentTime);
	update();
	invalidate();
	return true;
	}
	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	if (mScrubbing) {
	mListener.onScrubbingEnd(getScrubberTime(), 0, 0);
	mScrubbing = false;
	update();
	return true;
	}
	break;
	}
	}
	return false;
	}

	protected String stringForTime(long millis) {
	int totalSeconds = (int) millis / 1000;
	int seconds = totalSeconds % 60;
	int minutes = (totalSeconds / 60) % 60;
	int hours = totalSeconds / 3600;
	if (hours > 0) {
	return String.format("%d:%02d:%02d", hours, minutes, seconds).toString();
	} else {
	return String.format("%02d:%02d", minutes, seconds).toString();
	}
	}

	public void setSeekable(boolean canSeek) {
	mShowScrubber = canSeek;
	}

	private void updateBounds() {
	int showTime = mTotalTime > mCurrentTime ? mTotalTime : mCurrentTime;
	if (mLastShowTime == showTime) {
	// do not need to recompute the bounds.
	return;
	}
	String durationText = stringForTime(showTime);
	int length = durationText.length();
	mTimeTextPaint.getTextBounds(durationText, 0, length, mTimeBounds);
	mLastShowTime = showTime;
	if (LOG) {
	Log.v(TAG, "updateBounds() durationText=" + durationText + ", timeBounds="
	+ mTimeBounds);
	}
	}

	public void setScrubbing(boolean enable) {
	if (LOG) {
	Log.v(TAG, "setScrubbing(" + enable + ") scrubbing=" + mScrubbing);
	}
	mEnableScrubbing = enable;
	if (mScrubbing) { // if it is scrubbing, change it to false
	mListener.onScrubbingEnd(getScrubberTime(), 0, 0);
	mScrubbing = false;
	}
	}

	public boolean getScrubbing() {
	if (LOG) {
	Log.v(TAG, "mEnableScrubbing=" + mEnableScrubbing);
	}
	return mEnableScrubbing;
	}

	public void setInfo(String info) {
	if (LOG) {
	Log.v(TAG, "setInfo(" + info + ")");
	}
	mInfoExt.setInfo(info);
	mInfoExt.updateVisibleText(this, mProgressBar, mTimeBounds);
	invalidate();
	}

	public void setSecondaryProgress(int percent) {
	if (LOG) {
	Log.v(TAG, "setSecondaryProgress(" + percent + ")");
	}
	mSecondaryProgressExt.setSecondaryProgress(mProgressBar, percent);
	invalidate();
	}
	}

	interface ITimeBarInfoExt {
	void init(float textSizeInPx);

	void setInfo(String info);

	void draw(Canvas canvas, Rect infoBounds);

	void updateVisibleText(View parent, Rect progressBar, Rect timeBounds);
	}

	interface ITimeBarSecondaryProgressExt {
	void init();

	void setSecondaryProgress(Rect progressBar, int percent);

	void draw(Canvas canvas, Rect progressBounds);
	}

	interface ITimeBarLayoutExt {
	void init(int scrubberPadding, int vPaddingInPx);

	int getPreferredHeight(int originalPreferredHeight, Rect timeBounds);

	int getBarHeight(int originalBarHeight, Rect timeBounds);

	int getProgressMargin(int originalMargin);

	int getProgressOffset(Rect timeBounds);

	int getTimeOffset();

	Rect getInfoBounds(View parent, Rect timeBounds);
	}

	class TimeBarInfoExtImpl implements ITimeBarInfoExt {
	private static final String TAG = "TimeBarInfoExtensionImpl";
	private static final boolean LOG = false;
	private static final String ELLIPSE = "...";

	private Paint mInfoPaint;
	private Rect mInfoBounds;
	private String mInfoText;
	private String mVisibleText;
	private int mEllipseLength;

	@Override
	public void init(float textSizeInPx) {
	mInfoPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
	mInfoPaint.setColor(0xFFCECECE);
	mInfoPaint.setTextSize(textSizeInPx);
	mInfoPaint.setTextAlign(Paint.Align.CENTER);

	mEllipseLength = (int) Math.ceil(mInfoPaint.measureText(ELLIPSE));
	}

	@Override
	public void draw(Canvas canvas, Rect infoBounds) {
	if (mInfoText != null && mVisibleText != null) {
	canvas.drawText(mVisibleText, infoBounds.centerX(), infoBounds.centerY(), mInfoPaint);
	}
	}

	@Override
	public void setInfo(String info) {
	mInfoText = info;
	}

	public void updateVisibleText(View parent, Rect progressBar, Rect timeBounds) {
	if (mInfoText == null) {
	mVisibleText = null;
	return;
	}
	float tw = mInfoPaint.measureText(mInfoText);
	float space = progressBar.width() - timeBounds.width() * 2 - parent.getPaddingLeft()
	- parent.getPaddingRight();
	if (tw > 0 && space > 0 && tw > space) {
	// we need to cut the info text for visible
	float originalNum = mInfoText.length();
	int realNum = (int) ((space - mEllipseLength) * originalNum / tw);
	if (LOG) {
	Log.v(TAG, "updateVisibleText() infoText=" + mInfoText + " text width=" + tw
	+ ", space=" + space + ", originalNum=" + originalNum + ", realNum="
	+ realNum
	+ ", getPaddingLeft()=" + parent.getPaddingLeft() + ", getPaddingRight()="
	+ parent.getPaddingRight()
	+ ", progressBar=" + progressBar + ", timeBounds=" + timeBounds);
	}
	mVisibleText = mInfoText.substring(0, realNum) + ELLIPSE;
	} else {
	mVisibleText = mInfoText;
	}
	if (LOG) {
	Log.v(TAG, "updateVisibleText() infoText=" + mInfoText + ", visibleText="
	+ mVisibleText
	+ ", text width=" + tw + ", space=" + space);
	}
	}
	}

	class TimeBarSecondaryProgressExtImpl implements ITimeBarSecondaryProgressExt {
	private static final String TAG = "TimeBarSecondaryProgressExtensionImpl";
	private static final boolean LOG = false;

	private int mBufferPercent;
	private Rect mSecondaryBar;
	private Paint mSecondaryPaint;

	@Override
	public void init() {
	mSecondaryBar = new Rect();
	mSecondaryPaint = new Paint();
	mSecondaryPaint.setColor(0xFF5CA0C5);
	}

	@Override
	public void draw(Canvas canvas, Rect progressBounds) {
	if (mBufferPercent >= 0) {
	mSecondaryBar.set(progressBounds);
	mSecondaryBar.right = mSecondaryBar.left
	+ (int) (mBufferPercent * progressBounds.width() / 100);
	canvas.drawRect(mSecondaryBar, mSecondaryPaint);
	}
	if (LOG) {
	Log.v(TAG, "draw() bufferPercent=" + mBufferPercent + ", secondaryBar="
	+ mSecondaryBar);
	}
	}

	@Override
	public void setSecondaryProgress(Rect progressBar, int percent) {
	mBufferPercent = percent;
	}
	}

	class TimeBarLayoutExtImpl implements ITimeBarLayoutExt {
	private static final String TAG = "TimeBarLayoutExtensionImpl";
	private static final boolean LOG = false;

	private int mTextPadding;
	private int mVPaddingInPx;

	@Override
	public void init(int scrubberPadding, int vPaddingInPx) {
	mTextPadding = scrubberPadding / 2;
	mVPaddingInPx = vPaddingInPx;
	}

	@Override
	public int getPreferredHeight(int originalPreferredHeight, Rect timeBounds) {
	return originalPreferredHeight + timeBounds.height() + mTextPadding;
	}

	@Override
	public int getBarHeight(int originalBarHeight, Rect timeBounds) {
	return originalBarHeight + timeBounds.height() + mTextPadding;
	}

	@Override
	public int getProgressMargin(int originalMargin) {
	return 0;
	}

	@Override
	public int getProgressOffset(Rect timeBounds) {
	return (timeBounds.height() + mTextPadding) / 2;
	}

	@Override
	public int getTimeOffset() {
	return mTextPadding - mVPaddingInPx / 2;
	}

	@Override
	public Rect getInfoBounds(View parent, Rect timeBounds) {
	Rect bounds = new Rect(parent.getPaddingLeft(), 0,
	parent.getWidth() - parent.getPaddingRight(),
	(timeBounds.height() + mTextPadding * 3 + 1) * 2);
	return bounds;
	}
	}