Android 第三方控件Banner轮播 将指示器放在图片下面

最新推荐文章于 2024-05-25 22:07:27 发布
最新推荐文章于 2024-05-25 22:07:27 发布
阅读量3.7k 收藏 9
点赞数 2
分类专栏： 累积知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30944187/article/details/100989754
版权

 

首先看效果图

  导入 banner架包 “com.youth.banner:banner:1.4.10”   

1、这里我们需要布局代码

  针对布局文件进行修改R.layout.banner_view.xml

RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@id/bannerContainer"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clipChildren="false">

    <com.youth.banner.view.BannerViewPager
        android:id="@id/bannerViewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_above="@+id/relative_layout"
        android:clipChildren="false" />

    <RelativeLayout
        android:id="@+id/relative_layout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true">

        <LinearLayout
            android:id="@id/circleIndicator"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="bottom"
            android:gravity="center_horizontal"
            android:orientation="horizontal"
            android:padding="10dp"
            android:visibility="gone" />

        <TextView
            android:id="@id/numIndicator"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_alignParentRight="true"
            android:layout_margin="8dp"
            android:background="@drawable/black_background"
            android:gravity="center"
            android:text="1/1"
            android:textColor="#ffffff"
            android:visibility="gone" />

        <LinearLayout
            android:id="@id/titleView"
            android:layout_width="match_parent"
            android:layout_height="40dp"
            android:layout_below="@+id/circleIndicator"
            android:background="#44000000"
            android:orientation="horizontal"
            android:visibility="gone">

            <TextView
                android:id="@id/bannerTitle"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_weight="1000"
                android:ellipsize="marquee"
                android:focusable="true"
                android:focusableInTouchMode="true"
                android:gravity="center_vertical"
                android:paddingLeft="10dp"
                android:singleLine="true"
                android:textColor="#ffffff"
                android:visibility="gone" />

            <FrameLayout
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:paddingLeft="10dp"
                android:paddingRight="10dp">

                <TextView
                    android:id="@id/numIndicatorInside"
                    android:layout_width="wrap_content"
                    android:layout_height="match_parent"
                    android:gravity="center_vertical"
                    android:text="1/1"
                    android:textColor="#ffffff"
                    android:visibility="gone" />

                <LinearLayout
                    android:id="@id/indicatorInside"
                    android:layout_width="wrap_content"
                    android:layout_height="match_parent"
                    android:gravity="center_vertical"
                    android:orientation="horizontal"
                    android:visibility="gone" />
            </FrameLayout>
        </LinearLayout>
    </RelativeLayout>
    <ImageView
        android:id="@+id/bannerDefaultImage"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="centerCrop"
        android:visibility="gone"/>
</RelativeLayout>

这里布局文件就是将指示器放在图片下面，大小，样式可以自己设置

自定义banner代码修改，如下

public class BannerView extends FrameLayout implements OnPageChangeListener {
    public String tag = "banner";
    private int mIndicatorMargin = BannerConfig.PADDING_SIZE;
    private int mIndicatorWidth;
    private int mIndicatorHeight;
    private int indicatorSize;
    private int bannerBackgroundImage;
    private int bannerStyle = BannerConfig.CIRCLE_INDICATOR;
    private int delayTime = BannerConfig.TIME;
    private int scrollTime = BannerConfig.DURATION;
    private boolean isAutoPlay = BannerConfig.IS_AUTO_PLAY;
    private boolean isScroll = BannerConfig.IS_SCROLL;
    private int mIndicatorSelectedResId = com.youth.banner.R.drawable.gray_radius;
    private int mIndicatorUnselectedResId = com.youth.banner.R.drawable.white_radius;
    private int mLayoutResId = R.layout.banner_view;
    private int titleHeight;
    private int titleBackground;
    private int titleTextColor;
    private int titleTextSize;
    private int count = 0;
    private int currentItem;
    private int gravity = -1;
    private int lastPosition = 1;
    private int scaleType = 1;
    private List<String> titles;
    private List imageUrls;
    private List<View> imageViews;
    private List<ImageView> indicatorImages;
    private Context context;
    private BannerViewPager viewPager;
    private TextView bannerTitle, numIndicatorInside, numIndicator;
    private LinearLayout indicator, indicatorInside, titleView;
    private ImageView bannerDefaultImage;
    private ImageLoaderInterface imageLoader;
    private BannerPagerAdapter adapter;
    private OnPageChangeListener mOnPageChangeListener;
    private BannerScroller mScroller;
    private OnBannerClickListener bannerListener;
    private OnBannerListener listener;
    private DisplayMetrics dm;

