Android实现Banner界面广告图片循环轮播（包括实现手动滑动循环）

 前言：经常会看到有一些app的banner界面可以实现循环播放多个广告图片和手动滑动循环。本以为单纯的viewpager就可以实现这些功能。但是蛋疼的事情来了，viewpager并不支持循环翻页。所以要实现循环还得需要自己去动手。自己在网上也找了些例子，本博文的demo是结合自己找到的一些相关例子的基础上去改造，也希望对读者有用。

demo实现的效果图如下：

demo代码：

工程目录如下图：

废话不多说，上代码。

1.主activity代码如下：

package com.stevenhu.android.phone.ui; 
import java.util.arraylist; 
import java.util.list; 
import com.nostra13.universalimageloader.cache.disc.naming.md5filenamegenerator; 
import com.nostra13.universalimageloader.core.displayimageoptions; 
import com.nostra13.universalimageloader.core.imageloader; 
import com.nostra13.universalimageloader.core.imageloaderconfiguration; 
import com.nostra13.universalimageloader.core.assist.queueprocessingtype; 
import com.stevenhu.android.phone.bean.adinfo; 
import com.stevenhu.android.phone.utils.viewfactory; 
import android.annotation.suppresslint; 
import android.app.activity; 
import android.os.bundle; 
import android.view.view; 
import android.widget.imageview; 
import android.widget.toast; 
import cn.androiddevelop.cycleviewpager.lib.cycleviewpager; 
import cn.androiddevelop.cycleviewpager.lib.cycleviewpager.imagecycleviewlistener; 
/** 
* 描述：主页 
* 
* @author stevenhu 
* @version 2015年5月8日 上午10:47:37 
*/ 
public class mainactivity extends activity { 
private list<imageview> views = new arraylist<imageview>(); 
private list<adinfo> infos = new arraylist<adinfo>(); 
private cycleviewpager cycleviewpager; 
private string[] imageurls = {"http://img.taodiantong.cn/v55183/infoimg/2013-07/130720115322ky.jpg", 
"http://pic30.nipic.com/20130626/8174275_085522448172_2.jpg", 
"http://pic18.nipic.com/20111215/577405_080531548148_2.jpg", 
"http://pic15.nipic.com/20110722/2912365_092519919000_2.jpg", 
"http://pic.58pic.com/58pic/12/64/27/55u58picrdx.jpg"}; 
@override 
protected void oncreate(bundle savedinstancestate) { 
super.oncreate(savedinstancestate); 
setcontentview(r.layout.ui_main); 
configimageloader(); 
initialize(); 
} 
@suppresslint("newapi") 
private void initialize() { 
cycleviewpager = (cycleviewpager) getfragmentmanager() 
.findfragmentbyid(r.id.fragment_cycle_viewpager_content); 
for(int i = 0; i < imageurls.length; i ++){ 
adinfo info = new adinfo(); 
info.seturl(imageurls[i]); 
info.setcontent("图片-->" + i ); 
infos.add(info); 
} 
// 将最后一个imageview添加进来 
views.add(viewfactory.getimageview(this, infos.get(infos.size() - 1).geturl())); 
for (int i = 0; i < infos.size(); i++) { 
views.add(viewfactory.getimageview(this, infos.get(i).geturl())); 
} 
// 将第一个imageview添加进来 
views.add(viewfactory.getimageview(this, infos.get(0).geturl())); 
// 设置循环，在调用setdata方法前调用 
cycleviewpager.setcycle(true); 
// 在加载数据前设置是否循环 
cycleviewpager.setdata(views, infos, madcycleviewlistener); 
//设置轮播 
cycleviewpager.setwheel(true); 
// 设置轮播时间，默认5000ms 
cycleviewpager.settime(2000); 
//设置圆点指示图标组居中显示，默认靠右 
cycleviewpager.setindicatorcenter(); 
} 
private imagecycleviewlistener madcycleviewlistener = new imagecycleviewlistener() { 
@override 
public void onimageclick(adinfo info, int position, view imageview) { 
if (cycleviewpager.iscycle()) { 
position = position - 1; 
toast.maketext(mainactivity.this, 
"position-->" + info.getcontent(), toast.length_short) 
.show(); 
} 
} 
}; 
/** 
* 配置imageloder 
*/ 
private void configimageloader() { 
// 初始化imageloader 
@suppresswarnings("deprecation") 
displayimageoptions options = new displayimageoptions.builder().showstubimage(r.drawable.icon_stub) // 设置图片下载期间显示的图片 
.showimageforemptyuri(r.drawable.icon_empty) // 设置图片uri为空或是错误的时候显示的图片 
.showimageonfail(r.drawable.icon_error) // 设置图片加载或解码过程中发生错误显示的图片 
.cacheinmemory(true) // 设置下载的图片是否缓存在内存中 
.cacheondisc(true) // 设置下载的图片是否缓存在sd卡中 
// .displayer(new roundedbitmapdisplayer(20)) // 设置成圆角图片 
.build(); // 创建配置过得displayimageoption对象 
imageloaderconfiguration config = new imageloaderconfiguration.builder(getapplicationcontext()).defaultdisplayimageoptions(options) 
.threadpriority(thread.norm_priority - 2).denycacheimagemultiplesizesinmemory() 
.disccachefilenamegenerator(new md5filenamegenerator()).tasksprocessingorder(queueprocessingtype.lifo).build(); 
imageloader.getinstance().init(config); 
} 
} 

