android中左右滑屏的实现（广告位banner组件）

1. 原理

参见下图。整个组件是一个FrameLayout，里面有两个view，第一个是LinearLayout，承载了4个（或多个）可以滑动的view，见图中绿色背景的部分；第二个是一个RelativeLayout，在其底部放置了一个LinearLayout，在LinearLayout的内部放置了若干个小圆点，用来指示当前屏幕的索引。手势检测用了GestureDetector，并实现了OnGestureListener接口。为了能控制滑动速度，采用了Scroller弹性滑动对象。

为什么组件继承FrameLayout，是因为用于指示的小圆点是出现在view上面的，一个view叠在另一个view上面，这就是FrameLayout的特性

什么是banner组件？在许多android应用上，比如爱奇艺客户端、百度美拍、应用宝等上面，都有一个可以手动滑动的小广告条，这就是banner，实际应用中的banner，其信息（图片和点击行为）是后台可配置的，是需要通过网络从后台拉取的。网上有许多手动滑屏的例子，但是一般只是个demo，无法在实际中使用，因为其一般没有考虑如下几类问题：图片缓存、OOM问题、是否可灵活配置、是否预留外部接口以及是否封装良好。没有良好的封装，手动滑屏加在代码中，会使得代码变得很烂很脆弱。

 

        2.     功能、效果

• banner属性可动态设置，默认数量为4，可以调整默认的数量
• banner信息从后台获取，banner的条数就是屏幕的数量
• 可自动滑动也能手动滑动
• 图片下载为多线程，并采用常见的三级cache策略（内存、文件、网络），节省流量，并处理了OOM异常
• 内部处理点击事件，同时预留出了接口函数
• banner封装成一个ViewGroup类，使用起来简单，最少只需要两行代码

 

        3.    代码

 

代码注释写的比较详细，应该很好理解。分为2个文件，一个是banner的类，另一个是接口声明。

ScrollBanner.java

/**
 * ScrollBanner 支持滑屏效果的FrameLayout子类，可设置屏幕数量，尺寸。<br/>
 * 典型的用法：<br/>
 * 		ScrollBanner scrollBanner = new ScrollBanner(this, mScreenWidth, 100, this);<br/>
 *		linearLayout.addView(scrollBanner);<br/>
 *注意事项：<br/>
 *1.如果重新设置ScrollBanner的LayoutParams，则参数中的宽和高属性将被忽略，仍然采用对象实例化的宽和高<br/>
 *2.点击事件的回调如果设为null，则采用默认的事件回调<br/>
 *3.通过setOverScrollMode来设置 banner是否能够滑出屏幕的边界<br/>
 *4通过xml方式加载banner，需要进行如下调用：<br/>
 *		setResolution(width, height);<br/>
		setOnBannerClickListener(bannerClickListener);<br/>
		showBanner()<br/>
 * @author singwhatiwanna
 * @version 2013.3.4
 *
 */