    private WeakHandler handler = new WeakHandler();

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

    public BannerView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public BannerView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        this.context = context;
        titles = new ArrayList<>();
        imageUrls = new ArrayList<>();
        imageViews = new ArrayList<>();
        indicatorImages = new ArrayList<>();
        dm = context.getResources().getDisplayMetrics();
        indicatorSize = dm.widthPixels / 80;
        initView(context, attrs);
    }

    private void initView(Context context, AttributeSet attrs) {
        imageViews.clear();
        handleTypedArray(context, attrs);
        View view = LayoutInflater.from(context).inflate(mLayoutResId, this, true);
        bannerDefaultImage = (ImageView) view.findViewById(R.id.bannerDefaultImage);
        viewPager = (BannerViewPager) view.findViewById(com.youth.banner.R.id.bannerViewPager);
        titleView = (LinearLayout) view.findViewById(R.id.titleView);
        indicator = (LinearLayout) view.findViewById(R.id.circleIndicator);
        indicatorInside = (LinearLayout) view.findViewById(R.id.indicatorInside);
        bannerTitle = (TextView) view.findViewById(R.id.bannerTitle);
        numIndicator = (TextView) view.findViewById(R.id.numIndicator);
        numIndicatorInside = (TextView) view.findViewById(R.id.numIndicatorInside);
        bannerDefaultImage.setImageResource(bannerBackgroundImage);
        initViewPagerScroll();
    }

    private void handleTypedArray(Context context, AttributeSet attrs) {
        if (attrs == null) {
            return;
        }
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.Banner);
        mIndicatorWidth = typedArray.getDimensionPixelSize(com.youth.banner.R.styleable.Banner_indicator_width, indicatorSize);
        mIndicatorHeight = typedArray.getDimensionPixelSize(com.youth.banner.R.styleable.Banner_indicator_height, indicatorSize);
        mIndicatorMargin = typedArray.getDimensionPixelSize(com.youth.banner.R.styleable.Banner_indicator_margin, BannerConfig.PADDING_SIZE);
        mIndicatorSelectedResId = typedArray.getResourceId(com.youth.banner.R.styleable.Banner_indicator_drawable_selected, com.youth.banner.R.drawable.gray_radius);
        mIndicatorUnselectedResId = typedArray.getResourceId(com.youth.banner.R.styleable.Banner_indicator_drawable_unselected, com.youth.banner.R.drawable.white_radius);
        scaleType = typedArray.getInt(com.youth.banner.R.styleable.Banner_image_scale_type, scaleType);
        delayTime = typedArray.getInt(com.youth.banner.R.styleable.Banner_delay_time, BannerConfig.TIME);
        scrollTime = typedArray.getInt(com.youth.banner.R.styleable.Banner_scroll_time, BannerConfig.DURATION);
        isAutoPlay = typedArray.getBoolean(com.youth.banner.R.styleable.Banner_is_auto_play, BannerConfig.IS_AUTO_PLAY);
        titleBackground = typedArray.getColor(com.youth.banner.R.styleable.Banner_title_background, BannerConfig.TITLE_BACKGROUND);
        titleHeight = typedArray.getDimensionPixelSize(com.youth.banner.R.styleable.Banner_title_height, BannerConfig.TITLE_HEIGHT);
        titleTextColor = typedArray.getColor(com.youth.banner.R.styleable.Banner_title_textcolor, BannerConfig.TITLE_TEXT_COLOR);
        titleTextSize = typedArray.getDimensionPixelSize(com.youth.banner.R.styleable.Banner_title_textsize, BannerConfig.TITLE_TEXT_SIZE);
        mLayoutResId = typedArray.getResourceId(com.youth.banner.R.styleable.Banner_banner_layout, mLayoutResId);
        bannerBackgroundImage = typedArray.getResourceId(com.youth.banner.R.styleable.Banner_banner_default_image, com.youth.banner.R.drawable.no_banner);
        typedArray.recycle();
    }

    private void initViewPagerScroll() {
        try {
            Field mField = ViewPager.class.getDeclaredField("mScroller");
            mField.setAccessible(true);
            mScroller = new BannerScroller(viewPager.getContext());
            mScroller.setDuration(scrollTime);
            mField.set(viewPager, mScroller);
        } catch (Exception e) {
            Log.e(tag, e.getMessage());
        }
    }


    public BannerView isAutoPlay(boolean isAutoPlay) {
        this.isAutoPlay = isAutoPlay;
        return this;
    }

    public BannerView setImageLoader(ImageLoaderInterface imageLoader) {
        this.imageLoader = imageLoader;
        return this;
    }

    public BannerView setDelayTime(int delayTime) {
        this.delayTime = delayTime;
        return this;
    }

    public BannerView setIndicatorGravity(int type) {
        switch (type) {
            case BannerConfig.LEFT:
                this.gravity = Gravity.LEFT | Gravity.CENTER_VERTICAL;
                break;
            case BannerConfig.CENTER:
                this.gravity = Gravity.CENTER;
                break;
            case BannerConfig.RIGHT:
                this.gravity = Gravity.RIGHT | Gravity.CENTER_VERTICAL;
                break;
        }
        return this;
    }

    public BannerView setBannerAnimation(Class<? extends PageTransformer> transformer) {
        try {
            setPageTransformer(true, transformer.newInstance());
        } catch (Exception e) {
            Log.e(tag, "Please set the PageTransformer class");
        }
        return this;
    }

    /**
     * Set the number of pages that should be retained to either side of the
     * current page in the view hierarchy in an idle state. Pages beyond this
     * limit will be recreated from the adapter when needed.
     *
     * @param limit How many pages will be kept offscreen in an idle state.
     * @return Banner
     */
    public BannerView setOffscreenPageLimit(int limit) {
        if (viewPager != null) {
            viewPager.setOffscreenPageLimit(limit);
        }
        return this;
    }

    /**
     * Set a {@link PageTransformer} that will be called for each attached page whenever
     * the scroll position is changed. This allows the application to apply custom property
     * transformations to each page, overriding the default sliding look and feel.
     *
     * @param reverseDrawingOrder true if the supplied PageTransformer requires page views
     *                            to be drawn from last to first instead of first to last.
     * @param transformer         PageTransformer that will modify each page's animation properties
     * @return Banner
     */
    public BannerView setPageTransformer(boolean reverseDrawingOrder, PageTransformer transformer) {
        viewPager.setPageTransformer(reverseDrawingOrder, transformer);
        return this;
    }

    public BannerView setBannerTitles(List<String> titles) {
        this.titles = titles;
        return this;
    }

    public BannerView setBannerStyle(int bannerStyle) {
        this.bannerStyle = bannerStyle;
        return this;
    }

    public BannerView setViewPagerIsScroll(boolean isScroll) {
        this.isScroll = isScroll;
        return this;
    }

    public BannerView setImages(List<?> imageUrls) {
        this.imageUrls = imageUrls;
        this.count = imageUrls.size();
        return this;
    }

    public void update(List<?> imageUrls, List<String> titles) {
        this.titles.clear();
        this.titles.addAll(titles);
        update(imageUrls);
    }

    public void update(List<?> imageUrls) {
        this.imageUrls.clear();
        this.imageViews.clear();
        this.indicatorImages.clear();
        this.imageUrls.addAll(imageUrls);
        this.count = this.imageUrls.size();
        start();
    }

    public void updateBannerStyle(int bannerStyle) {
        indicator.setVisibility(GONE);
        numIndicator.setVisibility(GONE);
        numIndicatorInside.setVisibility(GONE);
        indicatorInside.setVisibility(GONE);
        bannerTitle.setVisibility(View.GONE);
        titleView.setVisibility(View.GONE);
        this.bannerStyle = bannerStyle;
        start();
    }

    public BannerView start() {
        setBannerStyleUI();
        setImageList(imageUrls);
        setData();
        return this;
    }

    private void setTitleStyleUI() {
        if (titles.size() != imageUrls.size()) {
            throw new RuntimeException("[Banner] --> The number of titles and images is different");
        }
        if (titleBackground != -1) {
            titleView.setBackgroundColor(titleBackground);
        }
        if (titleHeight != -1) {
            titleView.setLayoutParams(new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, titleHeight));
        }
        if (titleTextColor != -1) {
            bannerTitle.setTextColor(titleTextColor);
        }
        if (titleTextSize != -1) {
            bannerTitle.setTextSize(TypedValue.COMPLEX_UNIT_PX, titleTextSize);
        }
        if (titles != null && titles.size() > 0) {
            bannerTitle.setText(titles.get(0));
            bannerTitle.setVisibility(View.VISIBLE);
            titleView.setVisibility(View.VISIBLE);
        }
    }

    private void setBannerStyleUI() {
        int visibility =count > 1 ? View.VISIBLE :View.GONE;
        switch (bannerStyle) {
            case BannerConfig.CIRCLE_INDICATOR:
                indicator.setVisibility(visibility);
                break;
            case BannerConfig.NUM_INDICATOR:
                numIndicator.setVisibility(visibility);
                break;
            case BannerConfig.NUM_INDICATOR_TITLE:
                numIndicatorInside.setVisibility(visibility);
                setTitleStyleUI();
                break;
            case BannerConfig.CIRCLE_INDICATOR_TITLE:
                indicator.setVisibility(visibility);
                setTitleStyleUI();
                break;
            case BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE:
                indicatorInside.setVisibility(visibility);
                setTitleStyleUI();
                break;
        }
    }

    private void initImages() {
        imageViews.clear();
        if (bannerStyle == BannerConfig.CIRCLE_INDICATOR ||
                bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE ||
                bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE) {
            createIndicator();
        } else if (bannerStyle == BannerConfig.NUM_INDICATOR_TITLE) {
            numIndicatorInside.setText("1/" + count);
        } else if (bannerStyle == BannerConfig.NUM_INDICATOR) {
            numIndicator.setText("1/" + count);
        }
    }

    private void setImageList(List<?> imagesUrl) {
        if (imagesUrl == null || imagesUrl.size() <= 0) {
            bannerDefaultImage.setVisibility(VISIBLE);
            Log.e(tag, "The image data set is empty.");
            return;
        }
        bannerDefaultImage.setVisibility(GONE);
        initImages();

        for (int i = 0; i <= count + 1; i++) {
            View imageView = null;

            if (imageLoader != null) {
                imageView = imageLoader.createImageView(context);
                imageView.setElevation(10);
                setScaleType(imageView);
            }
            if (imageView == null) {
                imageView = new ImageView(context);
            }

            Object url = null;
            if (i == 0) {
                url = imagesUrl.get(count - 1);
            } else if (i == count + 1) {
                url = imagesUrl.get(0);
            } else {
                url = imagesUrl.get(i - 1);
            }
            imageViews.add(imageView);
            if (imageLoader != null)
                imageLoader.displayImage(context, url, imageView);
            else
                Log.e(tag, "Please set images loader.");
        }
    }

