package com.havenliu.progressdemo;
 
import android.app.Activity;
import android.os.Bundle;
import android.view.Display;
import android.view.Window;
import android.view.WindowManager;
/**
 *
 * http://www.havenliu.com/other/689.html
 * @author HavenLiu 
 *
 */
public class Main extends Activity {
	public static int screen_width;// 屏幕的宽度
	public static int screen_height;// 屏幕的高度
	//图片资源根据游戏屏幕的缩放比例
	public static float zoomRate;
	public static boolean isRun;
 
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// 全屏显示窗口
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
		isRun = true;
 
		Display display = getWindowManager().getDefaultDisplay();
 
		screen_width = display.getWidth();
		screen_height = display.getHeight();
		zoomRate = getZoomRate();
		setContentView(new MyView(this));
	}
 
	/**
	 * 计算图片的缩放比例，这要是为了让图片能自适应屏幕大小
	 * 
	 * @return
	 */
	private float getZoomRate() {
		float rate = 1f;
		float rate_width = screen_width / 44f;// 图片资源的宽度为44px
		float rate_height = screen_height / 547f;// 图片资源的高度为547px
		rate = Math.min(rate_width, rate_height);
		return rate;
	}
 
	@Override
	protected void onDestroy() {
		super.onDestroy();
		isRun = false;
	}
}

package com.havenliu.progressdemo;
 
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.view.View;
 
/**
 * 自定义View，也可以用SurfaceView代替
 * http://www.havenliu.com/other/689.html
 * @author HavenLiu 
 *
 *
 */
public class MyView extends View implements Runnable {
	// 游戏总时间，单位：秒
	public static final int TOTALTIME = 30;
	// 刷新频率：毫秒
	public static final int REFRESH = 30;
	private Bitmap img_progress;
	private Bitmap img_progress_bg;
	// 屏幕每次刷新，progressBar应减去的长度
	private float step;
	private Paint paint;
	// progressBar的中长度
	private float progress;
 
	public MyView(Context context) {
		super(context);
		paint = new Paint();
		paint.setDither(true);
 
		initBitmap();
		initProgress();
		new Thread(this).start();
	}
 