public class ScrollBanner extends FrameLayout implements 
ComponentCallBack.OnBannerClickListener, 
ResponseHandler.BannerInfoHandler
{

	private static final String TAG = "ScrollBanner";

	private HorizontalScrollViewEx mHorizontalScrollViewEx;
	
	//ScrollBanner的子view
	private LinearLayout linearLayoutScrolLayout;
	
	//linearLayoutScrolLayout的子view，用于放置若干个小圆点
	private LinearLayout linearLayoutForDot;
	
	private Scroller mScroller;	
	private Context mContext;
	private OnBannerClickListener mBannerClickListener;

	//屏幕及其bitmap
	private List<View> mLinearLayoutScreens = new ArrayList<View>();
	private List<Bitmap> mBannerBitmaps = new ArrayList<Bitmap>();

	//banner信息
	private List<BannerItem> mBannerItemsList = new ArrayList<BannerItem>();
	//小圆点
	private List<ImageView> mImageViewList = new ArrayList<ImageView>();
	private Drawable mPageIndicator;
	private Drawable mPageIndicatorFocused;
	
	//banner默认图片
	private Bitmap mDefaultBitmap;

	private int mScreenWidth;
	private int mScreenHeight;
	private int mScrollX;

	//current screen index
	private int mWhich = 0;

	public static final int MESSAGE_AUTO_SCROLL = 1;

	public static final int MESSAGE_FETCH_BANNER_SUCCESS = 2;

	public static final int MARGIN_BOTTOM = 2;
	
	//480*150 banner的图片尺寸 150.0/480=0.3125f
	public static final float ratio = 0.3125f;

	//banner的位置
	private int mLocation = -1;

	//banner分为几屏
	private int PAGE_COUNT = 4;

	//滑动方向 是否向右滑动
	private boolean mScrollToRight = true;

	//是否自动滑屏
	private boolean mTimerResume = true;

	//标志用户是否手动滑动了屏幕
	private boolean mByUserAction = false;

	//标志banner是否可以滑出边界
	private boolean mOverScrollMode = false;
	//标志banner可以滑出边界多少像素
	private int mOverScrollDistance = 0;

	//定时器 用于banner的自动播放
	final Timer timer = new Timer();

	//定时器的时间间隔 单位：ms
	public static final int TIMER_DURATION = 5000;

	private TimerTask mTimerTask = new TimerTask()
	{
		@Override
		public void run() 
		{
			if (mTimerResume && !mByUserAction) 
			{
				mHandler.sendEmptyMessage(MESSAGE_AUTO_SCROLL);
			}
			mByUserAction = false;
		}
	};

	//ScrollBanner私有handler 用于处理内部逻辑
	private Handler mHandler = new Handler()
	{
		public void handleMessage(Message msg)
		{
			//表示已经执行了onDetachedFromWindow，banner已经被销毁了
			if( mBannerBitmaps == null || mLinearLayoutScreens == null || 
					mImageViewList == null || mBannerItemsList == null || mContext == null )
				return;
			
			switch (msg.what)
			{
			case MESSAGE_AUTO_SCROLL:
				if (mWhich == PAGE_COUNT - 1)
					mScrollToRight = false;
				else if(mWhich == 0)
				{
					mScrollToRight = true;
				}

				if (mScrollToRight) 
					mWhich++;
				else 
				{
					mWhich--;
				}

				mHorizontalScrollViewEx.switchView(mWhich);
				break;
			case MESSAGE_FETCH_BANNER_SUCCESS:
				int more = 0;
				if(mBannerItemsList != null)
					more = mBannerItemsList.size() - PAGE_COUNT;
				if(mBannerItemsList.size() > 0)
				{
					//如果有banner 显示它
					ScrollBanner.this.show(true);
				}
				//如果后台返回的banneritem的数量大于预设值4
				if(more > 0)
				{
					for (int i = 0; i < more; i++)
						addBannerItem();
				}
				fetchBannerImages();
				break;

			default:
				break;
			}
		};
	};

	//用于获取bitmap
	private Handler  mBitmapHandler = new Handler()
	{

		public void handleMessage(Message msg)
		{
			//表示已经执行了onDetachedFromWindow，banner已经被销毁了
			if( mBannerBitmaps == null || mLinearLayoutScreens == null || 
					mImageViewList == null || mBannerItemsList == null || mContext == null )
				return;
			
			Bitmap bitmap = (Bitmap)msg.obj;
			String urlString = msg.getData().getString("url");
			Logger.d(TAG, "url=" + urlString);
			if (urlString == null || bitmap == null || mBannerItemsList == null)
			{
				Logger.w(TAG, "bitmap=null imgurl=" + urlString);
				return;
			}

			for( int i = 0; i < mBannerItemsList.size(); i++ )
			{
				BannerItem item = mBannerItemsList.get(i);
				if(item != null && urlString.equals(item.imgUrl) )
				{
					Logger.d(TAG, "find " + i + urlString);
					if( mBannerBitmaps != null ) 
					{
						mBannerBitmaps.set( i, bitmap );
						setBannerImages(i);
					}
					break;
				}
			}
			
		};

	};

	public ScrollBanner(Context context)
	{
		this(context, null);
	}

	public ScrollBanner(Context context, AttributeSet attrs)
	{
		super(context, attrs);
		mContext = context;
	}

	public ScrollBanner(Context context, AttributeSet attrs, int defStyle)
	{
		super(context, attrs, defStyle);
		mContext = context;
	}

	/**
	 * 
	 * @param context activity实例
	 * @param width banner的宽度 单位px
	 * @param height banner的高度 单位dip,-1表示根据图片比例自适应高度
	 * @param bannerClickListener 单击banner的回调接口
	 */
	public ScrollBanner(Context context, final int width, final int height, OnBannerClickListener bannerClickListener)
	{
		this(context, null);

		int activityId = ( (BaseActivity)context ).activityId();
		if(activityId == BaseActivity.ACCOUNT_ID)//位置3
			mLocation = 3;
		else if(activityId == BaseActivity.GAMEZONE_ID)//位置2
		{
			mLocation = 2;
		}
		
		//初始化时不显示banner
		this.show(false);
		setResolution(width, height);
		setOnBannerClickListener(bannerClickListener);
		setDefaultBannerImages();
		fetchBannerInfo();
	}

	/**
	 * 通过xml方式加载banner，必须调用此方法才能显示
	 */
	public void showBanner()
	{
		int activityId = ( (BaseActivity)mContext ).activityId();
		if(activityId == BaseActivity.ACCOUNT_ID)//位置3
			mLocation = 3;
		else if(activityId == BaseActivity.GAMEZONE_ID)//位置2
		{
			mLocation = 2;
		}
		
		setDefaultBannerImages();
		fetchBannerInfo();
	}
	
	/**
	 * 暂停滚动
	 */
	public void pauseScroll()
	{
		mTimerResume = false;
	}
	
	/**
	 * 恢复滚动
	 */
	public void resumeScroll()
	{
		mTimerResume = true;
	}
	
	/**
	 * 设置回调接口
	 * @param callBack 单击banner的回调接口
	 */
	public void setOnBannerClickListener(OnBannerClickListener bannerClickListener)
	{
		mBannerClickListener = (bannerClickListener != null ? bannerClickListener : ScrollBanner.this);
	}

	/**
	 * 设置banner的解析度
	 * @param width banner的宽度
	 * @param height banner的高度
	 */
	public void setResolution(final int width, final int height)
	{
		int heightInPx = height;
		
		if(height == -1)
			heightInPx = (int)(ratio * width) ;
		else
		{
			Resources resources = getResources();
			heightInPx = Math.round( TypedValue.applyDimension(
					TypedValue.COMPLEX_UNIT_DIP, height, resources.getDisplayMetrics()) );
		}
		
		mScreenWidth = width;
		mScreenHeight = heightInPx;
		setLayoutParams(new LayoutParams(width, heightInPx));

		initScrollView();
	}
	
	/**
	 * 获取banner的高度
	 * @return banner的高度 单位：px
	 */
	public int getHeightPixels()
	{
		return mScreenHeight;
	}

	/**
	 * 设置banner是否可以弹性滑出边界
	 * @param canOverScroll true表示可以滑出边界，false不能
	 */
	public void setOverScrollMode(boolean canOverScroll)
	{
		mOverScrollMode = canOverScroll;
		if(canOverScroll == false)
			mOverScrollDistance = 0;
	}

	/**
	 * 向后台获取banner的各种信息
	 */
	private void fetchBannerInfo()
	{
		NetworkManager netManager = (NetworkManager) AppEngine.getInstance().getManager(
				IManager.NETWORK_ID);
		netManager.getBannerInfo( String.valueOf(mLocation), ScrollBanner.this );
	}

	/**
	 * 获取banner的滑屏图像
	 */
	private void setDefaultBannerImages()
	{
		//为banner设置默认bitmap
        BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();  
        bitmapFactoryOptions.inJustDecodeBounds = false;  
        bitmapFactoryOptions.inSampleSize = 2;  

		Resources res=mContext.getResources();
		mDefaultBitmap = BitmapFactory.decodeResource(res, R.drawable.banner_image_default, bitmapFactoryOptions);
		
		for(int i = 0; i < PAGE_COUNT; i++)
			mBannerBitmaps.add(i, mDefaultBitmap);

		//初始化BannerItem对象
		for (int i = 0; i < PAGE_COUNT; i++)
			mBannerItemsList.add(i, null);

		setBannerImages(-1);
	}

	private void fetchBannerImages()
	{
		//表示已经执行了onDetachedFromWindow，banner已经被销毁了
		if( mBannerItemsList == null )
			return;
		
		//ImageManager 根据url向其获取bitmap
		ImageManager imageManager = (ImageManager)AppEngine.getInstance().
				getManager(IManager.IMAGE_ID);

		BannerItem item = null;
		for(int i = 0; i < PAGE_COUNT; i++)
		{
			try
			{
				item = mBannerItemsList.get(i);
			} 
			catch (IndexOutOfBoundsException e)
			{
				Logger.e(TAG, "fetchBannerImages error: " + e);
			}
			catch (Exception e) 
			{
				Logger.e(TAG, "fetchBannerImages error: " + e);
			}
			//ImageManager为多线程，采用常见的三级cache策略（内存、文件、网络）
			if( item != null && item.imgUrl != null )
				imageManager.loadBitmap( item.imgUrl, mBitmapHandler );
		}
	}

	/**
	 * 设置banner的滑屏图像
	 * @param position 如果position=-1，则表示设置全部bitmap
	 */
	private void setBannerImages(final int position)
	{
		int size = mBannerBitmaps.size();
		if (size < PAGE_COUNT || mLinearLayoutScreens == null)
		{
			return;
		}
		if(position >=0 && position < PAGE_COUNT )
		{
			Drawable drawable = mLinearLayoutScreens.get(position).getBackground();
			mLinearLayoutScreens.get(position).setBackgroundDrawable
			(new BitmapDrawable( mBannerBitmaps.get(position) ) );
			drawable.setCallback(null);
			drawable = null;
			
			return;
		}

		for(int i = 0; i < PAGE_COUNT; i++)
		{
			mLinearLayoutScreens.get(i).setBackgroundDrawable(new BitmapDrawable(mBannerBitmaps.get(i)));
		}
	}

	/**
	 * 是否显示banner
	 * @param isShow true显示 false不显示
	 */
	public void show(boolean isShow)
	{
		if(isShow)
		{
			this.setVisibility(View.VISIBLE);
			mTimerResume = true;
		}
		else 
		{
			this.setVisibility(View.GONE);
			mTimerResume = false;
		}
	}

	/**
	 * 切换到指定屏幕
	 * @param which 屏幕索引
	 */
	public void switchToScreen(final int which)
	{
		mHorizontalScrollViewEx.switchView(which);
	}
	
	/**
	 * 设置屏幕的数量 （此函数暂不开放）
	 * @param count 屏幕数量
	 */
	protected void setScreenCount(final int count)
	{
		PAGE_COUNT = count;
	}

	/**
	 * 设置偏移的距离 如果mOverScrollMode为false，则此设置无效 （此函数暂不开放）
	 * @param distance
	 */
	protected void setOverScrollDistance(int distance)
	{
		if(distance < 0)
			distance = 0;

		mOverScrollDistance = mOverScrollMode ? distance : 0;
	}

	/**
	 * 切换小圆点
	 * @param position current screen index
	 */
	private void switchScreenPosition(final int position)
	{
		if( mPageIndicator == null || mPageIndicatorFocused == null )
			return;
		
		int length = 0;
		if(mImageViewList != null)
			length = mImageViewList.size();
		if (position >= length || position < 0 || length <= 0)
		{
			return;
		}

		for(int i = 0; i < length; i++)
		{
			mImageViewList.get(i).setImageDrawable(mPageIndicator);
		}
		
		mImageViewList.get(position).setImageDrawable(mPageIndicatorFocused);
	}

	/**
	 * 初始化整个FrameLayout视图组
	 */
	private void initScrollView()
	{
		setLayoutParams(new LayoutParams(mScreenWidth, mScreenHeight ));

		linearLayoutScrolLayout = new LinearLayout(mContext);
		linearLayoutScrolLayout.setBackgroundColor(Color.WHITE);
		linearLayoutScrolLayout.setOrientation(LinearLayout.HORIZONTAL);
		
		int mVersionCode = 8;
		try
		{
			mVersionCode = Integer.valueOf(android.os.Build.VERSION.SDK);
			Logger.d(TAG, "sdk version=" + mVersionCode);
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
		}
		//针对android1.6及以下的特殊处理 此为android的低版本bug
		if(mVersionCode <= 5)
		{
			linearLayoutScrolLayout.setBaselineAligned(false);
		}
		
		//初始化四个滑动view
		for(int i = 0; i < PAGE_COUNT; i++)
		{
			LinearLayout linearLayoutScreen = new LinearLayout(mContext);
			linearLayoutScreen.setOrientation(LinearLayout.VERTICAL);
			linearLayoutScrolLayout.addView(linearLayoutScreen, new LayoutParams(
					mScreenWidth, 
					LayoutParams.FILL_PARENT));

			mLinearLayoutScreens.add(i, linearLayoutScreen);
		}

		//初始化小圆点视图
		RelativeLayout relativeLayout = new RelativeLayout(mContext);
		relativeLayout.setLayoutParams(new LayoutParams(
				LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT));

		//linearLayoutForDot为小圆点视图
		linearLayoutForDot =new LinearLayout(mContext);
		android.widget.RelativeLayout.LayoutParams layoutParams = 
				new android.widget.RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, 
						LayoutParams.WRAP_CONTENT);
		//小圆点距底部的距离 单位:px
		layoutParams.bottomMargin = MARGIN_BOTTOM;
		layoutParams.rightMargin = MARGIN_BOTTOM;
		layoutParams.addRule(android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM);
		layoutParams.addRule(android.widget.RelativeLayout.CENTER_HORIZONTAL);
		linearLayoutForDot.setLayoutParams(layoutParams);
		linearLayoutForDot.setOrientation(LinearLayout.HORIZONTAL);
		linearLayoutForDot.setHorizontalGravity(Gravity.CENTER);
		linearLayoutForDot.setVerticalGravity(Gravity.CENTER);
		//下面两句实现圆角半透明效果 不采用
		//		linearLayoutForDot.setBackgroundResource(R.drawable.round_corner_bg);
		//		linearLayoutForDot.getBackground().setAlpha(100);

		//初始化4个小圆点
		mPageIndicator = getResources().getDrawable(R.drawable.page_indicator);
		mPageIndicatorFocused = getResources().getDrawable(R.drawable.page_indicator_focused);
		for(int i = 0; i < PAGE_COUNT; i++)
		{
			ImageView imageView = new ImageView(mContext);
			imageView.setImageDrawable(mPageIndicator);
			mImageViewList.add(i, imageView);
			LinearLayout.LayoutParams layoutParamsForDot = 
					new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT, 
							LayoutParams.WRAP_CONTENT);
			layoutParamsForDot.rightMargin = 5;

			linearLayoutForDot.addView(imageView, layoutParamsForDot);
		}
		mImageViewList.get(0).setImageDrawable(mPageIndicatorFocused);
		relativeLayout.addView(linearLayoutForDot);

		mHorizontalScrollViewEx = new HorizontalScrollViewEx(mContext, null, mBannerClickListener);
		mHorizontalScrollViewEx.setLayoutParams(new LayoutParams(
				mScreenWidth * PAGE_COUNT, 
				LayoutParams.FILL_PARENT));
		mHorizontalScrollViewEx.addView(linearLayoutScrolLayout, new LayoutParams(
				LayoutParams.FILL_PARENT, 
				LayoutParams.FILL_PARENT));

		mHorizontalScrollViewEx.setHorizontalScrollBarEnabled(false);
		mHorizontalScrollViewEx.setHorizontalFadingEdgeEnabled(false);

		addView(mHorizontalScrollViewEx);
		addView(relativeLayout);

		//自动滑屏 5秒一次
		timer.schedule(mTimerTask, 5000, TIMER_DURATION);
	}

	/**
	 * 加一个banner页面 TODO此函数写的不好
	 */
	private void addBannerItem()
	{
		//表示已经执行了onDetachedFromWindow，banner已经被销毁了
		if( mBannerBitmaps == null || mLinearLayoutScreens == null || 
				mImageViewList == null || mContext == null )
			return;
		
		//调整屏幕数量和总宽度
		PAGE_COUNT += 1;
		mHorizontalScrollViewEx.getLayoutParams().width = mScreenWidth * PAGE_COUNT;
		        
        //加载默认图片资源
		if(mDefaultBitmap == null)
		{
	        BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();  
	        bitmapFactoryOptions.inJustDecodeBounds = false;  
	        bitmapFactoryOptions.inSampleSize = 2;  
			Resources res=mContext.getResources();
			mDefaultBitmap = BitmapFactory.decodeResource(res, R.drawable.banner_image_default, bitmapFactoryOptions);
		}
		mBannerBitmaps.add(mDefaultBitmap);
		mBannerItemsList.add(null);	
		//加一个屏幕
		LinearLayout linearLayoutScreen = new LinearLayout(mContext);
		linearLayoutScreen.setOrientation(LinearLayout.VERTICAL);
		linearLayoutScreen.setBackgroundDrawable(new BitmapDrawable( mBannerBitmaps.get(PAGE_COUNT - 1) ));
		linearLayoutScrolLayout.addView(linearLayoutScreen, new LayoutParams(
				mScreenWidth, 
				LayoutParams.FILL_PARENT));
		mLinearLayoutScreens.add(linearLayoutScreen);
		
		//加一个小圆点
		ImageView imageView = new ImageView(mContext);
		imageView.setImageDrawable(mPageIndicator);
		mImageViewList.add(imageView);
		LinearLayout.LayoutParams layoutParamsForDot = 
				new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT, 
						LayoutParams.WRAP_CONTENT);
		layoutParamsForDot.rightMargin = 5;
		linearLayoutForDot.addView(imageView, layoutParamsForDot);		
	}
	
	private class HorizontalScrollViewEx extends ViewGroup implements 
	OnGestureListener
	{

		private GestureDetector mGestureDetector;
		private int mWhichScreen;

		public HorizontalScrollViewEx(Context context, AttributeSet attrs, OnBannerClickListener bannerClickListener)
		{
			super(context, attrs);
			
			mGestureDetector = new GestureDetector(this);
			//解决长按屏幕后无法拖动的现象
			mGestureDetector.setIsLongpressEnabled(false);

			//构造弹性滑动对象
			mScroller = new Scroller(context);
		}

		/**
		 * 切换到指定屏幕
		 * @param whichScreen 屏幕index
		 */
		public void switchView(int whichScreen)
		{
			if(mLinearLayoutScreens == null)
				return;
			
			// 防止非法参数
			if (whichScreen < 0)
				whichScreen = 0;
			else if(whichScreen >= PAGE_COUNT)
				whichScreen = PAGE_COUNT - 1;

			Logger.i(TAG, "switch view to " + whichScreen);

			int delta = whichScreen * mScreenWidth - HorizontalScrollViewEx.this.getScrollX();

			//缓慢滚动到指定位置
			mScroller.startScroll(getScrollX(), 0, delta, 0, Math.abs(delta) * 3);

			// refresh
			invalidate();

			//delta>0 stands for user scroll view to right
			if (delta > 0) 
				mScrollToRight = true;
			else 
			{
				mScrollToRight = false;
			}

			mWhichScreen = whichScreen;
			mWhich = whichScreen;
			//切换小圆点
			switchScreenPosition(mWhichScreen);
		}

		/**
		 * 用户轻触触摸屏，由1个MotionEvent ACTION_DOWN触发
		 */
		@Override
		public boolean onDown(MotionEvent e)
		{
			Logger.i("MyGesture", "onDown");
			
			mScrollX = HorizontalScrollViewEx.this.getScrollX();

			return true;
		}

		/**
		 * 用户轻触触摸屏，尚未松开或拖动，由一个1个MotionEvent ACTION_DOWN触发
		 * 注意和onDown()的区别，强调的是没有松开或者拖动的状态
		 */
		public void onShowPress(MotionEvent e)
		{
			Logger.i("MyGesture", "onShowPress");
		}

		/**
		 * 用户（轻触触摸屏后）松开，由一个1个MotionEvent ACTION_UP触发
		 */
		public boolean onSingleTapUp(MotionEvent e)
		{
			Logger.i("MyGesture", "onSingleTapUp");
			if(mBannerItemsList == null || mBannerItemsList.size() <= mWhichScreen)
				return false;
			
			BannerItem bannerItem = mBannerItemsList.get(mWhichScreen);

			if(bannerItem != null)
			{
				BannerMotionEvent bannerMotionEvent = 
						new BannerMotionEvent(mWhichScreen, bannerItem.action, bannerItem.url, 
								bannerItem.gameId, bannerItem.gameType, bannerItem.title);
				mBannerClickListener.onBannerClick(bannerMotionEvent);
			}

			return false;
		}

		/** 用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE,
		 * 1个ACTION_UP触发
		 */
		public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
				float velocityY)
		{
			Logger.i("MyGesture", "onFling velocityX=" + velocityX);

			mWhichScreen = velocityX > 0 ?
					mWhichScreen - 1
					: mWhichScreen + 1;
			switchView(mWhichScreen);

			return true;
		}

		/** 
		 * 用户按下触摸屏，并拖动，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE触发
		 */
		public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
				float distanceY)
		{
			Logger.i("MyGesture", "onScroll");

			//禁止弹性滚动
			if (mOverScrollMode == false) 
			{
				float x1 = e1.getX();
				float x2 = e2.getX();
				if(mWhichScreen == 0 && x1 < x2)
					return false;
				else if(mWhichScreen == PAGE_COUNT - 1 && x1 > x2)
					return false;
			}
			
//			int distance = Math.abs(getScrollX() - mWhichScreen * mScreenWidth);	
//			if ((mWhichScreen ==0 || mWhichScreen == PAGE_COUNT -1) &&  distance > mOverScrollDistance)
//				return false;
			
			this.scrollBy((int)distanceX, 0);

			return true;
		}

		/**
		 *  用户长按触摸屏，由多个MotionEvent ACTION_DOWN触发
		 */
		public void onLongPress(MotionEvent e)
		{
			Logger.i("MyGesture", "onLongPress");
		}

		@Override
		public boolean onTouchEvent(MotionEvent event)
		{
			if(event.getAction() == MotionEvent.ACTION_DOWN)
			{
				mTimerResume = false;
				if ( !mScroller.isFinished() )
					mScroller.abortAnimation();
			}
			else if(event.getAction() == MotionEvent.ACTION_UP)
			{
				//开始自动滑屏
				mTimerResume = true;
				mByUserAction = true;
			}

			boolean consume = mGestureDetector.onTouchEvent(event);

			if (consume == false && event.getAction() == MotionEvent.ACTION_UP) 
			{
				int curScrollX = HorizontalScrollViewEx.this.getScrollX();
				int mWhichScreen = (curScrollX + mScreenWidth / 2) /mScreenWidth;

				switchView(mWhichScreen);
			}

			return consume;
		}

		@Override
		public void computeScroll()
		{
			if (mScroller.computeScrollOffset())
			{
				scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
				postInvalidate();
			}
		}

		@Override
		protected void onLayout(boolean changed, int l, int t, int r, int b)
		{
			if (changed) 
			{
				int childLeft = 0;
				final int childCount = getChildCount();

				for (int i=0; i<childCount; i++)
				{
					final View childView = getChildAt(i);
					if (childView.getVisibility() != View.GONE)
					{
						final int childWidth = childView.getMeasuredWidth();
						childView.layout(childLeft, 0, 
								childLeft+childWidth, childView.getMeasuredHeight());
						childLeft += childWidth;
					}
				}
			}
		}

		@Override  
		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
		{
			super.onMeasure(widthMeasureSpec, heightMeasureSpec);   

			final int width = MeasureSpec.getSize(widthMeasureSpec);   
			final int count = getChildCount();   
			
			for (int i = 0; i < count; i++)
			{   
				getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);   
			}
			scrollTo(mWhich * mScreenWidth, 0);
		}  

	}

	/**
	 * override此函数，防止其修改构造方法所定义的宽和高<br/>
	 *  注意：在这里，设置宽和高将不起作用
	 */
	@Override
	public void setLayoutParams(android.view.ViewGroup.LayoutParams params)
	{
		params.width = mScreenWidth;
		params.height = mScreenHeight;

		super.setLayoutParams(params);
	}

	//标志view AttachedToWindow
	@Override
	protected void onAttachedToWindow()
	{
		super.onAttachedToWindow();
		mTimerResume = true;
	}

	//标志view已经脱离window，典型的情形是view被销毁了，此时取消timer
	@Override
	protected void onDetachedFromWindow()
	{
		super.onDetachedFromWindow();
		Logger.d(TAG, "onDetachedFromWindow");
		
		mTimerResume = false;
		int activityId = ( (BaseActivity)mContext ).activityId();
		//如果是账号管理页面 则释放内存
		if(activityId == BaseActivity.ACCOUNT_ID)
		{
			destroy();
		}
	}
	
	/**
	 * 销毁banner
	 */
	public void destroy()
	{
		mTimerTask.cancel();
		timer.cancel();
		//去除各种bitmap对activity的引用关系
		destoryBitmaps();
		System.gc();
	}
	
	/**
	 * 去除各种bitmap对activity的引用关系
	 */
	private void destoryBitmaps()
	{		
		for (View view : mLinearLayoutScreens) 
		{
			Drawable drawable = view.getBackground();
			BitmapDrawable bitmapDrawable = null;
			if(drawable instanceof BitmapDrawable)
				bitmapDrawable = (BitmapDrawable)drawable;
			
			if(bitmapDrawable != null)
			{
				//解除drawable对view的引用
				bitmapDrawable.setCallback(null);
				bitmapDrawable = null;
			}
		}
		
		for (ImageView imageView : mImageViewList) 
		{
			Drawable drawable = imageView.getDrawable();
			if(drawable != null)
			{
				drawable.setCallback(null);
				drawable = null;
			}
		}
		
		mPageIndicator.setCallback(null);
		mPageIndicator = null;
		mPageIndicatorFocused.setCallback(null);
		mPageIndicatorFocused = null;
		
		mLinearLayoutScreens.clear();
		mLinearLayoutScreens = null;
		
		mBannerBitmaps.clear();
		mBannerBitmaps = null;
		
		mImageViewList.clear();
		mImageViewList = null;
		
		mBannerItemsList.clear();
		mBannerItemsList = null;	
	}
	
	//单击事件
	@Override
	public void onBannerClick( BannerMotionEvent bannerMotionEvent )
	{
		final int position = bannerMotionEvent.index;
		if(mContext == null)
			return;
		
		NotificationInfo notificationInfo = new NotificationInfo();
		notificationInfo.msgType = bannerMotionEvent.getAction();
		int action = bannerMotionEvent.getAction();
		if(action == NotificationInfo.NOTIFICATION_SINGLEGAME_MSG)    //单个游戏消息，直接启动该游戏
		{
			try
			{
				notificationInfo.gameId = Integer.parseInt( bannerMotionEvent.getGameId() );
				notificationInfo.gameType = Integer.parseInt( bannerMotionEvent.getGameType() );
			} 
			catch (NumberFormatException e) 
			{
				Logger.e(TAG, e.toString());
				return;
			}
		}
		else if(action == NotificationInfo.NOTIFICATION_GAMEPAGE_MSG)    //游戏主页消息，通过客户端展示游戏主页
		{
			try
			{
				notificationInfo.gameId = Integer.parseInt( bannerMotionEvent.getGameId() );
			} 
			catch (NumberFormatException e) 
			{
				Logger.e(TAG, e.toString());
				return;
			}
			notificationInfo.issueTitle = bannerMotionEvent.getTitle();
		}
		else if(action == NotificationInfo.NOTIFICATION_SHOW_WEBVIEW_MSG)    //交叉推广消息，通过一个webview展示
		{
			notificationInfo.issueTitle = bannerMotionEvent.getTitle();
			notificationInfo.openUrl = bannerMotionEvent.getResponseUrl();
		}
		else //reserved
		{
			return;
		}
		
		Intent intent = notificationInfo.generateIntent(mContext);
		if(intent != null)
			mContext.startActivity(intent);
	}
	
	/**
	 * ScrollBanner所关联的banner项 可以为多个 一个为一屏
	 */
	public static class BannerItem extends Object
	{
		public static final String ACTION = "action";
		public static final String URL = "url";
		public static final String IMGURL = "imgurl";
		public static final String GAMEID = "gameid";
		public static final String GAMETYPE = "gametype";
		public static final String TITLE = "title";

		public int index = -1;
		public int action = -1;
		public String url = "";
		public String imgUrl = "";
		public String gameId = "";
		public String gameType = "";
		public String title = "";

		public BannerItem(){}
	}

	/**
	 * BannerMotionEvent：单击banner所产生的事件对象<br/>
	 *getAction()来获取动作类别<br/>
	 *getResponseUrl()来获取响应url<br/>
	 *...
	 */
	public static class BannerMotionEvent extends Object
	{
		/**
		 * ACTION_PLAY_FLASH： 播放游戏
		 */
		public static final int ACTION_PLAY = 2;
		/**
		 * ACTION_HOMEPAGE：打开官网
		 */
		public static final int ACTION_HOMEPAGE = 3;
		/**
		 * ACTION_OPEN_URL：打开指定url
		 */
		public static final int ACTION_OPEN_URL = 4;

		//banner中屏幕的index
		private int index = -1;
		//响应url
		private String responseUrl = "";
		//动作种类
		private int action = -1;
		//gameid
		private String gameId = "";
		//gametype flash游戏(0) or h5游戏(1)
		private String gameType = "";
		//webview的标题
		private String title = "";
		
		public BannerMotionEvent(int index, int action, String responseUrl, 
				String gameId, String gameType, String title)
		{
			BannerMotionEvent.this.index = index;
			BannerMotionEvent.this.action = action;
			BannerMotionEvent.this.responseUrl = responseUrl;
			BannerMotionEvent.this.gameId = gameId;
			BannerMotionEvent.this.gameType = gameType;
			BannerMotionEvent.this.title = title;
		}

		/**
		 * 获取当前BannerMotionEvent事件对象的动作种类
		 * @return 动作种类：ACTION_PLAY等
		 */
		public int getAction()
		{
			return action;
		}

		/**
		 * 获取当前BannerMotionEvent事件对象的title
		 * @return title webview的标题
		 */
		public String getTitle()
		{
			return title;
		}
		
		/**
		 * 获取当前BannerMotionEvent事件对象的gameId
		 * @return gameId
		 */
		public String getGameId()
		{
			return gameId;
		}
		
		/**
		 * 获取当前BannerMotionEvent事件对象的gameType
		 * @return gameType 0 or 1
		 */
		public String getGameType()
		{
			return gameType;
		}
		
		/**
		 * 获取当前BannerMotionEvent事件对象的响应url
		 * @return 响应url
		 */
		public String getResponseUrl()
		{
			return responseUrl;
		}

		@SuppressLint("DefaultLocale")
		@Override
		public String toString()
		{
			return String.format("BannerMotionEvent { index=%d, action=%d, responseUrl=%s, gameId=%s, gameType=%s, title=%s }", 
					index, action, responseUrl, gameId, gameType, title);
		}
	}

	@Override
	public void onBannerInfoSuccess(List<BannerItem> items)
	{
		Logger.d(TAG, "onBannerInfoSuccess");
		mBannerItemsList = items;
		mHandler.sendEmptyMessage(MESSAGE_FETCH_BANNER_SUCCESS);
	}

	@Override
	public void onBannerInfoFailed()
	{
		Logger.e(TAG, "onBannerInfoFailed");
	}

}

 

ComponentCallBack.java

public interface ComponentCallBack 
{

	public static interface OnBannerClickListener
	{
		/**
		 * banner单击事件
		 * @param bannerMotionEvent 单击事件对象，包含所需的响应信息
		 * 参见 {@link BannerMotionEvent}
		 */
		public abstract void onBannerClick( BannerMotionEvent bannerMotionEvent );
	}
	
}