//重新设置

    private void setScaleType(View imageView) {
        if (imageView instanceof ImageView) {
            ImageView view = ((ImageView) imageView);
            switch (scaleType) {
                case 0:
                    view.setScaleType(ScaleType.CENTER);
                    break;
                case 1:
                    view.setScaleType(ScaleType.CENTER_CROP);
                    break;
                case 2:
                    view.setScaleType(ScaleType.CENTER_INSIDE);
                    break;
                case 3:
                    view.setScaleType(ScaleType.FIT_CENTER);
                    break;
                case 4:
                    view.setScaleType(ScaleType.FIT_END);
                    break;
                case 5:
                    view.setScaleType(ScaleType.FIT_START);
                    break;
                case 6:
                    view.setScaleType(ScaleType.FIT_XY);
                    break;
                case 7:
                    view.setScaleType(ScaleType.MATRIX);
                    break;
            }

        }
    }

    private void createIndicator() {
        indicatorImages.clear();
        indicator.removeAllViews();
        indicatorInside.removeAllViews();
        for (int i = 0; i < count; i++) {
            ImageView imageView = new ImageView(context);
            imageView.setScaleType(ScaleType.CENTER_CROP);
            LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(mIndicatorWidth, mIndicatorHeight);
            params.leftMargin = mIndicatorMargin;
            params.rightMargin = mIndicatorMargin;
            if (i == 0) {
                imageView.setImageResource(mIndicatorSelectedResId);
            } else {
                imageView.setImageResource(mIndicatorUnselectedResId);
            }
            indicatorImages.add(imageView);
            if (bannerStyle == BannerConfig.CIRCLE_INDICATOR ||
                    bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE)
                indicator.addView(imageView, params);
            else if (bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE)
                indicatorInside.addView(imageView, params);
        }
    }


    private void setData() {
        currentItem = 1;
        if (adapter == null) {
            adapter = new BannerPagerAdapter();
            viewPager.addOnPageChangeListener(this);
        }
        viewPager.setAdapter(adapter);
        viewPager.setFocusable(true);
        viewPager.setCurrentItem(1);
        if (gravity != -1)
            indicator.setGravity(gravity);
        if (isScroll && count > 1) {
            viewPager.setScrollable(true);
        } else {
            viewPager.setScrollable(false);
        }
        if (isAutoPlay)
            startAutoPlay();
    }


    public void startAutoPlay() {
        handler.removeCallbacks(task);
        handler.postDelayed(task, delayTime);
    }

    public void stopAutoPlay() {
        handler.removeCallbacks(task);
    }

    private final Runnable task = new Runnable() {
        @Override
        public void run() {
            if (count > 1 && isAutoPlay) {
                currentItem = currentItem % (count + 1) + 1;
//                Log.i(tag, "curr:" + currentItem + " count:" + count);
                if (currentItem == 1) {
                    viewPager.setCurrentItem(currentItem, false);
                    handler.post(task);
                } else {
                    viewPager.setCurrentItem(currentItem);
                    handler.postDelayed(task, delayTime);
                }
            }
        }
    };

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
//        Log.i(tag, ev.getAction() + "--" + isAutoPlay);
        if (isAutoPlay) {
            int action = ev.getAction();
            if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL
                    || action == MotionEvent.ACTION_OUTSIDE) {
                startAutoPlay();
            } else if (action == MotionEvent.ACTION_DOWN) {
                stopAutoPlay();
            }
        }
        return super.dispatchTouchEvent(ev);
    }

    /**
     * 返回真实的位置
     *
     * @param position
     * @return 下标从0开始
     */
    public int toRealPosition(int position) {
        int realPosition = (position - 1) % count;
        if (realPosition < 0)
            realPosition += count;
        return realPosition;
    }

    class BannerPagerAdapter extends PagerAdapter {

        @Override
        public int getCount() {
            return imageViews.size();
        }

        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view == object;
        }

        @Override
        public Object instantiateItem(ViewGroup container, final int position) {
       //  这里是我开发过程中逻辑 ，图片需要按照宽高比例进行显示，所以需要更改。 如下操作，
           因为ImageView不是通过xml得到的，这里我需要左右进行缩进，那么我就需要设定magin属性
            LinearLayout view = new LinearLayout(context);
            container.addView(view);
            View viewImg = imageViews.get(position);
            viewImg.setBackground(context.getDrawable(R.drawable.show_view));
            viewImg.setElevation(ScreenUtil.dp2px(context, 8f));
            LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
            lp.setMargins(ScreenUtil.dp2px(context, 16f), ScreenUtil.dp2px(context, 8f), ScreenUtil.dp2px(context, 16f), 0);
            view.addView(viewImg,lp);
            if (bannerListener != null) {
                view.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        Log.e(tag, "你正在使用旧版点击事件接口，下标是从1开始，" +
                                "为了体验请更换为setOnBannerListener，下标从0开始计算");
                        bannerListener.OnBannerClick(position);
                    }
                });
            }
            if (listener != null) {
                view.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        listener.OnBannerClick(toRealPosition(position));
                    }
                });
            }
            return view;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            LinearLayout view = (LinearLayout) object;
            view.removeAllViews();
            container.removeView(view);
        }

    }

    @Override
    public void onPageScrollStateChanged(int state) {
        if (mOnPageChangeListener != null) {
            mOnPageChangeListener.onPageScrollStateChanged(state);
        }
//        Log.i(tag,"currentItem: "+currentItem);
        switch (state) {
            case 0://No operation
                if (currentItem == 0) {
                    viewPager.setCurrentItem(count, false);
                } else if (currentItem == count + 1) {
                    viewPager.setCurrentItem(1, false);
                }
                break;
            case 1://start Sliding
                if (currentItem == count + 1) {
                    viewPager.setCurrentItem(1, false);
                } else if (currentItem == 0) {
                    viewPager.setCurrentItem(count, false);
                }
                break;
            case 2://end Sliding
                break;
        }
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        if (mOnPageChangeListener != null) {
            mOnPageChangeListener.onPageScrolled(toRealPosition(position), positionOffset, positionOffsetPixels);
        }
    }

    @Override
    public void onPageSelected(int position) {
        currentItem=position;
        if (mOnPageChangeListener != null) {
            mOnPageChangeListener.onPageSelected(toRealPosition(position));
        }
        if (bannerStyle == BannerConfig.CIRCLE_INDICATOR ||
                bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE ||
                bannerStyle == BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE) {
            indicatorImages.get((lastPosition - 1 + count) % count).setImageResource(mIndicatorUnselectedResId);
            indicatorImages.get((position - 1 + count) % count).setImageResource(mIndicatorSelectedResId);
            lastPosition = position;
        }
        if (position == 0) position = count;
        if (position > count) position = 1;
        switch (bannerStyle) {
            case BannerConfig.CIRCLE_INDICATOR:
                break;
            case BannerConfig.NUM_INDICATOR:
                numIndicator.setText(position + "/" + count);
                break;
            case BannerConfig.NUM_INDICATOR_TITLE:
                numIndicatorInside.setText(position + "/" + count);
                bannerTitle.setText(titles.get(position - 1));
                break;
            case BannerConfig.CIRCLE_INDICATOR_TITLE:
                bannerTitle.setText(titles.get(position - 1));
                break;
            case BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE:
                bannerTitle.setText(titles.get(position - 1));
                break;
        }

    }

    @Deprecated
    public BannerView setOnBannerClickListener(OnBannerClickListener listener) {
        this.bannerListener = listener;
        return this;
    }

    /**
     * 废弃了旧版接口，新版的接口下标是从1开始，同时解决下标越界问题
     *
     * @param listener
     * @return
     */
    public BannerView setOnBannerListener(OnBannerListener listener) {
        this.listener = listener;
        return this;
    }

    public void setOnPageChangeListener(OnPageChangeListener onPageChangeListener) {
        mOnPageChangeListener = onPageChangeListener;
    }

    public void releaseBanner() {
        handler.removeCallbacksAndMessages(null);
    }
}

  以上处理的是banner的源代码部分，在activity中的使用 

