BannerView Android 只一个方向

原创 已于 2022-07-19 15:25:18 修改 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android

于 2022-02-18 14:31:20 首次发布
本文介绍了BannerView自定义ViewGroup实现的滑动广告组件，包含居中、顶部、底部布局模式，以及左右向滑动和动画效果。核心内容涉及布局计算、视图动画和用户交互控制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

居中 LAYOUT_MODE_CENTER

左侧居中

顶部 LAYOUT_MODE_TOP

顶部

底部 LAYOUT_MODE_BOTTOM

底部

右往左布局 LAYOUT_RIGHT_TO_LEFT

在这里插入图片描述

BannerView
package com.example.bannerdemo;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;


public class BannerView extends ViewGroup implements Runnable {
    private final float SCALE_0 = 0.833333333333f;
    private final float SCALE_1 = 0.916666667f;
    private final float SCALE_2 = 1f;

    private final float ALPHA_0 = 0.4f;
    private final float ALPHA_1 = 0.8f;
    private final float ALPHA_2 = 1.0f;

    private final int DEFAULT_BASELINE = 30;
    // index=0 child baseline
    private int BASELINE_0 = 0;
    // index=1 child baseline
    private int BASELINE_1 = 0;
    // index=2 child baseline
    private int BASELINE_2 = 0;

    //动画间隔时间
    private int waitTime=1000;

    // 只能向左滑动
    private final int SCROLL_ORIENTATION_LEFT = 0;
    // 只能向右滑动
    private final int SCROLL_ORIENTATION_RIGHT = 1;
    // 双向滑动
    private final int SCROLL_ORIENTATION_ALL = 2;

    private final int LAYOUT_MODE_TOP = 0;
    private final int LAYOUT_MODE_CENTER = 1;
    private final int LAYOUT_MODE_BOTTOM = 2;

    private final int LAYOUT_LEFT_TO_RIGHT = 3;
    private final int LAYOUT_RIGHT_TO_LEFT = 4;


    // 布局模式
    int layoutMode = LAYOUT_MODE_CENTER;
    // 布局方向
    int layoutOrientation = LAYOUT_LEFT_TO_RIGHT;
    // 滑动方向
    int scrollOrientation = SCROLL_ORIENTATION_LEFT;
    // baseLine offset 子view偏移量
    int baseLineOffset = DEFAULT_BASELINE;
    // 最上面的左边距
    int topLeftBaseLine = 0;

    //item 点击事件
    private OnItemClickListener onItemClickListener;

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

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