	/**
	 * 预加载图片图片资源，并根据屏幕大小等比缩放
	 */
	private void initBitmap() {
		Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.timebar);
		Matrix matrix = new Matrix();
		matrix.postScale(Main.zoomRate, Main.zoomRate);
		img_progress = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 
		Bitmap bitmap_bg = BitmapFactory.decodeResource(getResources(), R.drawable.timebar_bg);
		img_progress_bg = Bitmap.createBitmap(bitmap_bg, 0, 0, bitmap_bg.getWidth(), bitmap_bg.getHeight(), matrix, true);
	}
 
	/**
	 * 初始化progressBar相关参数
	 */
	private void initProgress() {
		int _totalTime = TOTALTIME * 1000;
		int refreshTimes = _totalTime / REFRESH;
		progress = 547.0f * Main.zoomRate;
		step = progress / refreshTimes;// 547为滚动条的高度
	}
 
	@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		canvas.drawARGB(255, 157, 157, 157);
		// 居中
		canvas.drawBitmap(img_progress, Main.screen_width / 2 - img_progress.getWidth() / 2, 0, null);// 背景条：蓝色
 
		int rc = canvas.saveLayer(Main.screen_width / 2 - img_progress.getWidth() / 2, img_progress.getHeight() - progress, Main.screen_width / 2 + img_progress.getWidth() / 2,
				img_progress.getHeight(), null, Canvas.ALL_SAVE_FLAG);
		paint.setFilterBitmap(false);
		canvas.drawRect(Main.screen_width / 2 - img_progress.getWidth() / 2, 0, Main.screen_width / 2 + img_progress.getWidth() / 2, img_progress.getHeight(), paint);
		//Xfermode的类型很重要，不同的Mode有不同的效果。具体可以参考后面的图片
		paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
		canvas.drawBitmap(img_progress_bg, Main.screen_width / 2 - img_progress.getWidth() / 2, 0, paint);
		paint.setXfermode(null);
		canvas.restoreToCount(rc);
	}
 
	@Override
	public void run() {
		while (Main.isRun) {
			postInvalidate();
			if (progress <= 0) {
				// Game Over.....
				// do something......
//				Log.i("", "Game over.........you lost!");
			} else {
				progress -= step;
			}
			try {
				Thread.sleep(REFRESH);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
 
}

/**
 * MyGallery.java
 * @version 1.0
 * @author Haven http://www.havenliu.com
 * @createTime 2011-12-9 下午03:42:53
 * android.widget.Gallery的子函数。此类很重要。建议仔细看
 */
package com.havenliu.demo;
 
import android.content.Context;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.widget.Gallery;
 
public class MyGallery extends Gallery {
	private GestureDetector gestureScanner;
	private MyImageView imageView;
 
	public MyGallery(Context context) {
		super(context);
 
	}
 
	public MyGallery(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
	}
 
	public MyGallery(Context context, AttributeSet attrs) {
		super(context, attrs);
 
		gestureScanner = new GestureDetector(new MySimpleGesture());
		this.setOnTouchListener(new OnTouchListener() {
 
			float baseValue;
			float originalScale;
 
			@Override
			public boolean onTouch(View v, MotionEvent event) {
				View view = MyGallery.this.getSelectedView();
				if (view instanceof MyImageView) {
					imageView = (MyImageView) view;
 
					if (event.getAction() == MotionEvent.ACTION_DOWN) {
						baseValue = 0;
						originalScale = imageView.getScale();
					}
					if (event.getAction() == MotionEvent.ACTION_MOVE) {
						if (event.getPointerCount() == 2) {
							float x = event.getX(0) - event.getX(1);
							float y = event.getY(0) - event.getY(1);
							float value = (float) Math.sqrt(x * x + y * y);// 计算两点的距离
							// System.out.println("value:" + value);
							if (baseValue == 0) {
								baseValue = value;
							} else {
								float scale = value / baseValue;// 当前两点间的距离除以手指落下时两点间的距离就是需要缩放的比例。
								// scale the image
								imageView.zoomTo(originalScale * scale, x + event.getX(1), y + event.getY(1));
 
							}
						}
					}
				}
				return false;
			}
 
		});
	}
	@Override
	public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
		View view = MyGallery.this.getSelectedView();
		if (view instanceof MyImageView) {
			imageView = (MyImageView) view;
 
			float v[] = new float[9];
			Matrix m = imageView.getImageMatrix();
			m.getValues(v);
			// 图片实时的上下左右坐标
			float left, right;
			// 图片的实时宽，高
			float width, height;
			width = imageView.getScale() * imageView.getImageWidth();
			height = imageView.getScale() * imageView.getImageHeight();
			// 一下逻辑为移动图片和滑动gallery换屏的逻辑。如果没对整个框架了解的非常清晰，改动以下的代码前请三思！！！！！！
			if ((int) width <= Main.screenWidth && (int) height <= Main.screenHeight)// 如果图片当前大小<屏幕大小，直接处理滑屏事件 			{ 				super.onScroll(e1, e2, distanceX, distanceY); 			} else { 				left = v[Matrix.MTRANS_X]; 				right = left + width; 				Rect r = new Rect(); 				imageView.getGlobalVisibleRect(r); 				if (distanceX > 0)// 向左滑动
				{
					if (r.left > 0) {// 判断当前ImageView是否显示完全
						super.onScroll(e1, e2, distanceX, distanceY);
					} else if (right < Main.screenWidth) {
						super.onScroll(e1, e2, distanceX, distanceY);
					} else {
						imageView.postTranslate(-distanceX, -distanceY);
					}
				} else if (distanceX < 0)// 向右滑动
				{
					if (r.right < Main.screenWidth) { 						super.onScroll(e1, e2, distanceX, distanceY); 					} else if (left > 0) {
						super.onScroll(e1, e2, distanceX, distanceY);
					} else {
						imageView.postTranslate(-distanceX, -distanceY);
					}
				}
 
			}
 
		} else {
			super.onScroll(e1, e2, distanceX, distanceY);
		}
		return false;
	}
	@Override
	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
		return false;
	}
 
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		gestureScanner.onTouchEvent(event);
		switch (event.getAction()) {
		case MotionEvent.ACTION_UP:
			// 判断上下边界是否越界
			View view = MyGallery.this.getSelectedView();
			if (view instanceof MyImageView) {
				imageView = (MyImageView) view;
				float width = imageView.getScale() * imageView.getImageWidth();
				float height = imageView.getScale() * imageView.getImageHeight();
				if ((int) width <= Main.screenWidth && (int) height <= Main.screenHeight)// 如果图片当前大小<屏幕大小，判断边界 				{ 					break; 				} 				float v[] = new float[9]; 				Matrix m = imageView.getImageMatrix(); 				m.getValues(v); 				float top = v[Matrix.MTRANS_Y]; 				float bottom = top + height; 				if (top > 0) {
					imageView.postTranslateDur(-top, 200f);
				}
				Log.i("manga", "bottom:" + bottom);
				if (bottom < Main.screenHeight) { 					imageView.postTranslateDur(Main.screenHeight - bottom, 200f); 				} 			} 			break; 		} 		return super.onTouchEvent(event); 	} 	private class MySimpleGesture extends SimpleOnGestureListener { 		// 按两下的第二下Touch down时触发 		public boolean onDoubleTap(MotionEvent e) { 			View view = MyGallery.this.getSelectedView(); 			if (view instanceof MyImageView) { 				imageView = (MyImageView) view; 				if (imageView.getScale() > imageView.getScaleRate()) {
					imageView.zoomTo(imageView.getScaleRate(), Main.screenWidth / 2, Main.screenHeight / 2, 200f);
					// imageView.layoutToCenter();
				} else {
					imageView.zoomTo(1.0f, Main.screenWidth / 2, Main.screenHeight / 2, 200f);
				}
 
			} else {
 
			}
			// return super.onDoubleTap(e);
			return true;
		}
	}
}