/**
 * 获得屏幕宽度
 */
public static int getScreenWidth(Context context) {
    WindowManager wm = (WindowManager) context
            .getSystemService(Context.WINDOW_SERVICE);
    DisplayMetrics outMetrics = new DisplayMetrics();
    wm.getDefaultDisplay().getMetrics(outMetrics);
    return outMetrics.widthPixels;
}

// 设置 控件宽/高比例  ( view 控件)，根据需要自行设置

int screenWidth = getScreenWidth(this);
ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
layoutParams.width = screenWidth;
layoutParams.height = (layoutParams.width -控件左右俩边间距之和 ) * 4 / 9 + 上下间距之和;
view.setLayoutParams(layoutParams);

启动banner

 设置数据bannerImage（）

mBanner.update(bannerImage());

加载图片

mBanner.setImageLoader(new ImageLoader() {
    @Override
    public void displayImage(Context context, Object path, ImageView imageView) {
        //imageView铺满屏幕
        imageView.setScaleType(ImageView.ScaleType.CENTER);
        GlideApp
                .with(mContext)
                .load(path)
                .transform(new GlideRoundTransform(mContext, 8))
                .into(imageView);
    }
});
// 显示圆形指示器
mBanner.setBannerStyle(BannerConfig.CIRCLE_INDICATOR);
//指示器居中
mBanner.setIndicatorGravity(BannerConfig.CENTER);
//轮播时间(单位:毫秒)
mBanner.setDelayTime(4000);
//图片源
mBanner.setImages(bannerImage());
//banner切换动画效果
//    mBanner.setPageTransformer(true, getPageTransformer());
//启动(必须在最后)
mBanner.start();