    public BannerView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {

    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        measureChildren(widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension(measureWidth(widthMeasureSpec), measureHeight(heightMeasureSpec));
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);

            int baseLeftLine = getBaseLeftLine(child);
            getBaseTopLine(i);

            layoutChild(child, baseLeftLine);
            if (i == 2) {
                child.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (onItemClickListener != null) {
                            LayoutParams lp = (LayoutParams) child.getLayoutParams();
                            onItemClickListener.onItemClick(lp.dataPosition);
                        }
                    }
                });
            } else {
                child.setOnClickListener(null);
            }
        }
    }

    private int getBaseLeftLine(View child) {
        LayoutParams lp = (LayoutParams) child.getLayoutParams();

        int baseLine = 0;
        switch (lp.fromIndex) {
            case 0:
                if (mOffsetPercent > 0) {
                    baseLine = (int) (BASELINE_0 - mOffsetPercent * BASELINE_1);
                    if (baseLine < BASELINE_1) {
                        baseLine = BASELINE_1;
                    }
                    lp.scale = (float) (SCALE_0 + ((SCALE_1 - SCALE_0) * mOffsetPercent));
                    if (lp.scale > SCALE_1) {
                        lp.scale = SCALE_1;
                    }
                } else {
                    baseLine = (int) (BASELINE_0 + mOffsetPercent * BASELINE_1);
                    if (baseLine < BASELINE_1) {
                        baseLine = BASELINE_1;
                    }
                    lp.scale = (float) (SCALE_0 - ((SCALE_1 - SCALE_0) * mOffsetPercent));
                    if (lp.scale > SCALE_1) {
                        lp.scale = SCALE_1;
                    }
                }

                break;
            case 1:
                // toIndex=2
                if (mOffsetPercent > 0) {
                    baseLine = (int) (BASELINE_1 - mOffsetPercent * BASELINE_1);
                    if (baseLine < BASELINE_2) {
                        baseLine = BASELINE_2;
                    }
                    lp.scale = (float) (SCALE_1 + ((SCALE_2 - SCALE_1) * mOffsetPercent));
                    if (lp.scale > SCALE_2) {
                        lp.scale = SCALE_2;
                    }
                    lp.alpha = (float) (ALPHA_1 + ((ALPHA_2 - ALPHA_1) * mOffsetPercent));
                    if (lp.alpha > ALPHA_2) {
                        lp.alpha = ALPHA_2;
                    }
                } else {
                    baseLine = (int) (BASELINE_1 + mOffsetPercent * BASELINE_1);
                    if (baseLine < BASELINE_2) {
                        baseLine = BASELINE_2;
                    }
                    lp.scale = (float) (SCALE_1 - ((SCALE_2 - SCALE_1) * mOffsetPercent));
                    if (lp.scale > SCALE_2) {
                        lp.scale = SCALE_2;
                    }
                    lp.alpha = (float) (ALPHA_1 - ((ALPHA_2 - ALPHA_1) * mOffsetPercent));
                    if (lp.alpha > ALPHA_2) {
                        lp.alpha = ALPHA_2;
                    }
                }

                break;
            case 2:
                // toIndex= 0
                if (mOffsetPercent > 0) {
                    baseLine = (int) (BASELINE_2 + mOffsetPercent * BASELINE_0);
                    if (baseLine >= BASELINE_0) {
                        baseLine = BASELINE_0;
                    } else {
                        baseLine = (int) (BASELINE_2 + mOffsetPercent * child.getWidth());
                    }
                    lp.scale = (float) (SCALE_2 - ((SCALE_2 - SCALE_0) * mOffsetPercent));
                    if (lp.scale <= SCALE_0) {
                        lp.scale = SCALE_0;
                    } else {
                        lp.scale = SCALE_2;
                    }
                    lp.alpha = (float) (ALPHA_2 - ((ALPHA_2 - ALPHA_0) * mOffsetPercent));
                    if (lp.alpha >= ALPHA_0) {
                        lp.alpha = ALPHA_0;
                    } else {
                        lp.alpha = ALPHA_2;
                    }
                } else {
                    baseLine = (int) (BASELINE_2 + mOffsetPercent * BASELINE_0);
                    if (baseLine >= BASELINE_0) {
                        baseLine = BASELINE_0;
                    } else {
                        baseLine = (int) (BASELINE_2 + mOffsetPercent * child.getWidth());
                    }
                    lp.scale = (float) (SCALE_2 + ((SCALE_2 - SCALE_0) * mOffsetPercent));
                    if (lp.scale <= SCALE_0) {
                        lp.scale = SCALE_0;
                    } else {
                        lp.scale = SCALE_2;
                    }
                    lp.alpha = (float) (ALPHA_2 + ((ALPHA_2 - ALPHA_0) * mOffsetPercent));
                    if (lp.alpha <= ALPHA_0) {
                        lp.alpha = ALPHA_0;
                    } else {
                        lp.alpha = ALPHA_2;
                    }
                }

                break;
        }
        return baseLine;
    }


    private int getBaseTopLine(int index) {
        int baseLine = 0;
        switch (index) {
            case 0:
                baseLine = 40;
                break;
            case 1:
                baseLine = 20;
                break;
            case 2:
                baseLine = 0;
                break;
        }
        return baseLine;
    }

    private void layoutChild(View child, int baseLeftLine) {
        LayoutParams lp = (LayoutParams) child.getLayoutParams();
        child.setAlpha(lp.alpha);
        int childWidth = child.getMeasuredWidth();
        int childHeight = (int) (child.getMeasuredHeight() * lp.scale);

        int top = 0;
        int bottom = 0;
        if (layoutMode == LAYOUT_MODE_CENTER) {
            top = (int) (getHeight() / 2.0f - childHeight / 2.0f);
            bottom = (int) (getHeight() / 2.0f + childHeight / 2.0f);

        } else if (layoutMode == LAYOUT_MODE_BOTTOM) {
            top = getHeight() - childHeight;
            bottom = getHeight();
        } else if (layoutMode == LAYOUT_MODE_TOP) {
            top = 0;
            bottom = childHeight;
        }
        int left = 0;
        int right = 0;
        if (layoutOrientation == LAYOUT_LEFT_TO_RIGHT) {
            left = baseLeftLine;
            right = left + childWidth;
        } else if (layoutOrientation == LAYOUT_RIGHT_TO_LEFT) {
            right = getWidth() - baseLeftLine;
            left = right - childWidth;
        }
        child.layout(left + lp.leftMargin, top + lp.topMargin, right + lp.rightMargin, bottom + lp.bottomMargin);

    }

    private int measureWidth(int widthMeasureSpec) {
        int width = 0;
        int mode = MeasureSpec.getMode(widthMeasureSpec);
        int size = MeasureSpec.getSize(widthMeasureSpec);
        if (mode == MeasureSpec.EXACTLY) {
            width = size;
        } else {
            int maxChildWidth = 0;
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                LayoutParams layoutParams = (LayoutParams) child.getLayoutParams();
                maxChildWidth = Math.max(maxChildWidth, child.getMeasuredWidth() + layoutParams.leftMargin + layoutParams.rightMargin);
            }
            width = maxChildWidth + 60;
        }
        return width;
    }

    private int measureHeight(int heightMeasureSpec) {
        int height = 0;
        int mode = MeasureSpec.getMode(heightMeasureSpec);
        int size = MeasureSpec.getSize(heightMeasureSpec);
        if (mode == MeasureSpec.EXACTLY) {
            height = size;
        } else {
            int maxChildHeight = 0;
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                LayoutParams layoutParams = (LayoutParams) child.getLayoutParams();
                maxChildHeight = Math.max(maxChildHeight, child.getMeasuredHeight() + layoutParams.topMargin + layoutParams.bottomMargin);
            }
            height = maxChildHeight;
        }
        return height;
    }

    @Override
    public void addView(View child, int index, ViewGroup.LayoutParams params) {
        if (index > 2) {
            return;
        }
        LayoutParams lp = params instanceof LayoutParams ? (LayoutParams) params : new LayoutParams(params);
        lp.fromIndex = index;
        switch (index) {
            case 0:
                lp.scale = SCALE_0;
                lp.alpha = ALPHA_0;
                BASELINE_0 = baseLineOffset * 2;
                break;
            case 1:
                lp.scale = SCALE_1;
                lp.alpha = ALPHA_1;
                BASELINE_1 = baseLineOffset;

                break;
            case 2:
                lp.scale = SCALE_2;
                lp.alpha = ALPHA_2;
                BASELINE_2 = baseLineOffset * 0;
                break;
        }
        Log.e("BannerView", "BASELINE_0  =" + BASELINE_0);
        Log.e("BannerView", "BASELINE_1  =" + BASELINE_1);
        Log.e("BannerView", "BASELINE_2  =" + BASELINE_2);
        super.addView(child, index, params);
    }

    public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
        this.onItemClickListener = onItemClickListener;
    }

    public static class LayoutParams extends MarginLayoutParams {

        public int fromIndex;
        public int toIndex = -1;
        public int dataPosition;

        public float scale;
        public float alpha;

        public LayoutParams(Context c, AttributeSet attrs) {
            super(c, attrs);
        }

        public LayoutParams(int width, int height) {
            super(width, height);
        }

        public LayoutParams(MarginLayoutParams source) {
            super(source);
        }

        public LayoutParams(ViewGroup.LayoutParams source) {
            super(source);
        }
    }

    @Override
    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
        return new LayoutParams(p);
    }

    @Override
    public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new LayoutParams(getContext(), attrs);
    }

    @Override
    protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
        return new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
    }

    float mLastX;
    boolean isBeingDragged;

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        float x = ev.getX();
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastX = x;
                isBeingDragged = true;
                break;
            case MotionEvent.ACTION_MOVE:
                float offsetX = x - mLastX;
                //判断是否触发拖动事件
                if (Math.abs(offsetX) > 60) {
                    //更新上一次的触摸坐标
                    mLastX = x;
                    //标记已开始拖拽

                }
                break;

            case MotionEvent.ACTION_OUTSIDE:
            case MotionEvent.ACTION_UP:
                isBeingDragged = false;
                break;
            case MotionEvent.ACTION_CANCEL:
                requestDisallowInterceptTouchEvent(true);
                break;

        }
        return isBeingDragged;
    }


    float mOffsetX;

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (autoAnimator != null && autoAnimator.isRunning()) {
            return false;
        }

        float x = event.getX();
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                removeCallbacks(this);
            case MotionEvent.ACTION_MOVE:
                float offsetX = x - mLastX;
                mOffsetX += offsetX;
                if (Math.abs(mOffsetX) > 60) {
                    isBeingDragged = true;
                }
                //百分比
                mOffsetPercent = mOffsetX / getWidth();
                // 开始移动
                onChildMove();
                break;
            case MotionEvent.ACTION_OUTSIDE:
            case MotionEvent.ACTION_UP:
                //开始动画，固定位子
                isBeingDragged = false;
                run();
                break;
        }
        mLastX = x;
        return true;
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_MOVE:
                getParent().requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_OUTSIDE:
            case MotionEvent.ACTION_UP:
                getParent().requestDisallowInterceptTouchEvent(false);
                break;
        }
        return super.dispatchTouchEvent(event);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        if (autoAnimation) {
            run();
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if (autoAnimation) {
            removeCallbacks(this);
        }

        if (autoAnimator != null && autoAnimator.isRunning()) {
            autoAnimator.cancel();
        }
    }

    @Override
    public void run() {
        startAutoMove();
    }

    ValueAnimator autoAnimator;

    private boolean autoAnimation = true;

    public void setAutoAnimation(boolean autoAnimation) {
        this.autoAnimation = autoAnimation;
    }

    /**
     * 自动播放
     */
    public void startAutoMove() {
        if (getChildCount() != 3) {
            Log.e("BannerView", "child need 3 current count is" + getChildCount());
            return;
        }
        if (autoAnimator != null && autoAnimator.isRunning()) {
            return;
        }
        if (isBeingDragged) {
            return;
        }

        autoAnimator = ValueAnimator.ofFloat(mOffsetPercent, -1.f);
        autoAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                mOffsetPercent = (float) animation.getAnimatedValue();
                onChildMove();
            }
        });
        autoAnimator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                isReordered = false;
                mOffsetX = 0;
                mOffsetPercent = 0;
                if (autoAnimation) {
                    postDelayed(BannerView.this, waitTime);
                }
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });

        autoAnimator.setDuration(500);
        autoAnimator.setInterpolator(mInterpolator);
        autoAnimator.start();

    }

    /**
     * 调整动画的插值器，现在是减速
     */
    private Interpolator mInterpolator = new DecelerateInterpolator();

    // 滑动的百分比
    float mOffsetPercent;

    private void onChildMove() {
        if (scrollOrientation == SCROLL_ORIENTATION_LEFT) {
            if (mOffsetPercent > 0) {
                return;
            }
        }
        if (scrollOrientation == SCROLL_ORIENTATION_RIGHT) {
            if (mOffsetPercent < 0) {
                return;
            }
        }
        changeChildFromAndTop();
        updateChildOrder();
        requestLayout();
    }

    private void changeChildFromAndTop() {
        if (Math.abs(mOffsetPercent) >= 1) {
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                LayoutParams lp = (LayoutParams) child.getLayoutParams();
                lp.fromIndex = lp.toIndex;
                lp.toIndex = -1;
            }
            isReordered = false;
            mOffsetPercent %= 1;
            mOffsetX %= getWidth();
        }

        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            LayoutParams lp = (LayoutParams) child.getLayoutParams();
            switch (lp.fromIndex) {
                case 0:
                    lp.toIndex = mOffsetPercent > 0 ? 1 : 1;
                    break;
                case 1:
                    lp.toIndex = mOffsetPercent > 0 ? 2 : 2;
                    break;
                case 2:
                    lp.toIndex = mOffsetPercent > 0 ? 0 : 0;
                    break;
            }
        }
    }

    boolean isReordered;

    /**
     * 更新子View的层级顺序
     */
    private void updateChildOrder() {
        Log.e("bannerView", "updateChildOrder mOffsetPercent" + mOffsetPercent);
        if (Math.abs(mOffsetPercent) >= .9F) {
            if (!isReordered) {
                exchangeOrder(2, 0);
                exchangeOrder(2, 1);
                isReordered = true;
            }
        } else {
            if (isReordered) {
                exchangeOrder(0, 2);
                isReordered = false;

            }
        }
        for (int i=0;i<3;i++){
            View childAt = getChildAt(i);
            LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
            Log.e("bannerView", "updateChildOrder mOffsetPercent  i "+i +"from  "+ layoutParams.fromIndex);
            Log.e("bannerView", "updateChildOrder mOffsetPercent i "+i +"to  " +layoutParams.toIndex);
        }

    }


    /**
     * 交换子View的层级顺序
     *
     * @param fromIndex 原子View索引
     * @param toIndex   目标子View索引
     */

    private void exchangeOrder(int fromIndex, int toIndex) {
        Log.e("bannerView", "exchangeOrder fromIndex" + fromIndex);
        Log.e("bannerView", "exchangeOrder toIndex" + toIndex);
        if (fromIndex == toIndex || fromIndex >= getChildCount() || toIndex >= getChildCount()) {
            return;
        }

        if (fromIndex > toIndex) {
            int temp = fromIndex;
            fromIndex = toIndex;
            toIndex = temp;
        }

        View from = getChildAt(fromIndex);
        View to = getChildAt(toIndex);

        detachViewFromParent(toIndex);
        detachViewFromParent(fromIndex);

        attachViewToParent(to, fromIndex, to.getLayoutParams());
        attachViewToParent(from, toIndex, from.getLayoutParams());
        invalidate();
    }

    /**
     * 把目标子View放置到视图层级最底部
     */
    private void setAsBottom(View child) {
        int index = indexOfChild(child);
        if (index > 1) {
            return;
        }
        Log.e("bannerView", "setAsBottom index" + index);
        exchangeOrder(index, 0);
    }

    public interface OnItemClickListener {
        void onItemClick(int position);
    }
}

