Android开发之轮播图

一。XML文件

<fragment
    android:id="@+id/fragment_cycle_viewpager_content"
    android:name="com.after90.luluzhuan.utils.lunbo.CycleViewPager"
    android:layout_width="match_parent"
    android:layout_height="200dp" />
二。activity
记得在活动创建时调用configImageLoader()
  @Override
    public void showBannerSuccess(List<BannerBean> bannerBeen) {
        cycleViewPager = (CycleViewPager) getActivity().getFragmentManager().findFragmentById(R.id.fragment_cycle_viewpager_content);

//        for (int i = 0; i < imageUrls.length; i++) {
//            BannerBean info = new BannerBean();
//            info.setNews_title_image_url(imageUrls[i]);
//            info.setContent("图片-->" + i);
//            infos.add(info);
//        }

        // 将最后一个ImageView添加进来
        views.add(ViewFactory.getImageView(getActivity(), bannerBeen.get(bannerBeen.size() - 1).getNews_title_image_url()));
        for (int i = 0; i < bannerBeen.size(); i++) {
            views.add(ViewFactory.getImageView(getActivity(), bannerBeen.get(i).getNews_title_image_url()));
        }
        // 将第一个ImageView添加进来
        views.add(ViewFactory.getImageView(getActivity(), bannerBeen.get(0).getNews_title_image_url()));

        // 设置循环,在调用setData方法前调用
        cycleViewPager.setCycle(true);

        // 在加载数据前设置是否循环
        cycleViewPager.setData(views, bannerBeen, mAdCycleViewListener);
        //设置轮播
        cycleViewPager.setWheel(true);

        // 设置轮播时间,默认5000ms
        cycleViewPager.setTime(3000);
        //设置圆点指示图标组居中显示,默认靠右
        cycleViewPager.setIndicatorCenter();
    }
    private CycleViewPager.ImageCycleViewListener mAdCycleViewListener = new CycleViewPager.ImageCycleViewListener() {

        @Override
        public void onImageClick(BannerBean info, int position, View imageView) {
            if (cycleViewPager.isCycle()) {
                position = position - 1;
                Toast.makeText(getActivity(),
                        "position-->" + info.getNews_title(), Toast.LENGTH_SHORT)
                        .show();
            }

        }

    };
    /**
     * 配置ImageLoder
     */
    private void configImageLoader() {
        // 初始化ImageLoader
        @SuppressWarnings("deprecation")
        DisplayImageOptions options = new DisplayImageOptions.Builder().showStubImage(R.mipmap.icon_stub) // 设置图片下载期间显示的图片
                .showImageForEmptyUri(R.mipmap.icon_empty) // 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.mipmap.icon_error) // 设置图片加载或解码过程中发生错误显示的图片
                .cacheInMemory(true) // 设置下载的图片是否缓存在内存中
                .cacheOnDisc(true) // 设置下载的图片是否缓存在SD卡中
                // .displayer(new RoundedBitmapDisplayer(20)) // 设置成圆角图片
                .build(); // 创建配置过得DisplayImageOption对象

        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(getActivity()).defaultDisplayImageOptions(options)
                .threadPriority(Thread.NORM_PRIORITY - 2).denyCacheImageMultipleSizesInMemory()
                .discCacheFileNameGenerator(new Md5FileNameGenerator()).tasksProcessingOrder(QueueProcessingType.LIFO).build();
        ImageLoader.getInstance().init(config);
    }

三。工具类

(1)

/**
 * 自定义高度的viewpapger
 */
public class BaseViewPager extends ViewPager {
   private boolean scrollable = true;

   public BaseViewPager(Context context) {
      super(context);
   }

   public BaseViewPager(Context context, AttributeSet attrs) {
      super(context, attrs);
   }

   /**
    * 设置viewpager是否可以滚动
    * 
    * @param enable
    */
   public void setScrollable(boolean enable) {
      scrollable = enable;
   }

   @Override
   public boolean onInterceptTouchEvent(MotionEvent event) {
      if (scrollable) {
         return super.onInterceptTouchEvent(event);
      } else {
         return false;
      }
   }
}
 
(2)
/**
 * 实现可循环,可轮播的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<BannerBean> 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<BannerBean> list, ImageCycleViewListener listener) {
      setData(views, list, listener, 0);
   }

   /**
    * 初始化viewpager
    * 
    * @param views
    *            要显示的views
    * @param showPosition
    *            默认显示位置
    */
   public void setData(List<ImageView> views, List<BannerBean> 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.mipmap.icon_point);
      }
      if (indicators.length > selectedPosition)
         indicators[selectedPosition]
               .setBackgroundResource(R.mipmap.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 imageView
       */
      public void onImageClick(BannerBean info, int postion, View imageView);
   }

(3)
/**
 * 为了防止内存泄漏,定义外部类,防止内部类对外部类的引用
 */
public class CycleViewPagerHandler extends Handler {
    Context context;

   public CycleViewPagerHandler(Context context) {
      this.context = context;
   }
};
(4)
/**
 * ImageView创建工厂
 */
public class ViewFactory {

   /**
    * 获取ImageView视图的同时加载显示url
    * 
    * @return
    */
   public static ImageView getImageView(Context context, String url) {
      ImageView imageView = (ImageView)LayoutInflater.from(context).inflate(
            R.layout.view_banner, null);
      ImageLoader.getInstance().displayImage(url, imageView);
      return imageView;
   }
}













  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值