/**
 * MyImageView.java
 * @version 1.0
 * @author Haven  http://www.havenliu.com
 * @createTime 2011-12-9 下午03:12:30
 * 此类代码是根据android系统自带的ImageViewTouchBase代码修改
 */
package com.havenliu.demo;
 
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.widget.ImageView;
 
public class MyImageView extends ImageView {
	@SuppressWarnings("unused")
	private static final String TAG = "ImageViewTouchBase";
 
	// This is the base transformation which is used to show the image
	// initially. The current computation for this shows the image in
	// it's entirety, letterboxing as needed. One could choose to
	// show the image as cropped instead.
	//
	// This matrix is recomputed when we go from the thumbnail image to
	// the full size image.
	protected Matrix mBaseMatrix = new Matrix();
 
	// This is the supplementary transformation which reflects what
	// the user has done in terms of zooming and panning.
	//
	// This matrix remains the same when we go from the thumbnail image
	// to the full size image.
	protected Matrix mSuppMatrix = new Matrix();
 
	// This is the final matrix which is computed as the concatentation
	// of the base matrix and the supplementary matrix.
	private final Matrix mDisplayMatrix = new Matrix();
 
	// Temporary buffer used for getting the values out of a matrix.
	private final float[] mMatrixValues = new float[9];
 
	// The current bitmap being displayed.
	// protected final RotateBitmap mBitmapDisplayed = new RotateBitmap(null);
	protected Bitmap image = null;
 
	int mThisWidth = -1, mThisHeight = -1;
 
	float mMaxZoom = 2.0f;// 最大缩放比例
	float mMinZoom ;// 最小缩放比例
 
	private int imageWidth;// 图片的原始宽度
	private int imageHeight;// 图片的原始高度
 
	private float scaleRate;// 图片适应屏幕的缩放比例
 
	public MyImageView(Context context, int imageWidth, int imageHeight) {
		super(context);
		this.imageHeight = imageHeight;
		this.imageWidth = imageWidth;
		init();
	}
 
	public MyImageView(Context context, AttributeSet attrs, int imageWidth, int imageHeight) {
		super(context, attrs);
		this.imageHeight = imageHeight;
		this.imageWidth = imageWidth;
		init();
	}
 
	/**
	 * 计算图片要适应屏幕需要缩放的比例
	 */
	private void arithScaleRate() {
		float scaleWidth = Main.screenWidth / (float) imageWidth;
		float scaleHeight = Main.screenHeight / (float) imageHeight;
		scaleRate = Math.min(scaleWidth, scaleHeight);
	}
 
	public float getScaleRate() {
		return scaleRate;
	}
 
	public int getImageWidth() {
		return imageWidth;
	}
 
	public void setImageWidth(int imageWidth) {
		this.imageWidth = imageWidth;
	}
 
	public int getImageHeight() {
		return imageHeight;
	}
 