参考litepage

Android BannerView
09-03
Android结合viewpager实现的简单广告轮播banner控件，仅供参考~
BannerView：适用于Android的BannerView
02-07
BannerView Android版BannerView。 从RecyclerView扩展。 显示图像或文字。 简单易用，易于扩展。 屏幕截图 入门 步骤1.将其添加到存储库末尾的root build.gradle中： allprojects { repositories { .. . maven { url ' https://jitpack.io ' } } } 步骤2.添加依赖关系： dependencies { implementation ' com.github.mminng:BannerView:1.0.0 ' } 例就像使用Recyclerview 将BannerView添加到您的布局 图片横幅 < com> 文字横幅
Android-简单的轮播图控件BannerView
skyf1y的专栏
09-14 929
一个简单android轮播图控件，引入非常简单，只要给工程增加一个类即可
Android-BannerRecyclerView一个可以滑动的AndroidBannerView
08-13
BannerRecyclerView 一个可以滑动的Android Banner View
Android-LBannerView-包含小圆点的轮播图控件
08-13
LBannerView - 包含小圆点的轮播图控件
Android实现一个丝滑的自动轮播控件实例代码
01-20
在Android开发中，创建一个丝滑的自动轮播控件是一项常见的需求，它可以用来展示广告、热门活动等信息。为了实现这样一个功能，开发者通常会基于现有的Android官方API进行改造，以确保控件的稳定性和性能。本文将...
Android开发：自定义BannerView的封装方法
在Android开发中，"BannerView"是指用户界面上用于展示轮播广告、图片或其他信息滚动展示的一个控件。开发者常常需要自定义这样的控件以适应具体的应用场景，比如加载动态内容、保持UI的一致性或增加用户交互性。本...
BannerView2
04-14
BannerView2是一个专门用于实现轮播图视图的Android组件，它基于自定义View的方式进行构建。在Android应用开发中，轮播图是常见的展示广告、推荐内容或动态信息的UI元素，通常会包含自动滚动和点击跳转等功能。下面...
Android实现首页轮播图的BannerView技术解析
总结一下，BannerView.zip文件的核心内容涉及到了Android开发中的轮播图实现技术，其中ViewPager是一个关键组件，它通过与PagerAdapter结合来实现页面切换的基本功能，并通过扩展可以实现更复杂的交互效果。...
自定义 简单方便的 轮播图 BannerView
01-19
本项目提供的"自定义简单方便的轮播图 BannerView"就是一个这样的解决方案，它具有自动播放、手势触摸以及item点击事件的支持，能够为开发者提供便利的集成体验。 首先，我们来详细了解一下`CustomBannerView`这个...
BannerView:Android BannerView 图片轮播控件，支持无限循环，可设置显示各种样式，支持添加banner切换动画，支持定制各种大小形状不一的指示器。调用简单，代码稳定，体积小
05-16
BannerView 这是一个轻量简洁的自定义banner控件。欢迎大家提出意见或建议 BannerView在控件可见时自动播放，不可见时停止播放，不需要额外设置界面切换时的开始播放和暂停播放。 Gradle allprojects { repositories { ... maven { url 'https://jitpack.io' } } } implementation 'com.github.lany192:BannerView:3.0.1' Usage xml layout <com.lany.banner.BannerView android:id="@+id/banner_view" android:layout_width="match_parent" android:layout_height="180dp" app:ba
AndroidBannerView
06-16
横幅视图 [截屏] 谢谢 由开发 葛亮 - 问题 1.NullPointException at viewpager#draw(Canvas)
Android-BannerView-->一款用于在APP顶部展示的Snackbar
08-13
BannerView --> 一款用于在APP顶部展示的Snackbar
Android-MZBannerView仿魅族BannerView图片轮播控件支持多种模式切换
08-13
仿魅族BannerView,图片轮播控件,支持多种模式切换：普通ViewPager使用，普通Banner使用，仿魅族Banner使用
android banner以及横竖方向ViewPager
03-04
android banner以及横竖方向ViewPager 支持手势控制的banner 解决了ViewPager不能响应onTouchListener的问题 同时包含支持垂直方向滑动ViewPager的两种实现方式 具体参见博文http://blog.youkuaiyun.com/tiantianshangcha/article/details/50804954
Android常用控件-BannerView(无限轮播图控件)
weixin_33892359的博客
08-05 903
轮播图控件，封装ViewPager，支持无限循环轮播，支持三种常用页面特效，支持设置指示器，支持自动切换手动滑动和自动滑动的滑动时长，封装Banner的Holder实现更加简单。使用Kotlin开发，在项目中使用，满足大部分Banner相关需求，可以直接使用。 本项目基于MZBannerView进行二次开发，只用于开源交流，如果侵权等问题请及时提醒。 简单预览 使用方法 在项目根目录的bui...
Android打造万能的BannerView无限轮播图
金戈鐡馬
02-27 1140
这个给ViewPager设置了一个平滑的缩放的动画，但是看到了一个ViewPager设置动画的一个坑，发现滑到第一张的时候，在向右滑动的时候，图片会滑出一点边缘。一般底部会有两种类型指示器，一是矩形的，二是圆形的，这个类实现了如何自定义矩形和圆形指示器，其实这个类也可以实现圆形的和带圆角的矩形的图片，用PorterDuffXfermode图层的概念。BannerAdapter这个类是轮播图的适配器，因为服务器返回的列表图片的url，显示的时候需要转成IamgeViw，用适配器设计模式转一下。
Android App Banner，用它就够了。无限轮播、简单易用、扩展性强的BannerView
蜗牛学开车的博客
11-21 2494
按照惯例先上效果图： 写在前面GitHub上也是有比较详细的使用介绍的，如果你想直接看GitHub上的也可以直接点击后面的传送门去往GitHub。我是传送门本文的内容可能有点长，如果你想要直接但Demo的源码的，可以直接跳到最后，最后有完整的代码(包括Java代码和XML代码)。前言今天给大家推荐一款简单易用、扩展性强且超级稳定的轮播图库。·为什么说简单已用？答：因为实现起来比较简单，几行
android 自动轮播代码生成,【Android】三行代码实现一个轮播BannerView
weixin_26802933的博客
05-25 149
自己简单封装了一个带hint的轮播ViewPager，用来展示app首页的Banner，先看效果图吧。ezgif-1-437f7aee24.gifdependencies(依赖)compile 'com.coldmoqiuli:banners:1.0.0'使用起来非常方便~~2至3行代码就能实现上述效果，只要传入一个list就可以(其中是你需要展示的ImageView)，当然也可以自己在这基础上添...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值