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

http://blog.csdn.net/singwhatiwanna/article/details/8875241

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

[java] view plaincopy

1. /** 
2.  * ScrollBanner 支持滑屏效果的FrameLayout子类，可设置屏幕数量，尺寸。<br/> 
3.  * 典型的用法：<br/> 
4.  *      ScrollBanner scrollBanner = new ScrollBanner(this, mScreenWidth, 100, this);<br/> 
5.  *      linearLayout.addView(scrollBanner);<br/> 
6.  *注意事项：<br/> 
7.  *1.如果重新设置ScrollBanner的LayoutParams，则参数中的宽和高属性将被忽略，仍然采用对象实例化的宽和高<br/> 
8.  *2.点击事件的回调如果设为null，则采用默认的事件回调<br/> 
9.  *3.通过setOverScrollMode来设置 banner是否能够滑出屏幕的边界<br/> 
10.  *4通过xml方式加载banner，需要进行如下调用：<br/> 
11.  *      setResolution(width, height);<br/> 
12.         setOnBannerClickListener(bannerClickListener);<br/> 
13.         showBanner()<br/> 
14.  * @author singwhatiwanna 
15.  * @version 2013.3.4 
16.  * 
17.  */  
18. public class ScrollBanner extends FrameLayout implements   
19. ComponentCallBack.OnBannerClickListener,   
20. ResponseHandler.BannerInfoHandler  
21. {  
22.   
23.     private static final String TAG = "ScrollBanner";  
24.   
25.     private HorizontalScrollViewEx mHorizontalScrollViewEx;  
26.       
27.     //ScrollBanner的子view  
28.     private LinearLayout linearLayoutScrolLayout;  
29.       
30.     //linearLayoutScrolLayout的子view，用于放置若干个小圆点  
31.     private LinearLayout linearLayoutForDot;  
32.       
33.     private Scroller mScroller;   
34.     private Context mContext;  
35.     private OnBannerClickListener mBannerClickListener;  
36.   
37.     //屏幕及其bitmap  
38.     private List<View> mLinearLayoutScreens = new ArrayList<View>();  
39.     private List<Bitmap> mBannerBitmaps = new ArrayList<Bitmap>();  
40.   
41.     //banner信息  
42.     private List<BannerItem> mBannerItemsList = new ArrayList<BannerItem>();  
43.     //小圆点  
44.     private List<ImageView> mImageViewList = new ArrayList<ImageView>();  
45.     private Drawable mPageIndicator;  
46.     private Drawable mPageIndicatorFocused;  
47.       
48.     //banner默认图片  
49.     private Bitmap mDefaultBitmap;  
50.   
51.     private int mScreenWidth;  
52.     private int mScreenHeight;  
53.     private int mScrollX;  
54.   
55.     //current screen index  
56.     private int mWhich = 0;  
57.   
58.     public static final int MESSAGE_AUTO_SCROLL = 1;  
59.   
60.     public static final int MESSAGE_FETCH_BANNER_SUCCESS = 2;  
61.   
62.     public static final int MARGIN_BOTTOM = 2;  
63.       
64.     //480*150 banner的图片尺寸 150.0/480=0.3125f  
65.     public static final float ratio = 0.3125f;  
66.   
67.     //banner的位置  
68.     private int mLocation = -1;  
69.   
70.     //banner分为几屏  
71.     private int PAGE_COUNT = 4;  
72.   
73.     //滑动方向 是否向右滑动  
74.     private boolean mScrollToRight = true;  
75.   
76.     //是否自动滑屏  
77.     private boolean mTimerResume = true;  
78.   
79.     //标志用户是否手动滑动了屏幕  
80.     private boolean mByUserAction = false;  
81.   
82.     //标志banner是否可以滑出边界  
83.     private boolean mOverScrollMode = false;  
84.     //标志banner可以滑出边界多少像素  
85.     private int mOverScrollDistance = 0;  
86.   
87.     //定时器 用于banner的自动播放  
88.     final Timer timer = new Timer();  
89.   
90.     //定时器的时间间隔 单位：ms  
91.     public static final int TIMER_DURATION = 5000;  
92.   
93.     private TimerTask mTimerTask = new TimerTask()  
94.     {  
95.         @Override  
96.         public void run()   
97.         {  
98.             if (mTimerResume && !mByUserAction)   
99.             {  
100.                 mHandler.sendEmptyMessage(MESSAGE_AUTO_SCROLL);  
101.             }  
102.             mByUserAction = false;  
103.         }  
104.     };  
105.   
106.     //ScrollBanner私有handler 用于处理内部逻辑  
107.     private Handler mHandler = new Handler()  
108.     {  
109.         public void handleMessage(Message msg)  
110.         {  
111.             //表示已经执行了onDetachedFromWindow，banner已经被销毁了  
112.             if( mBannerBitmaps == null || mLinearLayoutScreens == null ||   
113.                     mImageViewList == null || mBannerItemsList == null || mContext == null )  
114.                 return;  
115.               
116.             switch (msg.what)  
117.             {  
118.             case MESSAGE_AUTO_SCROLL:  
119.                 if (mWhich == PAGE_COUNT - 1)  
120.                     mScrollToRight = false;  
121.                 else if(mWhich == 0)  
122.                 {  
123.                     mScrollToRight = true;  
124.                 }  
125.   
126.                 if (mScrollToRight)   
127.                     mWhich++;  
128.                 else   
129.                 {  
130.                     mWhich--;  
131.                 }  
132.   
133.                 mHorizontalScrollViewEx.switchView(mWhich);  
134.                 break;  
135.             case MESSAGE_FETCH_BANNER_SUCCESS:  
136.                 int more = 0;  
137.                 if(mBannerItemsList != null)  
138.                     more = mBannerItemsList.size() - PAGE_COUNT;  
139.                 if(mBannerItemsList.size() > 0)  
140.                 {  
141.                     //如果有banner 显示它  
142.                     ScrollBanner.this.show(true);  
143.                 }  
144.                 //如果后台返回的banneritem的数量大于预设值4  
145.                 if(more > 0)  
146.                 {  
147.                     for (int i = 0; i < more; i++)  
148.                         addBannerItem();  
149.                 }  
150.                 fetchBannerImages();  
151.                 break;  
152.   
153.             default:  
154.                 break;  
155.             }  
156.         };  
157.     };  
158.   
159.     //用于获取bitmap  
160.     private Handler  mBitmapHandler = new Handler()  
161.     {  
162.   
163.         public void handleMessage(Message msg)  
164.         {  
165.             //表示已经执行了onDetachedFromWindow，banner已经被销毁了  
166.             if( mBannerBitmaps == null || mLinearLayoutScreens == null ||   
167.                     mImageViewList == null || mBannerItemsList == null || mContext == null )  
168.                 return;  
169.               
170.             Bitmap bitmap = (Bitmap)msg.obj;  
171.             String urlString = msg.getData().getString("url");  
172.             Logger.d(TAG, "url=" + urlString);  
173.             if (urlString == null || bitmap == null || mBannerItemsList == null)  
174.             {  
175.                 Logger.w(TAG, "bitmap=null imgurl=" + urlString);  
176.                 return;  
177.             }  
178.   
179.             for( int i = 0; i < mBannerItemsList.size(); i++ )  
180.             {  
181.                 BannerItem item = mBannerItemsList.get(i);  
182.                 if(item != null && urlString.equals(item.imgUrl) )  
183.                 {  
184.                     Logger.d(TAG, "find " + i + urlString);  
185.                     if( mBannerBitmaps != null )   
186.                     {  
187.                         mBannerBitmaps.set( i, bitmap );  
188.                         setBannerImages(i);  
189.                     }  
190.                     break;  
191.                 }  
192.             }  
193.               
194.         };  
195.   
196.     };  
197.   
198.     public ScrollBanner(Context context)  
199.     {  
200.         this(context, null);  
201.     }  
202.   
203.     public ScrollBanner(Context context, AttributeSet attrs)  
204.     {  
205.         super(context, attrs);  
206.         mContext = context;  
207.     }  
208.   
209.     public ScrollBanner(Context context, AttributeSet attrs, int defStyle)  
210.     {  
211.         super(context, attrs, defStyle);  
212.         mContext = context;  
213.     }  
214.   
215.     /** 
216.      *  
217.      * @param context activity实例 
218.      * @param width banner的宽度 单位px 
219.      * @param height banner的高度 单位dip,-1表示根据图片比例自适应高度 
220.      * @param bannerClickListener 单击banner的回调接口 
221.      */  
222.     public ScrollBanner(Context context, final int width, final int height, OnBannerClickListener bannerClickListener)  
223.     {  
224.         this(context, null);  
225.   
226.         int activityId = ( (BaseActivity)context ).activityId();  
227.         if(activityId == BaseActivity.ACCOUNT_ID)//位置3  
228.             mLocation = 3;  
229.         else if(activityId == BaseActivity.GAMEZONE_ID)//位置2  
230.         {  
231.             mLocation = 2;  
232.         }  
233.           
234.         //初始化时不显示banner  
235.         this.show(false);  
236.         setResolution(width, height);  
237.         setOnBannerClickListener(bannerClickListener);  
238.         setDefaultBannerImages();  
239.         fetchBannerInfo();  
240.     }  
241.   
242.     /** 
243.      * 通过xml方式加载banner，必须调用此方法才能显示 
244.      */  
245.     public void showBanner()  
246.     {  
247.         int activityId = ( (BaseActivity)mContext ).activityId();  
248.         if(activityId == BaseActivity.ACCOUNT_ID)//位置3  
249.             mLocation = 3;  
250.         else if(activityId == BaseActivity.GAMEZONE_ID)//位置2  
251.         {  
252.             mLocation = 2;  
253.         }  
254.           
255.         setDefaultBannerImages();  
256.         fetchBannerInfo();  
257.     }  
258.       
259.     /** 
260.      * 暂停滚动 
261.      */  
262.     public void pauseScroll()  
263.     {  
264.         mTimerResume = false;  
265.     }  
266.       
267.     /** 
268.      * 恢复滚动 
269.      */  
270.     public void resumeScroll()  
271.     {  
272.         mTimerResume = true;  
273.     }  
274.       
275.     /** 
276.      * 设置回调接口 
277.      * @param callBack 单击banner的回调接口 
278.      */  
279.     public void setOnBannerClickListener(OnBannerClickListener bannerClickListener)  
280.     {  
281.         mBannerClickListener = (bannerClickListener != null ? bannerClickListener : ScrollBanner.this);  
282.     }  
283.   
284.     /** 
285.      * 设置banner的解析度 
286.      * @param width banner的宽度 
287.      * @param height banner的高度 
288.      */  
289.     public void setResolution(final int width, final int height)  
290.     {  
291.         int heightInPx = height;  
292.           
293.         if(height == -1)  
294.             heightInPx = (int)(ratio * width) ;  
295.         else  
296.         {  
297.             Resources resources = getResources();  
298.             heightInPx = Math.round( TypedValue.applyDimension(  
299.                     TypedValue.COMPLEX_UNIT_DIP, height, resources.getDisplayMetrics()) );  
300.         }  
301.           
302.         mScreenWidth = width;  
303.         mScreenHeight = heightInPx;  
304.         setLayoutParams(new LayoutParams(width, heightInPx));  
305.   
306.         initScrollView();  
307.     }  
308.       
309.     /** 
310.      * 获取banner的高度 
311.      * @return banner的高度 单位：px 
312.      */  
313.     public int getHeightPixels()  
314.     {  
315.         return mScreenHeight;  
316.     }  
317.   
318.     /** 
319.      * 设置banner是否可以弹性滑出边界 
320.      * @param canOverScroll true表示可以滑出边界，false不能 
321.      */  
322.     public void setOverScrollMode(boolean canOverScroll)  
323.     {  
324.         mOverScrollMode = canOverScroll;  
325.         if(canOverScroll == false)  
326.             mOverScrollDistance = 0;  
327.     }  
328.   
329.     /** 
330.      * 向后台获取banner的各种信息 
331.      */  
332.     private void fetchBannerInfo()  
333.     {  
334.         NetworkManager netManager = (NetworkManager) AppEngine.getInstance().getManager(  
335.                 IManager.NETWORK_ID);  
336.         netManager.getBannerInfo( String.valueOf(mLocation), ScrollBanner.this );  
337.     }  
338.   
339.     /** 
340.      * 获取banner的滑屏图像 
341.      */  
342.     private void setDefaultBannerImages()  
343.     {  
344.         //为banner设置默认bitmap  
345.         BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();    
346.         bitmapFactoryOptions.inJustDecodeBounds = false;    
347.         bitmapFactoryOptions.inSampleSize = 2;    
348.   
349.         Resources res=mContext.getResources();  
350.         mDefaultBitmap = BitmapFactory.decodeResource(res, R.drawable.banner_image_default, bitmapFactoryOptions);  
351.           
352.         for(int i = 0; i < PAGE_COUNT; i++)  
353.             mBannerBitmaps.add(i, mDefaultBitmap);  
354.   
355.         //初始化BannerItem对象  
356.         for (int i = 0; i < PAGE_COUNT; i++)  
357.             mBannerItemsList.add(i, null);  
358.   
359.         setBannerImages(-1);  
360.     }  
361.   
362.     private void fetchBannerImages()  
363.     {  
364.         //表示已经执行了onDetachedFromWindow，banner已经被销毁了  
365.         if( mBannerItemsList == null )  
366.             return;  
367.           
368.         //ImageManager 根据url向其获取bitmap  
369.         ImageManager imageManager = (ImageManager)AppEngine.getInstance().  
370.                 getManager(IManager.IMAGE_ID);  
371.   
372.         BannerItem item = null;  
373.         for(int i = 0; i < PAGE_COUNT; i++)  
374.         {  
375.             try  
376.             {  
377.                 item = mBannerItemsList.get(i);  
378.             }   
379.             catch (IndexOutOfBoundsException e)  
380.             {  
381.                 Logger.e(TAG, "fetchBannerImages error: " + e);  
382.             }  
383.             catch (Exception e)   
384.             {  
385.                 Logger.e(TAG, "fetchBannerImages error: " + e);  
386.             }  
387.             //ImageManager为多线程，采用常见的三级cache策略（内存、文件、网络）  
388.             if( item != null && item.imgUrl != null )  
389.                 imageManager.loadBitmap( item.imgUrl, mBitmapHandler );  
390.         }  
391.     }  
392.   
393.     /** 
394.      * 设置banner的滑屏图像 
395.      * @param position 如果position=-1，则表示设置全部bitmap 
396.      */  
397.     private void setBannerImages(final int position)  
398.     {  
399.         int size = mBannerBitmaps.size();  
400.         if (size < PAGE_COUNT || mLinearLayoutScreens == null)  
401.         {  
402.             return;  
403.         }  
404.         if(position >=0 && position < PAGE_COUNT )  
405.         {  
406.             Drawable drawable = mLinearLayoutScreens.get(position).getBackground();  
407.             mLinearLayoutScreens.get(position).setBackgroundDrawable  
408.             (new BitmapDrawable( mBannerBitmaps.get(position) ) );  
409.             drawable.setCallback(null);  
410.             drawable = null;  
411.               
412.             return;  
413.         }  
414.   
415.         for(int i = 0; i < PAGE_COUNT; i++)  
416.         {  
417.             mLinearLayoutScreens.get(i).setBackgroundDrawable(new BitmapDrawable(mBannerBitmaps.get(i)));  
418.         }  
419.     }  
420.   
421.     /** 
422.      * 是否显示banner 
423.      * @param isShow true显示 false不显示 
424.      */  
425.     public void show(boolean isShow)  
426.     {  
427.         if(isShow)  
428.         {  
429.             this.setVisibility(View.VISIBLE);  
430.             mTimerResume = true;  
431.         }  
432.         else   
433.         {  
434.             this.setVisibility(View.GONE);  
435.             mTimerResume = false;  
436.         }  
437.     }  
438.   
439.     /** 
440.      * 切换到指定屏幕 
441.      * @param which 屏幕索引 
442.      */  
443.     public void switchToScreen(final int which)  
444.     {  
445.         mHorizontalScrollViewEx.switchView(which);  
446.     }  
447.       
448.     /** 
449.      * 设置屏幕的数量 （此函数暂不开放） 
450.      * @param count 屏幕数量 
451.      */  
452.     protected void setScreenCount(final int count)  
453.     {  
454.         PAGE_COUNT = count;  
455.     }  
456.   
457.     /** 
458.      * 设置偏移的距离 如果mOverScrollMode为false，则此设置无效 （此函数暂不开放） 
459.      * @param distance 
460.      */  
461.     protected void setOverScrollDistance(int distance)  
462.     {  
463.         if(distance < 0)  
464.             distance = 0;  
465.   
466.         mOverScrollDistance = mOverScrollMode ? distance : 0;  
467.     }  
468.   
469.     /** 
470.      * 切换小圆点 
471.      * @param position current screen index 
472.      */  
473.     private void switchScreenPosition(final int position)  
474.     {  
475.         if( mPageIndicator == null || mPageIndicatorFocused == null )  
476.             return;  
477.           
478.         int length = 0;  
479.         if(mImageViewList != null)  
480.             length = mImageViewList.size();  
481.         if (position >= length || position < 0 || length <= 0)  
482.         {  
483.             return;  
484.         }  
485.   
486.         for(int i = 0; i < length; i++)  
487.         {  
488.             mImageViewList.get(i).setImageDrawable(mPageIndicator);  
489.         }  
490.           
491.         mImageViewList.get(position).setImageDrawable(mPageIndicatorFocused);  
492.     }  
493.   
494.     /** 
495.      * 初始化整个FrameLayout视图组 
496.      */  
497.     private void initScrollView()  
498.     {  
499.         setLayoutParams(new LayoutParams(mScreenWidth, mScreenHeight ));  
500.   
501.         linearLayoutScrolLayout = new LinearLayout(mContext);  
502.         linearLayoutScrolLayout.setBackgroundColor(Color.WHITE);  
503.         linearLayoutScrolLayout.setOrientation(LinearLayout.HORIZONTAL);  
504.           
505.         int mVersionCode = 8;  
506.         try  
507.         {  
508.             mVersionCode = Integer.valueOf(android.os.Build.VERSION.SDK);  
509.             Logger.d(TAG, "sdk version=" + mVersionCode);  
510.         }   
511.         catch (Exception e)   
512.         {  
513.             e.printStackTrace();  
514.         }  
515.         //针对android1.6及以下的特殊处理 此为android的低版本bug  
516.         if(mVersionCode <= 5)  
517.         {  
518.             linearLayoutScrolLayout.setBaselineAligned(false);  
519.         }  
520.           
521.         //初始化四个滑动view  
522.         for(int i = 0; i < PAGE_COUNT; i++)  
523.         {  
524.             LinearLayout linearLayoutScreen = new LinearLayout(mContext);  
525.             linearLayoutScreen.setOrientation(LinearLayout.VERTICAL);  
526.             linearLayoutScrolLayout.addView(linearLayoutScreen, new LayoutParams(  
527.                     mScreenWidth,   
528.                     LayoutParams.FILL_PARENT));  
529.   
530.             mLinearLayoutScreens.add(i, linearLayoutScreen);  
531.         }  
532.   
533.         //初始化小圆点视图  
534.         RelativeLayout relativeLayout = new RelativeLayout(mContext);  
535.         relativeLayout.setLayoutParams(new LayoutParams(  
536.                 LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT));  
537.   
538.         //linearLayoutForDot为小圆点视图  
539.         linearLayoutForDot =new LinearLayout(mContext);  
540.         android.widget.RelativeLayout.LayoutParams layoutParams =   
541.                 new android.widget.RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT,   
542.                         LayoutParams.WRAP_CONTENT);  
543.         //小圆点距底部的距离 单位:px  
544.         layoutParams.bottomMargin = MARGIN_BOTTOM;  
545.         layoutParams.rightMargin = MARGIN_BOTTOM;  
546.         layoutParams.addRule(android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM);  
547.         layoutParams.addRule(android.widget.RelativeLayout.CENTER_HORIZONTAL);  
548.         linearLayoutForDot.setLayoutParams(layoutParams);  
549.         linearLayoutForDot.setOrientation(LinearLayout.HORIZONTAL);  
550.         linearLayoutForDot.setHorizontalGravity(Gravity.CENTER);  
551.         linearLayoutForDot.setVerticalGravity(Gravity.CENTER);  
552.         //下面两句实现圆角半透明效果 不采用  
553.         //      linearLayoutForDot.setBackgroundResource(R.drawable.round_corner_bg);  
554.         //      linearLayoutForDot.getBackground().setAlpha(100);  
555.   
556.         //初始化4个小圆点  
557.         mPageIndicator = getResources().getDrawable(R.drawable.page_indicator);  
558.         mPageIndicatorFocused = getResources().getDrawable(R.drawable.page_indicator_focused);  
559.         for(int i = 0; i < PAGE_COUNT; i++)  
560.         {  
561.             ImageView imageView = new ImageView(mContext);  
562.             imageView.setImageDrawable(mPageIndicator);  
563.             mImageViewList.add(i, imageView);  
564.             LinearLayout.LayoutParams layoutParamsForDot =   
565.                     new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT,   
566.                             LayoutParams.WRAP_CONTENT);  
567.             layoutParamsForDot.rightMargin = 5;  
568.   
569.             linearLayoutForDot.addView(imageView, layoutParamsForDot);  
570.         }  
571.         mImageViewList.get(0).setImageDrawable(mPageIndicatorFocused);  
572.         relativeLayout.addView(linearLayoutForDot);  
573.   
574.         mHorizontalScrollViewEx = new HorizontalScrollViewEx(mContext, null, mBannerClickListener);  
575.         mHorizontalScrollViewEx.setLayoutParams(new LayoutParams(  
576.                 mScreenWidth * PAGE_COUNT,   
577.                 LayoutParams.FILL_PARENT));  
578.         mHorizontalScrollViewEx.addView(linearLayoutScrolLayout, new LayoutParams(  
579.                 LayoutParams.FILL_PARENT,   
580.                 LayoutParams.FILL_PARENT));  
581.   
582.         mHorizontalScrollViewEx.setHorizontalScrollBarEnabled(false);  
583.         mHorizontalScrollViewEx.setHorizontalFadingEdgeEnabled(false);  
584.   
585.         addView(mHorizontalScrollViewEx);  
586.         addView(relativeLayout);  
587.   
588.         //自动滑屏 5秒一次  
589.         timer.schedule(mTimerTask, 5000, TIMER_DURATION);  
590.     }  
591.   
592.     /** 
593.      * 加一个banner页面 TODO此函数写的不好 
594.      */  
595.     private void addBannerItem()  
596.     {  
597.         //表示已经执行了onDetachedFromWindow，banner已经被销毁了  
598.         if( mBannerBitmaps == null || mLinearLayoutScreens == null ||   
599.                 mImageViewList == null || mContext == null )  
600.             return;  
601.           
602.         //调整屏幕数量和总宽度  
603.         PAGE_COUNT += 1;  
604.         mHorizontalScrollViewEx.getLayoutParams().width = mScreenWidth * PAGE_COUNT;  
605.                   
606.         //加载默认图片资源  
607.         if(mDefaultBitmap == null)  
608.         {  
609.             BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();    
610.             bitmapFactoryOptions.inJustDecodeBounds = false;    
611.             bitmapFactoryOptions.inSampleSize = 2;    
612.             Resources res=mContext.getResources();  
613.             mDefaultBitmap = BitmapFactory.decodeResource(res, R.drawable.banner_image_default, bitmapFactoryOptions);  
614.         }  
615.         mBannerBitmaps.add(mDefaultBitmap);  
616.         mBannerItemsList.add(null);   
617.         //加一个屏幕  
618.         LinearLayout linearLayoutScreen = new LinearLayout(mContext);  
619.         linearLayoutScreen.setOrientation(LinearLayout.VERTICAL);  
620.         linearLayoutScreen.setBackgroundDrawable(new BitmapDrawable( mBannerBitmaps.get(PAGE_COUNT - 1) ));  
621.         linearLayoutScrolLayout.addView(linearLayoutScreen, new LayoutParams(  
622.                 mScreenWidth,   
623.                 LayoutParams.FILL_PARENT));  
624.         mLinearLayoutScreens.add(linearLayoutScreen);  
625.           
626.         //加一个小圆点  
627.         ImageView imageView = new ImageView(mContext);  
628.         imageView.setImageDrawable(mPageIndicator);  
629.         mImageViewList.add(imageView);  
630.         LinearLayout.LayoutParams layoutParamsForDot =   
631.                 new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT,   
632.                         LayoutParams.WRAP_CONTENT);  
633.         layoutParamsForDot.rightMargin = 5;  
634.         linearLayoutForDot.addView(imageView, layoutParamsForDot);        
635.     }  
636.       
637.     private class HorizontalScrollViewEx extends ViewGroup implements   
638.     OnGestureListener  
639.     {  
640.   
641.         private GestureDetector mGestureDetector;  
642.         private int mWhichScreen;  
643.   
644.         public HorizontalScrollViewEx(Context context, AttributeSet attrs, OnBannerClickListener bannerClickListener)  
645.         {  
646.             super(context, attrs);  
647.               
648.             mGestureDetector = new GestureDetector(this);  
649.             //解决长按屏幕后无法拖动的现象  
650.             mGestureDetector.setIsLongpressEnabled(false);  
651.   
652.             //构造弹性滑动对象  
653.             mScroller = new Scroller(context);  
654.         }  
655.   
656.         /** 
657.          * 切换到指定屏幕 
658.          * @param whichScreen 屏幕index 
659.          */  
660.         public void switchView(int whichScreen)  
661.         {  
662.             if(mLinearLayoutScreens == null)  
663.                 return;  
664.               
665.             // 防止非法参数  
666.             if (whichScreen < 0)  
667.                 whichScreen = 0;  
668.             else if(whichScreen >= PAGE_COUNT)  
669.                 whichScreen = PAGE_COUNT - 1;  
670.   
671.             Logger.i(TAG, "switch view to " + whichScreen);  
672.   
673.             int delta = whichScreen * mScreenWidth - HorizontalScrollViewEx.this.getScrollX();  
674.   
675.             //缓慢滚动到指定位置  
676.             mScroller.startScroll(getScrollX(), 0, delta, 0, Math.abs(delta) * 3);  
677.   
678.             // refresh  
679.             invalidate();  
680.   
681.             //delta>0 stands for user scroll view to right  
682.             if (delta > 0)   
683.                 mScrollToRight = true;  
684.             else   
685.             {  
686.                 mScrollToRight = false;  
687.             }  
688.   
689.             mWhichScreen = whichScreen;  
690.             mWhich = whichScreen;  
691.             //切换小圆点  
692.             switchScreenPosition(mWhichScreen);  
693.         }  
694.   
695.         /** 
696.          * 用户轻触触摸屏，由1个MotionEvent ACTION_DOWN触发 
697.          */  
698.         @Override  
699.         public boolean onDown(MotionEvent e)  
700.         {  
701.             Logger.i("MyGesture", "onDown");  
702.               
703.             mScrollX = HorizontalScrollViewEx.this.getScrollX();  
704.   
705.             return true;  
706.         }  
707.   
708.         /** 
709.          * 用户轻触触摸屏，尚未松开或拖动，由一个1个MotionEvent ACTION_DOWN触发 
710.          * 注意和onDown()的区别，强调的是没有松开或者拖动的状态 
711.          */  
712.         public void onShowPress(MotionEvent e)  
713.         {  
714.             Logger.i("MyGesture", "onShowPress");  
715.         }  
716.   
717.         /** 
718.          * 用户（轻触触摸屏后）松开，由一个1个MotionEvent ACTION_UP触发 
719.          */  
720.         public boolean onSingleTapUp(MotionEvent e)  
721.         {  
722.             Logger.i("MyGesture", "onSingleTapUp");  
723.             if(mBannerItemsList == null || mBannerItemsList.size() <= mWhichScreen)  
724.                 return false;  
725.               
726.             BannerItem bannerItem = mBannerItemsList.get(mWhichScreen);  
727.   
728.             if(bannerItem != null)  
729.             {  
730.                 BannerMotionEvent bannerMotionEvent =   
731.                         new BannerMotionEvent(mWhichScreen, bannerItem.action, bannerItem.url,   
732.                                 bannerItem.gameId, bannerItem.gameType, bannerItem.title);  
733.                 mBannerClickListener.onBannerClick(bannerMotionEvent);  
734.             }  
735.   
736.             return false;  
737.         }  
738.   
739.         /** 用户按下触摸屏、快速移动后松开，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE, 
740.          * 1个ACTION_UP触发 
741.          */  
742.         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,  
743.                 float velocityY)  
744.         {  
745.             Logger.i("MyGesture", "onFling velocityX=" + velocityX);  
746.   
747.             mWhichScreen = velocityX > 0 ?  
748.                     mWhichScreen - 1  
749.                     : mWhichScreen + 1;  
750.             switchView(mWhichScreen);  
751.   
752.             return true;  
753.         }  
754.   
755.         /**  
756.          * 用户按下触摸屏，并拖动，由1个MotionEvent ACTION_DOWN, 多个ACTION_MOVE触发 
757.          */  
758.         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,  
759.                 float distanceY)  
760.         {  
761.             Logger.i("MyGesture", "onScroll");  
762.   
763.             //禁止弹性滚动  
764.             if (mOverScrollMode == false)   
765.             {  
766.                 float x1 = e1.getX();  
767.                 float x2 = e2.getX();  
768.                 if(mWhichScreen == 0 && x1 < x2)  
769.                     return false;  
770.                 else if(mWhichScreen == PAGE_COUNT - 1 && x1 > x2)  
771.                     return false;  
772.             }  
773.               
774. //          int distance = Math.abs(getScrollX() - mWhichScreen * mScreenWidth);      
775. //          if ((mWhichScreen ==0 || mWhichScreen == PAGE_COUNT -1) &&  distance > mOverScrollDistance)  
776. //              return false;  
777.               
778.             this.scrollBy((int)distanceX, 0);  
779.   
780.             return true;  
781.         }  
782.   
783.         /** 
784.          *  用户长按触摸屏，由多个MotionEvent ACTION_DOWN触发 
785.          */  
786.         public void onLongPress(MotionEvent e)  
787.         {  
788.             Logger.i("MyGesture", "onLongPress");  
789.         }  
790.   
791.         @Override  
792.         public boolean onTouchEvent(MotionEvent event)  
793.         {  
794.             if(event.getAction() == MotionEvent.ACTION_DOWN)  
795.             {  
796.                 mTimerResume = false;  
797.                 if ( !mScroller.isFinished() )  
798.                     mScroller.abortAnimation();  
799.             }  
800.             else if(event.getAction() == MotionEvent.ACTION_UP)  
801.             {  
802.                 //开始自动滑屏  
803.                 mTimerResume = true;  
804.                 mByUserAction = true;  
805.             }  
806.   
807.             boolean consume = mGestureDetector.onTouchEvent(event);  
808.   
809.             if (consume == false && event.getAction() == MotionEvent.ACTION_UP)   
810.             {  
811.                 int curScrollX = HorizontalScrollViewEx.this.getScrollX();  
812.                 int mWhichScreen = (curScrollX + mScreenWidth / 2) /mScreenWidth;  
813.   
814.                 switchView(mWhichScreen);  
815.             }  
816.   
817.             return consume;  
818.         }  
819.   
820.         @Override  
821.         public void computeScroll()  
822.         {  
823.             if (mScroller.computeScrollOffset())  
824.             {  
825.                 scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
826.                 postInvalidate();  
827.             }  
828.         }  
829.   
830.         @Override  
831.         protected void onLayout(boolean changed, int l, int t, int r, int b)  
832.         {  
833.             if (changed)   
834.             {  
835.                 int childLeft = 0;  
836.                 final int childCount = getChildCount();  
837.   
838.                 for (int i=0; i<childCount; i++)  
839.                 {  
840.                     final View childView = getChildAt(i);  
841.                     if (childView.getVisibility() != View.GONE)  
842.                     {  
843.                         final int childWidth = childView.getMeasuredWidth();  
844.                         childView.layout(childLeft, 0,   
845.                                 childLeft+childWidth, childView.getMeasuredHeight());  
846.                         childLeft += childWidth;  
847.                     }  
848.                 }  
849.             }  
850.         }  
851.   
852.         @Override    
853.         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)  
854.         {  
855.             super.onMeasure(widthMeasureSpec, heightMeasureSpec);     
856.   
857.             final int width = MeasureSpec.getSize(widthMeasureSpec);     
858.             final int count = getChildCount();     
859.               
860.             for (int i = 0; i < count; i++)  
861.             {     
862.                 getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);     
863.             }  
864.             scrollTo(mWhich * mScreenWidth, 0);  
865.         }    
866.   
867.     }  
868.   
869.     /** 
870.      * override此函数，防止其修改构造方法所定义的宽和高<br/> 
871.      *  注意：在这里，设置宽和高将不起作用 
872.      */  
873.     @Override  
874.     public void setLayoutParams(android.view.ViewGroup.LayoutParams params)  
875.     {  
876.         params.width = mScreenWidth;  
877.         params.height = mScreenHeight;  
878.   
879.         super.setLayoutParams(params);  
880.     }  
881.   
882.     //标志view AttachedToWindow  
883.     @Override  
884.     protected void onAttachedToWindow()  
885.     {  
886.         super.onAttachedToWindow();  
887.         mTimerResume = true;  
888.     }  
889.   
890.     //标志view已经脱离window，典型的情形是view被销毁了，此时取消timer  
891.     @Override  
892.     protected void onDetachedFromWindow()  
893.     {  
894.         super.onDetachedFromWindow();  
895.         Logger.d(TAG, "onDetachedFromWindow");  
896.           
897.         mTimerResume = false;  
898.         int activityId = ( (BaseActivity)mContext ).activityId();  
899.         //如果是账号管理页面 则释放内存  
900.         if(activityId == BaseActivity.ACCOUNT_ID)  
901.         {  
902.             destroy();  
903.         }  
904.     }  
905.       
906.     /** 
907.      * 销毁banner 
908.      */  
909.     public void destroy()  
910.     {  
911.         mTimerTask.cancel();  
912.         timer.cancel();  
913.         //去除各种bitmap对activity的引用关系  
914.         destoryBitmaps();  
915.         System.gc();  
916.     }  
917.       
918.     /** 
919.      * 去除各种bitmap对activity的引用关系 
920.      */  
921.     private void destoryBitmaps()  
922.     {         
923.         for (View view : mLinearLayoutScreens)   
924.         {  
925.             Drawable drawable = view.getBackground();  
926.             BitmapDrawable bitmapDrawable = null;  
927.             if(drawable instanceof BitmapDrawable)  
928.                 bitmapDrawable = (BitmapDrawable)drawable;  
929.               
930.             if(bitmapDrawable != null)  
931.             {  
932.                 //解除drawable对view的引用  
933.                 bitmapDrawable.setCallback(null);  
934.                 bitmapDrawable = null;  
935.             }  
936.         }  
937.           
938.         for (ImageView imageView : mImageViewList)   
939.         {  
940.             Drawable drawable = imageView.getDrawable();  
941.             if(drawable != null)  
942.             {  
943.                 drawable.setCallback(null);  
944.                 drawable = null;  
945.             }  
946.         }  
947.           
948.         mPageIndicator.setCallback(null);  
949.         mPageIndicator = null;  
950.         mPageIndicatorFocused.setCallback(null);  
951.         mPageIndicatorFocused = null;  
952.           
953.         mLinearLayoutScreens.clear();  
954.         mLinearLayoutScreens = null;  
955.           
956.         mBannerBitmaps.clear();  
957.         mBannerBitmaps = null;  
958.           
959.         mImageViewList.clear();  
960.         mImageViewList = null;  
961.           
962.         mBannerItemsList.clear();  
963.         mBannerItemsList = null;      
964.     }  
965.       
966.     //单击事件  
967.     @Override  
968.     public void onBannerClick( BannerMotionEvent bannerMotionEvent )  
969.     {  
970.         final int position = bannerMotionEvent.index;  
971.         if(mContext == null)  
972.             return;  
973.           
974.         NotificationInfo notificationInfo = new NotificationInfo();  
975.         notificationInfo.msgType = bannerMotionEvent.getAction();  
976.         int action = bannerMotionEvent.getAction();  
977.         if(action == NotificationInfo.NOTIFICATION_SINGLEGAME_MSG)    //单个游戏消息，直接启动该游戏  
978.         {  
979.             try  
980.             {  
981.                 notificationInfo.gameId = Integer.parseInt( bannerMotionEvent.getGameId() );  
982.                 notificationInfo.gameType = Integer.parseInt( bannerMotionEvent.getGameType() );  
983.             }   
984.             catch (NumberFormatException e)   
985.             {  
986.                 Logger.e(TAG, e.toString());  
987.                 return;  
988.             }  
989.         }  
990.         else if(action == NotificationInfo.NOTIFICATION_GAMEPAGE_MSG)    //游戏主页消息，通过客户端展示游戏主页  
991.         {  
992.             try  
993.             {  
994.                 notificationInfo.gameId = Integer.parseInt( bannerMotionEvent.getGameId() );  
995.             }   
996.             catch (NumberFormatException e)   
997.             {  
998.                 Logger.e(TAG, e.toString());  
999.                 return;  
1000.             }  
1001.             notificationInfo.issueTitle = bannerMotionEvent.getTitle();  
1002.         }  
1003.         else if(action == NotificationInfo.NOTIFICATION_SHOW_WEBVIEW_MSG)    //交叉推广消息，通过一个webview展示  
1004.         {  
1005.             notificationInfo.issueTitle = bannerMotionEvent.getTitle();  
1006.             notificationInfo.openUrl = bannerMotionEvent.getResponseUrl();  
1007.         }  
1008.         else //reserved  
1009.         {  
1010.             return;  
1011.         }  
1012.           
1013.         Intent intent = notificationInfo.generateIntent(mContext);  
1014.         if(intent != null)  
1015.             mContext.startActivity(intent);  
1016.     }  
1017.       
1018.     /** 
1019.      * ScrollBanner所关联的banner项 可以为多个 一个为一屏 
1020.      */  
1021.     public static class BannerItem extends Object  
1022.     {  
1023.         public static final String ACTION = "action";  
1024.         public static final String URL = "url";  
1025.         public static final String IMGURL = "imgurl";  
1026.         public static final String GAMEID = "gameid";  
1027.         public static final String GAMETYPE = "gametype";  
1028.         public static final String TITLE = "title";  
1029.   
1030.         public int index = -1;  
1031.         public int action = -1;  
1032.         public String url = "";  
1033.         public String imgUrl = "";  
1034.         public String gameId = "";  
1035.         public String gameType = "";  
1036.         public String title = "";  
1037.   
1038.         public BannerItem(){}  
1039.     }  
1040.   
1041.     /** 
1042.      * BannerMotionEvent：单击banner所产生的事件对象<br/> 
1043.      *getAction()来获取动作类别<br/> 
1044.      *getResponseUrl()来获取响应url<br/> 
1045.      *... 
1046.      */  
1047.     public static class BannerMotionEvent extends Object  
1048.     {  
1049.         /** 
1050.          * ACTION_PLAY_FLASH： 播放游戏 
1051.          */  
1052.         public static final int ACTION_PLAY = 2;  
1053.         /** 
1054.          * ACTION_HOMEPAGE：打开官网 
1055.          */  
1056.         public static final int ACTION_HOMEPAGE = 3;  
1057.         /** 
1058.          * ACTION_OPEN_URL：打开指定url 
1059.          */  
1060.         public static final int ACTION_OPEN_URL = 4;  
1061.   
1062.         //banner中屏幕的index  
1063.         private int index = -1;  
1064.         //响应url  
1065.         private String responseUrl = "";  
1066.         //动作种类  
1067.         private int action = -1;  
1068.         //gameid  
1069.         private String gameId = "";  
1070.         //gametype flash游戏(0) or h5游戏(1)  
1071.         private String gameType = "";  
1072.         //webview的标题  
1073.         private String title = "";  
1074.           
1075.         public BannerMotionEvent(int index, int action, String responseUrl,   
1076.                 String gameId, String gameType, String title)  
1077.         {  
1078.             BannerMotionEvent.this.index = index;  
1079.             BannerMotionEvent.this.action = action;  
1080.             BannerMotionEvent.this.responseUrl = responseUrl;  
1081.             BannerMotionEvent.this.gameId = gameId;  
1082.             BannerMotionEvent.this.gameType = gameType;  
1083.             BannerMotionEvent.this.title = title;  
1084.         }  
1085.   
1086.         /** 
1087.          * 获取当前BannerMotionEvent事件对象的动作种类 
1088.          * @return 动作种类：ACTION_PLAY等 
1089.          */  
1090.         public int getAction()  
1091.         {  
1092.             return action;  
1093.         }  
1094.   
1095.         /** 
1096.          * 获取当前BannerMotionEvent事件对象的title 
1097.          * @return title webview的标题 
1098.          */  
1099.         public String getTitle()  
1100.         {  
1101.             return title;  
1102.         }  
1103.           
1104.         /** 
1105.          * 获取当前BannerMotionEvent事件对象的gameId 
1106.          * @return gameId 
1107.          */  
1108.         public String getGameId()  
1109.         {  
1110.             return gameId;  
1111.         }  
1112.           
1113.         /** 
1114.          * 获取当前BannerMotionEvent事件对象的gameType 
1115.          * @return gameType 0 or 1 
1116.          */  
1117.         public String getGameType()  
1118.         {  
1119.             return gameType;  
1120.         }  
1121.           
1122.         /** 
1123.          * 获取当前BannerMotionEvent事件对象的响应url 
1124.          * @return 响应url 
1125.          */  
1126.         public String getResponseUrl()  
1127.         {  
1128.             return responseUrl;  
1129.         }  
1130.   
1131.         @SuppressLint("DefaultLocale")  
1132.         @Override  
1133.         public String toString()  
1134.         {  
1135.             return String.format("BannerMotionEvent { index=%d, action=%d, responseUrl=%s, gameId=%s, gameType=%s, title=%s }",   
1136.                     index, action, responseUrl, gameId, gameType, title);  
1137.         }  
1138.     }  
1139.   
1140.     @Override  
1141.     public void onBannerInfoSuccess(List<BannerItem> items)  
1142.     {  
1143.         Logger.d(TAG, "onBannerInfoSuccess");  
1144.         mBannerItemsList = items;  
1145.         mHandler.sendEmptyMessage(MESSAGE_FETCH_BANNER_SUCCESS);  
1146.     }  
1147.   
1148.     @Override  
1149.     public void onBannerInfoFailed()  
1150.     {  
1151.         Logger.e(TAG, "onBannerInfoFailed");  
1152.     }  
1153.   
1154. }  

 

ComponentCallBack.java

[java] view plaincopy

1. public interface ComponentCallBack   
2. {  
3.   
4.     public static interface OnBannerClickListener  
5.     {  
6.         /** 
7.          * banner单击事件 
8.          * @param bannerMotionEvent 单击事件对象，包含所需的响应信息 
9.          * 参见 {@link BannerMotionEvent} 
10.          */  
11.         public abstract void onBannerClick( BannerMotionEvent bannerMotionEvent );  
12.     }  
13.