ViewPager的切换动画，首先看下效果图（网上获取）这里主要说的是banner也可以实现，效果图如下

 /**
     * 滑动动画
     *
     * @return
     */
    private ViewPager.PageTransformer getPageTransformer() {
        ViewPager.PageTransformer pageTransformer;
        // type 为1或者3为缩放翻页动画
        pageTransformer = new ViewPager.PageTransformer() {
            @Override
            public void transformPage(View page, float position) {
                if (position >= -1.0f && position <= 0.0f) {
                    // 控制左侧滑入或者划出View缩放比例
                    page.setScaleX(1 + position * 0.1f);
                    page.setScaleY(1 + position * 0.2f);
                } else if (position > 0.0f && position <= 1.0f) {
                    // 控制右侧滑入或者划出View缩放比例
                    page.setScaleX(1 - position * 0.1f);
                    page.setScaleY(1 - position * 0.2f);
                } else {
                    // 控制其它View缩放比例
                    page.setScaleX(0.9f);
                    page.setScaleY(0.8f);
                }
            }
        };
        return pageTransformer;
    }

mBanner.setPageTransformer(true, getPageTransformer()); 主要代码

以上仅供参考，部分代码针对我的项目工程需要的，上面的代码都是可以实现功能的，demo有时间上传

 

 

