android 仿系统图片播放器中的幻灯片播放

在android系统相册中有一个幻灯片播放的功能 效果非常好 他是用openGl 画的  现在我分享一个使用SurfaceView画的一个小demo  不多说 直接看代码：

package com.zhao.imageslide;
import java.util.List;

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.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;


public class SlideSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Runnable{ 
		private static final String TAG = "SlideSurfaceView";
	    boolean mbLoop = false;
	  
	    private Context mContext;
	    SurfaceHolder mSurfaceHolder = null;
	    private int mWidth = 0;
	    private int mHeight = 0;
	    
	    private List<Integer> mList;
	    private Bitmap mCurrentBitmap;
	    private Bitmap mNextBitmap;
	    private boolean isLoadingNextBitmap = false;
	    private int mCurrentposition = 0;
	    int miCount = 0;  
	    int y =50;  
	      
	    public SlideSurfaceView(Context context, List<Integer> list) {  
	        super(context);  
	        mContext = context;
	        mList = list;
	        mSurfaceHolder = this.getHolder();  
	        
	        mSurfaceHolder.addCallback(this);
	        this.setFocusable(true);  
	        mbLoop = true;  
	    }  
	    
	      
	    @Override  
	    public void surfaceChanged(SurfaceHolder holder, int format, int width, 
	            int height) {  
	    }  
	      
	    @Override  
	    public void surfaceCreated(SurfaceHolder holder) {  
	    	mWidth = getMeasuredWidth();
	        mHeight = getMeasuredHeight();
	        Log.i(TAG, "mWidth:" + mWidth + "  mHeight:" + mHeight);
	        loadFirstBitmap();
	        new Thread(this).start();
	    }  
	      
	    @Override  
	    public void surfaceDestroyed(SurfaceHolder holder) {  
	        mbLoop = false;  
	    }  
	    
	    
	      
	    @Override  
	    public void run() {  
	        while (mbLoop){  
	            try {  
	                Thread.sleep(10);  
	            } catch (Exception e) {  
	                  
	            }  
	            synchronized( mSurfaceHolder ){  
	                Draw();  
	            }  
	        }  
	    }  
	    public void Draw(){  
	        Canvas canvas = mSurfaceHolder.lockCanvas();  
	        if (mSurfaceHolder==null || canvas == null) {  
	            return;  
	        }  
	        if (miCount < 100) {  
	            miCount++;  
	        }else {  
	            miCount = 5;  
	        }  
	        Paint mPaint = new Paint();  
	        Paint mNextPaint = new Paint();
	        mPaint.setAntiAlias(true);  
	        canvas.drawRect(0, 0, mWidth, mHeight, mPaint);
	        switch (miCount) {
			case 96:
				mPaint.setAlpha(215);
				mNextPaint.setAlpha(55);
				break;
			case 97:
				mPaint.setAlpha(175);
				mNextPaint.setAlpha(95);
				break;
			case 98:
				mPaint.setAlpha(135);
				mNextPaint.setAlpha(135);
				break;
			case 99:
				mPaint.setAlpha(95);
				mNextPaint.setAlpha(175);
				break;
			case 100:
				mPaint.setAlpha(55);
				mNextPaint.setAlpha(215);
				break;
			default:
				break;
			}
	        if(miCount > 95) {
	        	if(mNextBitmap != null) {
	        		Bitmap nextBitmap = getScaleImage(mNextBitmap, miCount - 96);
					canvas.drawBitmap(nextBitmap, (mWidth - nextBitmap.getWidth()) / 2, (mHeight - nextBitmap.getHeight()) / 2, mNextPaint);
	        	}
	        }
	        Bitmap bitmap = getScaleImage(mCurrentBitmap, miCount);
	        canvas.drawBitmap(bitmap, (mWidth - bitmap.getWidth()) / 2, (mHeight - bitmap.getHeight()) / 2, mPaint);
	        mSurfaceHolder.unlockCanvasAndPost(canvas);
	        if(mNextBitmap != null) {
	        	if(miCount >= 100) {
	        		Log.i(TAG, "change to next");
	        		mCurrentBitmap.recycle();
	        		mCurrentBitmap = mNextBitmap;
	        		mNextBitmap = null;
	        		mCurrentposition ++;
	        		if(mCurrentposition >= mList.size()) {
	        			mCurrentposition = 0;
	        		}
	        	}
	        } else {
	        	if(!isLoadingNextBitmap) {
	        		loadNextBitmap();
	        	}
	        }
	    }  
	 