	public void setImageHeight(int imageHeight) {
		this.imageHeight = imageHeight;
	}
 
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
			event.startTracking();
			return true;
		}
		return super.onKeyDown(keyCode, event);
	}
 
	@Override
	public boolean onKeyUp(int keyCode, KeyEvent event) {
		if (keyCode == KeyEvent.KEYCODE_BACK && event.isTracking() && !event.isCanceled()) {
			if (getScale() > 1.0f) {
				// If we're zoomed in, pressing Back jumps out to show the
				// entire image, otherwise Back returns the user to the gallery.
				zoomTo(1.0f);
				return true;
			}
		}
		return super.onKeyUp(keyCode, event);
	}
 
	protected Handler mHandler = new Handler();
 
	@Override
	public void setImageBitmap(Bitmap bitmap) {
		super.setImageBitmap(bitmap);
		image = bitmap;
		// 计算适应屏幕的比例
		arithScaleRate();
		//缩放到屏幕大小
		zoomTo(scaleRate,Main.screenWidth / 2f, Main.screenHeight / 2f);
 
		//居中
		layoutToCenter();
 
//		imageView.zoomTo(scaleRate, Main.screenWidth / 2, Main.screenHeight / 2
//		center(true, true);
	}
 
	// Center as much as possible in one or both axis. Centering is
	// defined as follows: if the image is scaled down below the
	// view's dimensions then center it (literally). If the image
	// is scaled larger than the view and is translated out of view
	// then translate it back into view (i.e. eliminate black bars).
	protected void center(boolean horizontal, boolean vertical) {
		// if (mBitmapDisplayed.getBitmap() == null) {
		// return;
		// }
		if (image == null) {
			return;
		}
 
		Matrix m = getImageViewMatrix();
 
		RectF rect = new RectF(0, 0, image.getWidth(), image.getHeight());
//		RectF rect = new RectF(0, 0, imageWidth*getScale(), imageHeight*getScale());
 
		m.mapRect(rect);
 
		float height = rect.height();
		float width = rect.width();
 
		float deltaX = 0, deltaY = 0;
 
		if (vertical) {
			int viewHeight = getHeight();
			if (height < viewHeight) { 				deltaY = (viewHeight - height) / 2 - rect.top; 			} else if (rect.top > 0) {
				deltaY = -rect.top;
			} else if (rect.bottom < viewHeight) {
				deltaY = getHeight() - rect.bottom;
			}
		}
 
		if (horizontal) {
			int viewWidth = getWidth();
			if (width < viewWidth) { 				deltaX = (viewWidth - width) / 2 - rect.left; 			} else if (rect.left > 0) {
				deltaX = -rect.left;
			} else if (rect.right < viewWidth) { 				deltaX = viewWidth - rect.right; 			} 		} 		postTranslate(deltaX, deltaY); 		setImageMatrix(getImageViewMatrix()); 	} 	private void init() { 		setScaleType(ImageView.ScaleType.MATRIX); 	} 	/** 	 * 设置图片居中显示 	 */ 	public void layoutToCenter() 	{ 		//正在显示的图片实际宽高 		float width = imageWidth*getScale(); 		float height = imageHeight*getScale(); 		//空白区域宽高 		float fill_width = Main.screenWidth - width; 		float fill_height = Main.screenHeight - height; 		//需要移动的距离 		float tran_width = 0f; 		float tran_height = 0f; 		if(fill_width>0)
			tran_width = fill_width/2;
		if(fill_height>0)
			tran_height = fill_height/2;
 
		postTranslate(tran_width, tran_height);
		setImageMatrix(getImageViewMatrix());
	}
 
	protected float getValue(Matrix matrix, int whichValue) {
		matrix.getValues(mMatrixValues);
		mMinZoom =( Main.screenWidth/2f)/imageWidth;
 
		return mMatrixValues[whichValue];
	}
 
	// Get the scale factor out of the matrix.
	protected float getScale(Matrix matrix) {
		return getValue(matrix, Matrix.MSCALE_X);
	}
 
	protected float getScale() {
		return getScale(mSuppMatrix);
	}
 
	// Combine the base matrix and the supp matrix to make the final matrix.
	protected Matrix getImageViewMatrix() {
		// The final matrix is computed as the concatentation of the base matrix
		// and the supplementary matrix.
		mDisplayMatrix.set(mBaseMatrix);
		mDisplayMatrix.postConcat(mSuppMatrix);
		return mDisplayMatrix;
	}
 
	static final float SCALE_RATE = 1.25F;
 
	// Sets the maximum zoom, which is a scale relative to the base matrix. It
	// is calculated to show the image at 400% zoom regardless of screen or
	// image orientation. If in the future we decode the full 3 megapixel image,
	// rather than the current 1024x768, this should be changed down to 200%.
	protected float maxZoom() {
		if (image == null) {
			return 1F;
		}
 
		float fw = (float) image.getWidth() / (float) mThisWidth;
		float fh = (float) image.getHeight() / (float) mThisHeight;
		float max = Math.max(fw, fh) * 4;
		return max;
	}
 
	protected void zoomTo(float scale, float centerX, float centerY) {
		if (scale > mMaxZoom) {
			scale = mMaxZoom;
		} else if (scale < mMinZoom) {
			scale = mMinZoom;
		}
 
		float oldScale = getScale();
		float deltaScale = scale / oldScale;
 
		mSuppMatrix.postScale(deltaScale, deltaScale, centerX, centerY);
		setImageMatrix(getImageViewMatrix());
		center(true, true);
	}
 
	protected void zoomTo(final float scale, final float centerX, final float centerY, final float durationMs) {
		final float incrementPerMs = (scale - getScale()) / durationMs;
		final float oldScale = getScale();
		final long startTime = System.currentTimeMillis();
 
		mHandler.post(new Runnable() {
			public void run() {
				long now = System.currentTimeMillis();
				float currentMs = Math.min(durationMs, now - startTime);
				float target = oldScale + (incrementPerMs * currentMs);
				zoomTo(target, centerX, centerY);
				if (currentMs < durationMs) { 					mHandler.post(this); 				} 			} 		}); 	} 	protected void zoomTo(float scale) { 		float cx = getWidth() / 2F; 		float cy = getHeight() / 2F; 		zoomTo(scale, cx, cy); 	} 	protected void zoomToPoint(float scale, float pointX, float pointY) { 		float cx = getWidth() / 2F; 		float cy = getHeight() / 2F; 		panBy(cx - pointX, cy - pointY); 		zoomTo(scale, cx, cy); 	} 	protected void zoomIn() { 		zoomIn(SCALE_RATE); 	} 	protected void zoomOut() { 		zoomOut(SCALE_RATE); 	} 	protected void zoomIn(float rate) { 		if (getScale() >= mMaxZoom) {
			return; // Don't let the user zoom into the molecular level.
		} else if (getScale() <= mMinZoom) {
			return;
		}
		if (image == null) {
			return;
		}
 
		float cx = getWidth() / 2F;
		float cy = getHeight() / 2F;
 
		mSuppMatrix.postScale(rate, rate, cx, cy);
		setImageMatrix(getImageViewMatrix());
	}
 
	protected void zoomOut(float rate) {
		if (image == null) {
			return;
		}
 
		float cx = getWidth() / 2F;
		float cy = getHeight() / 2F;
 
		// Zoom out to at most 1x.
		Matrix tmp = new Matrix(mSuppMatrix);
		tmp.postScale(1F / rate, 1F / rate, cx, cy);
 
		if (getScale(tmp) < 1F) {
			mSuppMatrix.setScale(1F, 1F, cx, cy);
		} else {
			mSuppMatrix.postScale(1F / rate, 1F / rate, cx, cy);
		}
		setImageMatrix(getImageViewMatrix());
		center(true, true);
	}
 
	public void postTranslate(float dx, float dy) {
		mSuppMatrix.postTranslate(dx, dy);
		setImageMatrix(getImageViewMatrix());
	}
	float _dy=0.0f;
	protected void postTranslateDur( final float dy, final float durationMs) {
		_dy=0.0f;
		final float incrementPerMs = dy / durationMs;
		final long startTime = System.currentTimeMillis();
		mHandler.post(new Runnable() {
			public void run() {
				long now = System.currentTimeMillis();
				float currentMs = Math.min(durationMs, now - startTime);
 
				postTranslate(0, incrementPerMs*currentMs-_dy);
				_dy=incrementPerMs*currentMs;
 
				if (currentMs < durationMs) {
					mHandler.post(this);
				}
			}
		});
	}
	protected void panBy(float dx, float dy) {
		postTranslate(dx, dy);
		setImageMatrix(getImageViewMatrix());
	}
}