2.主文件ui_main.xml代码如下：

<?xml version="1.0" encoding="utf-8"?> 
<linearlayout xmlns:android="http://schemas.android.com/apk/res/android" 
android:layout_width="match_parent" 
android:layout_height="match_parent" 
android:orientation="vertical" > 
<fragment 
android:id="@+id/fragment_cycle_viewpager_content" 
android:name="cn.androiddevelop.cycleviewpager.lib.cycleviewpager" 
android:layout_width="match_parent" 
android:layout_height="180dip" /> 
<relativelayout 
android:layout_width="fill_parent" 
android:layout_height="0dip" 
android:layout_weight="1"> 
<textview 
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:layout_centerinparent="true" 
android:text="content"/> 
</relativelayout> 
</linearlayout> 

3.cycleviewpager类代码如下：

package cn.androiddevelop.cycleviewpager.lib; 
import java.util.arraylist; 
import java.util.list; 
import android.annotation.suppresslint; 
import android.app.fragment; 
import android.os.bundle; 
import android.os.message; 
import android.support.v4.view.pageradapter; 
import android.support.v4.view.viewpager.onpagechangelistener; 
import android.view.layoutinflater; 
import android.view.view; 
import android.view.view.onclicklistener; 
import android.view.viewgroup; 
import android.widget.framelayout; 
import android.widget.imageview; 
import android.widget.linearlayout; 
import android.widget.relativelayout; 
import com.stevenhu.android.phone.bean.adinfo; 
import com.stevenhu.android.phone.ui.r; 
/** 
* 实现可循环，可轮播的viewpager 
*/ 
@suppresslint("newapi") 
public class cycleviewpager extends fragment implements onpagechangelistener { 
private list<imageview> imageviews = new arraylist<imageview>(); 
private imageview[] indicators; 
private framelayout viewpagerfragmentlayout; 
private linearlayout indicatorlayout; // 指示器 
private baseviewpager viewpager; 
private baseviewpager parentviewpager; 
private viewpageradapter adapter; 
private cycleviewpagerhandler handler; 
private int time = 5000; // 默认轮播时间 
private int currentposition = 0; // 轮播当前位置 
private boolean isscrolling = false; // 滚动框是否滚动着 
private boolean iscycle = false; // 是否循环 
private boolean iswheel = false; // 是否轮播 
private long releasetime = 0; // 手指松开、页面不滚动时间，防止手机松开后短时间进行切换 
private int wheel = 100; // 转动 
private int wheel_wait = 101; // 等待 
private imagecycleviewlistener mimagecycleviewlistener; 
private list<adinfo> infos; 
@override 
public view oncreateview(layoutinflater inflater, viewgroup container, 
bundle savedinstancestate) { 
view view = layoutinflater.from(getactivity()).inflate( 
r.layout.view_cycle_viewpager_contet, null); 
viewpager = (baseviewpager) view.findviewbyid(r.id.viewpager); 
indicatorlayout = (linearlayout) view 
.findviewbyid(r.id.layout_viewpager_indicator); 
viewpagerfragmentlayout = (framelayout) view 
.findviewbyid(r.id.layout_viewager_content); 
handler = new cycleviewpagerhandler(getactivity()) { 
@override 
public void handlemessage(message msg) { 
super.handlemessage(msg); 
if (msg.what == wheel && imageviews.size() != 0) { 
if (!isscrolling) { 
int max = imageviews.size() + 1; 
int position = (currentposition + 1) % imageviews.size(); 
viewpager.setcurrentitem(position, true); 
if (position == max) { // 最后一页时回到第一页 
viewpager.setcurrentitem(1, false); 
} 
} 
releasetime = system.currenttimemillis(); 
handler.removecallbacks(runnable); 
handler.postdelayed(runnable, time); 
return; 
} 
if (msg.what == wheel_wait && imageviews.size() != 0) { 
handler.removecallbacks(runnable); 
handler.postdelayed(runnable, time); 
} 
} 
}; 
return view; 
} 
public void setdata(list<imageview> views, list<adinfo> list, imagecycleviewlistener listener) { 
setdata(views, list, listener, 0); 
} 
/** 
* 初始化viewpager 
* 
* @param views 
* 要显示的views 
* @param showposition 
* 默认显示位置 
*/ 
public void setdata(list<imageview> views, list<adinfo> list, imagecycleviewlistener listener, int showposition) { 
mimagecycleviewlistener = listener; 
infos = list; 
this.imageviews.clear(); 
if (views.size() == 0) { 
viewpagerfragmentlayout.setvisibility(view.gone); 
return; 
} 
for (imageview item : views) { 
this.imageviews.add(item); 
} 
int ivsize = views.size(); 
// 设置指示器 
indicators = new imageview[ivsize]; 
if (iscycle) 
indicators = new imageview[ivsize - 2]; 
indicatorlayout.removeallviews(); 
for (int i = 0; i < indicators.length; i++) { 
view view = layoutinflater.from(getactivity()).inflate( 
r.layout.view_cycle_viewpager_indicator, null); 
indicators[i] = (imageview) view.findviewbyid(r.id.image_indicator); 
indicatorlayout.addview(view); 
} 
adapter = new viewpageradapter(); 
// 默认指向第一项，下方viewpager.setcurrentitem将触发重新计算指示器指向 
setindicator(0); 
viewpager.setoffscreenpagelimit(3); 
viewpager.setonpagechangelistener(this); 
viewpager.setadapter(adapter); 
if (showposition < 0 || showposition >= views.size()) 
showposition = 0; 
if (iscycle) { 
showposition = showposition + 1; 
} 
viewpager.setcurrentitem(showposition); 
} 
/** 
* 设置指示器居中，默认指示器在右方 
*/ 
public void setindicatorcenter() { 
relativelayout.layoutparams params = new relativelayout.layoutparams( 
relativelayout.layoutparams.wrap_content, 
relativelayout.layoutparams.wrap_content); 
params.addrule(relativelayout.align_parent_bottom); 
params.addrule(relativelayout.center_horizontal); 
indicatorlayout.setlayoutparams(params); 
} 
/** 
* 是否循环，默认不开启，开启前，请将views的最前面与最后面各加入一个视图，用于循环 
* 
* @param iscycle 
* 是否循环 
*/ 
public void setcycle(boolean iscycle) { 
this.iscycle = iscycle; 
} 
/** 
* 是否处于循环状态 
* 
* @return 
*/ 
public boolean iscycle() { 
return iscycle; 
} 
/** 
* 设置是否轮播，默认不轮播,轮播一定是循环的 
* 
* @param iswheel 
*/ 
public void setwheel(boolean iswheel) { 
this.iswheel = iswheel; 
iscycle = true; 
if (iswheel) { 
handler.postdelayed(runnable, time); 
} 
} 
/** 
* 是否处于轮播状态 
* 
* @return 
*/ 
public boolean iswheel() { 
return iswheel; 
} 
final runnable runnable = new runnable() { 
@override 
public void run() { 
if (getactivity() != null && !getactivity().isfinishing() 
&& iswheel) { 
long now = system.currenttimemillis(); 
// 检测上一次滑动时间与本次之间是否有触击(手滑动)操作，有的话等待下次轮播 
if (now - releasetime > time - 500) { 
handler.sendemptymessage(wheel); 
} else { 
handler.sendemptymessage(wheel_wait); 
} 
} 
} 
}; 
/** 
* 释放指示器高度，可能由于之前指示器被限制了高度，此处释放 
*/ 
public void releaseheight() { 
getview().getlayoutparams().height = relativelayout.layoutparams.match_parent; 
refreshdata(); 
} 
/** 
* 设置轮播暂停时间，即没多少秒切换到下一张视图.默认5000ms 
* 
* @param time 
* 毫秒为单位 
*/ 
public void settime(int time) { 
this.time = time; 
} 
/** 
* 刷新数据，当外部视图更新后，通知刷新数据 
*/ 
public void refreshdata() { 
if (adapter != null) 
adapter.notifydatasetchanged(); 
} 
/** 
* 隐藏cycleviewpager 
*/ 
public void hide() { 
viewpagerfragmentlayout.setvisibility(view.gone); 
} 
/** 
* 返回内置的viewpager 
* 
* @return viewpager 
*/ 
public baseviewpager getviewpager() { 
return viewpager; 
} 
/** 
* 页面适配器 返回对应的view 
* 
* @author yuedong li 
* 
*/ 
private class viewpageradapter extends pageradapter { 
@override 
public int getcount() { 
return imageviews.size(); 
} 
@override 
public boolean isviewfromobject(view arg0, object arg1) { 
return arg0 == arg1; 
} 
@override 
public void destroyitem(viewgroup container, int position, object object) { 
container.removeview((view) object); 
} 
@override 
public view instantiateitem(viewgroup container, final int position) { 
imageview v = imageviews.get(position); 
if (mimagecycleviewlistener != null) { 
v.setonclicklistener(new onclicklistener() { 
@override 
public void onclick(view v) { 
mimagecycleviewlistener.onimageclick(infos.get(currentposition - 1), currentposition, v); 
} 
}); 
} 
container.addview(v); 
return v; 
} 
@override 
public int getitemposition(object object) { 
return position_none; 
} 
} 
@override 
public void onpagescrollstatechanged(int arg0) { 
if (arg0 == 1) { // viewpager在滚动 
isscrolling = true; 
return; 
} else if (arg0 == 0) { // viewpager滚动结束 
if (parentviewpager != null) 
parentviewpager.setscrollable(true); 
releasetime = system.currenttimemillis(); 
viewpager.setcurrentitem(currentposition, false); 
} 
isscrolling = false; 
} 
@override 
public void onpagescrolled(int arg0, float arg1, int arg2) { 
} 
@override 
public void onpageselected(int arg0) { 
int max = imageviews.size() - 1; 
int position = arg0; 
currentposition = arg0; 
if (iscycle) { 
if (arg0 == 0) { 
currentposition = max - 1; 
} else if (arg0 == max) { 
currentposition = 1; 
} 
position = currentposition - 1; 
} 
setindicator(position); 
} 
/** 
* 设置viewpager是否可以滚动 
* 
* @param enable 
*/ 
public void setscrollable(boolean enable) { 
viewpager.setscrollable(enable); 
} 
/** 
* 返回当前位置,循环时需要注意返回的position包含之前在views最前方与最后方加入的视图，即当前页面试图在views集合的位置 
* 
* @return 
*/ 
public int getcurrentpostion() { 
return currentposition; 
} 
/** 
* 设置指示器 
* 
* @param selectedposition 
* 默认指示器位置 
*/ 
private void setindicator(int selectedposition) { 
for (int i = 0; i < indicators.length; i++) { 
indicators[i] 
.setbackgroundresource(r.drawable.icon_point); 
} 
if (indicators.length > selectedposition) 
indicators[selectedposition] 
.setbackgroundresource(r.drawable.icon_point_pre); 
} 
/** 
* 如果当前页面嵌套在另一个viewpager中，为了在进行滚动时阻断父viewpager滚动，可以 阻止父viewpager滑动事件 
* 父viewpager需要实现parentviewpager中的setscrollable方法 
*/ 
public void disableparentviewpagertouchevent(baseviewpager parentviewpager) { 
if (parentviewpager != null) 
parentviewpager.setscrollable(false); 
} 
/** 
* 轮播控件的监听事件 
* 
* @author minking 
*/ 
public static interface imagecycleviewlistener { 
/** 
* 单击图片事件 
* 
* @param position 
* @param imageview 
*/ 
public void onimageclick(adinfo info, int postion, view imageview); 
} 
}

cycleviewpager类为实现可循环，可轮播的viewpager的核心类，继承自fragment，具体实现原理就不多说了，代码中都有相关的注释。

以上所述是小编给大家介绍的android实现banner界面广告图片循环轮播（包括实现手动滑动循环)，希望对大家有所帮助！