	    private Bitmap getScaleImage(Bitmap srcBitmap, int index) {
	    	Bitmap bitmap = null;
	    	Matrix matrix = new Matrix();
	    	float scale = getScale(srcBitmap);
	    	float scaleSpeed;
	    	if(scale < 1) {
	    		scaleSpeed = (1 - scale) / 100;
    		} else {
    			scaleSpeed = 0.2f / 100;
    		}
	    	float bitScale = scale + scaleSpeed * index;
	    	matrix.postScale(bitScale, bitScale);
	    	bitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true);
	    	return bitmap;
	    }
	    
	    
	    private void loadFirstBitmap() {
	    	if(mCurrentBitmap == null) {
	    		BitmapFactory.Options options = new BitmapFactory.Options();
				options.inJustDecodeBounds = true;
				BitmapFactory.decodeResource(getResources(), mList.get(0), options);
				options.inJustDecodeBounds = false;
				options.inSampleSize = calculateInSampleSize(options,(int)(mWidth * 1.2F), (int)(mHeight * 1.2F));
				mCurrentBitmap = BitmapFactory.decodeResource(getResources(), mList.get(0), options);
				if(mCurrentBitmap != null) {
					mCurrentBitmap = createScaleBitmap(mCurrentBitmap, (int)(mWidth * 1.2F), (int)(mHeight * 1.2F));
				}
	    	}
		}
	    
	    private void loadNextBitmap() {
	    	Log.i(TAG, "loadNextBitmap");
	    	isLoadingNextBitmap = true;
	    	new Thread() {
	    		@Override
	    		public void run() {
	    			super.run();
	    			if(mList != null && mList.size() > 0) {
	    				int index = mCurrentposition + 1;
	    				if(index >= mList.size()) {
	    					index = 0;
	    				}
	    				
	    				BitmapFactory.Options options = new BitmapFactory.Options();
						options.inJustDecodeBounds = true;
						BitmapFactory.decodeResource(getResources(), mList.get(index), options);
						options.inJustDecodeBounds = false;
						options.inSampleSize = calculateInSampleSize(options,(int)(mWidth * 1.2F), (int)(mHeight * 1.2F));
						mNextBitmap = BitmapFactory.decodeResource(getResources(), mList.get(index), options);
						if(mNextBitmap != null) {
							mNextBitmap = createScaleBitmap(mNextBitmap, (int)(mWidth * 1.2F), (int)(mHeight * 1.2F));
						}
	    			}
	    			isLoadingNextBitmap = false;
	    		}
	    	}.start();
	    }
	    
	    private static int calculateInSampleSize(BitmapFactory.Options options,
	            int reqWidth, int reqHeight) {
	        final int height = options.outHeight;
	        final int width = options.outWidth;
	        int inSampleSize = 1;
	        if (height > reqHeight || width > reqWidth) {
	            final int halfHeight = height / 2;
	            final int halfWidth = width / 2;
	            while ((halfHeight / inSampleSize) > reqHeight
	                    && (halfWidth / inSampleSize) > reqWidth) {
	                inSampleSize *= 2;
	            }
	        }
	        return inSampleSize;
	    }
		
		private static Bitmap createScaleBitmap(Bitmap src, int dstWidth, int dstHeight) {
			Bitmap dst = null;
	        int width = src.getWidth();
	        int height = src.getHeight();
	        Log.i(TAG, "dstWidth:" + dstWidth + "  width:"+ width +"   dstHeight:" + dstHeight + "  height:" + height);
	        float scale = 1.0f;
	        Matrix matrix = new Matrix();
	        if(width > dstWidth || height > dstHeight) {
	        	scale = Math.min(dstWidth * 1.0F / width, dstHeight * 1.0F / height);
	        } else {
	        	if(width > height) {
	        		scale = dstWidth * 1.0f / width;
	        	} else {
	        		scale = dstHeight * 1.0f / height;
	        	}
	        	if(scale >= 4.0f) {
	        		scale = 4.0f;
	        	}
	        }
	        Log.e(TAG, "scale:" + scale);
        	matrix.postScale(scale, scale);
        	dst = Bitmap.createBitmap(src, 0, 0, width, height, matrix, true);
	        if(src != dst) {
	        	src.recycle();
	        }
	        Log.e(TAG, "dstHeight    " + "height:" + dst.getHeight() + "   width:" + dst.getWidth() );
	        return dst;
	    }

		private float getScale(Bitmap bitmap) {
			float scale = 1.0f;
			int width = bitmap.getWidth();
			int height = bitmap.getHeight();
			if(width <= mWidth && height <= mHeight) {
			} else {
				float scaleWidth = mWidth * 1.0f / width;
				float scaleHeight = mHeight * 1.0F / height;
				scale = scaleWidth > scaleHeight ? scaleHeight : scaleWidth;
			}
			return scale;
		}
}

代码可直接使用 很简单 注释就不写了