小小布点_lbq
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
仿京东轮播指示器
12-03
仿京东首页轮播指示器，主要通过自定义view来实现，轮播用的banner
Android实现带指示器的自动轮播式ViewPager
08-31
主要为大家详细介绍了Android实现带指示器的自动轮播式ViewPager的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android com.youth.banner.Banner设置圆角
最新发布
qq_27494201的博客
05-25 309
【代码】Android com.youth.banner.Banner设置圆角。
从零开始学习自定义view【2】com.youth.banner:banner库下的自定义Indicator指示器
jiet_h的博客
06-26 4222
com.youth.banner:banner库提供了一些默认的Indicator样式，例如圆点指示器。如果我们想要自定义Indicator的样式，可以使用setIndicator()方法来设置。可以设置圆点的大小、间距、颜色等属性，以满足我们的设计需求。自定义MyCircleIndicator : 其实就是com.youth.banner:banner库下的CircleIndicator的kotlin版本，只不过我们可以在此基础上进行自定义，但前提是我们得先看懂youth作者写的代码。
android-轮播图插件banner的使用
Willow_Spring的博客
02-02 5593
今天学习banner的使用 一、添加banner的依赖，youth下的 implementation 'com.youth.banner:banner:1.4.10' 二、xml布局添加banner控件 三、主逻辑代码 1、拿到控件 2、初始化轮播图数据，标题数据。网络数据本地数据都行 我这里imgs是图片数据，titles时标题数据 3、设置banner 图片加载器我用glide private void banner() { // 这是图片加载器 banne
安卓轮播图banner的使用和详解
qq_47625961的博客
10-14 3103
轮播图banner 1.首先要导入依赖 //Banner图依赖 implementation 'com.youth.banner:banner:1.4.10' //glide依赖 implementation 'com.github.bumptech.glide:glide:4.0.0-RC1' 2.如果是网络解析图片,这里得在Manifest中添加权限 <!--网络--> <uses-permission android:name="android.permissio
Banner基本使用 2.1.0
ulddfhv的专栏
10-29 8619
Step 1.依赖banner Gradle dependencies{ compile 'com.youth.banner:banner:2.1.0' } Step 2.添加权限到你的 AndroidManifest.xml <!-- if you want to load images from the internet --> <uses-permission android:name="android.permission.INTERNET" />
Android自定义图片轮播Banner控件使用解析
08-27
下面我们将详细介绍Android自定义图片轮播Banner控件的使用方法。 一、控件的主要特点 Android自定义图片轮播Banner控件具有以下主要特点： 1. 支持自定义宽高比例 2. 支持自定义图片切换时间 3. 支持自定义指示...
BannerView:Android BannerView 图片轮播控件，支持无限循环，可设置显示各种样式，支持添加banner切换动画，支持定制各种大小形状不一的指示器。调用简单，代码稳定，体积小
05-16
这是一个轻量简洁的自定义banner控件。欢迎大家提出意见或建议 BannerView在控件可见时自动播放，不可见时停止播放，不需要额外设置界面切换时的开始播放和暂停播放。 Gradle allprojects { repositories { ... ...
Android Banner轮播图效果实现(带下标)
08-13
"Android Banner轮播图效果实现(带下标)"这个话题主要涉及到如何在Android应用中创建一个具有小圆圈指示器的轮播图组件，下面将详细讲解其核心知识点。 1. **使用RecyclerView或ViewPager**: 轮播图的基础框架通常...
Android自定义Banner轮播效果
08-27
下面将详细介绍Android自定义Banner轮播效果的实现方法和关键技术要点。 一、自定义View布局 Android自定义Banner轮播效果的实现需要自定义View布局，使用RelativeLayout作为根布局，内部包含ViewPager和...
Android广告图片轮播控件，banner的简单使用
张雨的博客
09-09 1万+
Android广告图片轮播控件 GitHub地址 https://github.com/youth5201314/banner 1.添加依赖 //图片轮播框架 implementation 'com.youth.banner:banner:1.4.10' //glide，比较好的版本，Matisse版本，配合glide3.7.0，因为后面的glide版本没有了...
Android Banner 轮播图使用方法
qq_19688207的博客
07-16 1910
Banner轮播图
Android——支持图片加视频无限轮播的banner
Saqino的博客
11-25 8629
基于https://github.com/youth5201314/banner扩展，图片+视频无限轮播banner Demo地址 https://gitee.com/saqino/pic-video-banner-demo.git 说明 使用大佬的banner控件是很方便的，但是对视频+图片无限轮播的支持较弱，所以决定重写几个类实现功能。 不重写无法实现的原因如下： 无限轮播模式下，item大于1时， adapter会自动增加两个item，一个在最前，一个在最后，这样子做...
android 循环轮播控件com.youth.banner 的自定义轮播指示器，满足开发需求。
weixin_35861115的博客
10-27 1万+
1：轮播com.youth.banner 轮播图控件com.youth.banner，github地址：https://github.com/youth5201314/banner。 具体使用请看github，简单方便，咱们主要介绍如何自定义指示器。 2：自定义指示器 ...
安卓首页界面：用Banner框架实现Android轮播图效果
qq_68469751的博客
12-20 2767
1111
个人笔记：Kotlin 用banner实现简单轮播图
qq_62870666的博客
04-26 2669
首先在gradle导入依赖 implementation 'com.youth.banner:banner:1.4.10' 在layout中编写如下代码 <com.youth.banner.Banner android:id="@+id/banner" android:layout_width="match_parent" android:layout_height="match_parent" /> 接下来回
Android 轮播图banner框架的使用
阳光大男孩！！！的博客
09-29 2445
最近发现了一个不错的轮播图框架，分享一下。 效果图： 一、添加依赖 在build.gradle中添加banner依赖 implementation ‘com.youth.banner:banner:1.4.10’ 推荐使用glide框架加载图片，本文也使用glide框架 implementation ‘com.github.bumptech.glide:glide:3.7.0’ imple...
android轮播图Banner的使用及详解
热门推荐
五万年前走丢了
07-24 4万+
今天带给大家一个比较实用的轮播图框架，banner 1.导入依赖'com.youth.banner:banner:1.4.9'2.添加权限<uses-permission android:name="android.permission.INTERNET" />//联网 <uses-permission android:name="android.permission.READ_EXTERNAL_
安卓banner轮播控件
04-04
Android中常用的Banner轮播控件有： 1. ViewPager：Android原生控件，支持滑动切换，需要自己实现轮播逻辑。 2. Banner：第三方库，支持自动轮播、手动滑动、无限循环等功能，使用方便。 3. LoopViewPager：第三...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值