广告轮播

最新推荐文章于 2021-02-25 21:50:04 发布
最新推荐文章于 2021-02-25 21:50:04 发布
阅读量327 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhangLiangXWZ/article/details/85257614
版权

BannerPagerAdapter

import android.content.Context;
import android.support.v4.view.PagerAdapter;
import android.util.SparseArray;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;

import java.util.List;

public class BannerPagerAdapter<T> extends PagerAdapter {

    private Context mContext;
    private List<T> mData;
    private CustomBanner.ViewCreator mCreator;
    private CustomBanner.OnPageClickListener mOnPageClickListener;

    private SparseArray<View> views = new SparseArray<>();

    public BannerPagerAdapter(Context context, CustomBanner.ViewCreator<T> creator, List data) {
        mContext = context;
        mCreator = creator;
        mData = data;
    }

    @Override
    public int getCount() {
        return mData == null || mData.isEmpty() ? 0 : mData.size() + 2;
    }

    @Override
    public boolean isViewFromObject(View arg0, Object arg1) {
        return arg0 == arg1;
    }

    @Override
    public void destroyItem(ViewGroup container, int position,
                            Object object) {
        //Warning：不要在这里调用removeView
    }

    @Override
    public Object instantiateItem(ViewGroup container, final int position) {

        View view = views.get(position);

        if (view == null) {
            view = mCreator.createView(mContext, position);
            views.put(position, view);
        }

        //如果View已经在之前添加到了一个父组件，则必须先remove，否则会抛出IllegalStateException。
        ViewParent vp = view.getParent();
        if (vp != null) {
            ViewGroup parent = (ViewGroup) vp;
            parent.removeView(view);
        }

        final int item = getActualPosition(position);
        final T t = mData.get(item);

        mCreator.updateUI(mContext, view, item, t);

        view.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mOnPageClickListener != null) {
                    mOnPageClickListener.onPageClick(item, t);
                }
            }
        });

        container.addView(view);
        return view;
    }

    private int getActualPosition(int position) {
        if (position == 0) {
            return mData.size() - 1;
        } else if (position == getCount() - 1) {
            return 0;
        } else {
            return position - 1;
        }
    }

    public void setOnPageClickListener(CustomBanner.OnPageClickListener l) {
        mOnPageClickListener = l;
    }

}

CustomBanner

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.ShapeDrawable;
import android.os.Handler;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.AccelerateInterpolator;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;

import com.example.zl.myapplication.R;

import java.lang.reflect.Field;
import java.util.List;

public class CustomBanner<T> extends FrameLayout {

    private Context mContext;

    private ViewPager mBannerViewPager;
    //普通指示器的容器
    private LinearLayout mIndicatorLayout;
    //数字指示器
    private NumberIndicator mNumberIndicator;
    private BannerPagerAdapter<T> mAdapter;
    private ViewPagerScroller mScroller;
    private long mIntervalTime;

    private int mIndicatorSelectRes;
    private int mIndicatorUnSelectRes;
    private int mIndicatorInterval;
    private IndicatorGravity mIndicatorGravity = IndicatorGravity.CENTER;
    private IndicatorStyle mIndicatorStyle = IndicatorStyle.ORDINARY;

    private int mBannerCount;
    private boolean isTurning;

    private OnPageClickListener mOnPageClickListener;
    private ViewPager.OnPageChangeListener mOnPageChangeListener;

    private Handler mTimeHandler = new Handler();
    private Runnable mTurningTask = new Runnable() {
        @Override
        public void run() {
            if (isTurning && mBannerViewPager != null) {
                int page = mBannerViewPager.getCurrentItem() + 1;
                mBannerViewPager.setCurrentItem(page);
                mTimeHandler.postDelayed(mTurningTask, mIntervalTime);
            }
        }
    };

    /**
     * 指示器方向
     */
    public enum IndicatorGravity {
        LEFT, RIGHT, CENTER
    }

    /**
     * 指示器类型
     */
    public enum IndicatorStyle {
        //没有指示器
        NONE,
        //数字指示器
        NUMBER,
        //普通指示器
        ORDINARY
    }

    public CustomBanner(Context context) {
        super(context);
        init(context);
    }

    public CustomBanner(Context context, AttributeSet attrs) {
        super(context, attrs);
        getAttrs(context, attrs);
        init(context);
    }

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

    private void getAttrs(Context context, AttributeSet attrs) {
        if (attrs != null) {
            TypedArray mTypedArray = context.obtainStyledAttributes(attrs, R.styleable.custom_banner);
            int gravity = mTypedArray.getInt(R.styleable.custom_banner_indicatorGravity, 3);

            if (gravity == 1) {
                mIndicatorGravity = IndicatorGravity.LEFT;
            } else if (gravity == 2) {
                mIndicatorGravity = IndicatorGravity.RIGHT;
            } else if (gravity == 3) {
                mIndicatorGravity = IndicatorGravity.CENTER;
            }

            int style = mTypedArray.getInt(R.styleable.custom_banner_indicatorStyle, 3);

            if (style == 1) {
                mIndicatorStyle = IndicatorStyle.NONE;
            } else if (style == 2) {
                mIndicatorStyle = IndicatorStyle.NUMBER;
            } else if (style == 3) {
                mIndicatorStyle = IndicatorStyle.ORDINARY;
            }

            mIndicatorInterval = mTypedArray.getDimensionPixelOffset(
                    R.styleable.custom_banner_indicatorInterval, DensityUtils.dp2px(context, 5));
            mIndicatorSelectRes = mTypedArray.getResourceId(
                    R.styleable.custom_banner_indicatorSelectRes, 0);
            mIndicatorUnSelectRes = mTypedArray.getResourceId(
                    R.styleable.custom_banner_indicatorUnSelectRes, 0);
            mTypedArray.recycle();
        }
    }

    private void init(Context context) {
        mContext = context;
        addBannerViewPager(context);
        addIndicatorLayout(context);
        addTextIndicator(context);
    }

    private void addBannerViewPager(Context context) {
        mBannerViewPager = new ViewPager(context);
        mBannerViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetP) {
                if (!isMarginal(position) && mOnPageChangeListener != null) {
                    mOnPageChangeListener.onPageScrolled(getActualPosition(position),
                            positionOffset, positionOffsetP);
                }
            }

            @Override
            public void onPageSelected(int position) {
                if (!isMarginal(position) && mOnPageChangeListener != null) {
                    mOnPageChangeListener.onPageSelected(getActualPosition(position));
                }
                updateIndicator();
            }

            @Override
            public void onPageScrollStateChanged(int state) {
                int position = mBannerViewPager.getCurrentItem();
                if (!isMarginal(position) && mOnPageChangeListener != null) {
                    mOnPageChangeListener.onPageScrollStateChanged(state);
                }
                if (state == ViewPager.SCROLL_STATE_IDLE) {
                    if (position == 0) {
                        mScroller.setSudden(true);
                        mBannerViewPager.setCurrentItem(mAdapter.getCount() - 2, true);
                        mScroller.setSudden(false);
                    } else if (position == mAdapter.getCount() - 1) {
                        mScroller.setSudden(true);
                        mBannerViewPager.setCurrentItem(1, true);
                        mScroller.setSudden(false);
                    }
                }
            }
        });

        replaceViewPagerScroll();
        this.addView(mBannerViewPager);
    }

    private void addIndicatorLayout(Context context) {
        //添加普通指示器容器
        mIndicatorLayout = new LinearLayout(context);
        LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        lp.gravity = analysisGravity(mIndicatorGravity);
        int margins = DensityUtils.dp2px(context, 8);
        lp.setMargins(margins, 0, margins, margins);
        mIndicatorLayout.setGravity(Gravity.CENTER);
        mIndicatorLayout.setShowDividers(LinearLayout.SHOW_DIVIDER_MIDDLE);
        mIndicatorLayout.setDividerDrawable(getDividerDrawable(mIndicatorInterval));
        this.addView(mIndicatorLayout, lp);
        mIndicatorLayout.setVisibility(mIndicatorStyle == IndicatorStyle.ORDINARY ? VISIBLE : GONE);
    }

    private void addTextIndicator(Context context) {
        //添加数字指示器
        mNumberIndicator = new NumberIndicator(context);
        LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        lp.gravity = analysisGravity(mIndicatorGravity);
        int margins = DensityUtils.dp2px(context, 8);
        lp.setMargins(margins, 0, margins, margins);
        this.addView(mNumberIndicator, lp);
        mNumberIndicator.setVisibility(GONE);
    }

    private Drawable getDividerDrawable(int interval) {
//        ShapeDrawable drawable = (ShapeDrawable) mContext.getResources().getDrawable(
//                R.drawable.door_indicator_divider);
//        drawable.setIntrinsicWidth(interval);
        ShapeDrawable drawable = new ShapeDrawable();
        drawable.getPaint().setColor(Color.TRANSPARENT);
        drawable.setIntrinsicWidth(interval);
        return drawable;
    }

    @Override
    public void onWindowFocusChanged(boolean hasWindowFocus) {
        super.onWindowFocusChanged(hasWindowFocus);
        if (isTurning) {
            if (hasWindowFocus) {
                startTurning(mIntervalTime);
            } else {
                stopTurning();
                isTurning = true;
            }
        }
    }

    private boolean isMarginal(int position) {
        return position == 0 || position == getCount() + 1;
    }

    /**
     * 设置轮播图数据
     *
     * @param creator 创建和更新轮播图View的接口
     * @param data    轮播图数据
     * @return
     */
    public CustomBanner<T> setPages(ViewCreator<T> creator, List<T> data) {
        mAdapter = new BannerPagerAdapter<T>(mContext, creator, data);
        if (mOnPageClickListener != null) {
            mAdapter.setOnPageClickListener(mOnPageClickListener);
        }
        mBannerViewPager.setAdapter(mAdapter);
        if (data == null) {
            mIndicatorLayout.removeAllViews();
            mBannerCount = 0;
        } else {
            mBannerCount = data.size();
            initIndicator(data.size());
        }
        setCurrentItem(0);
        updateIndicator();
        return this;
    }

    /**
     * 设置指示器资源
     *
     * @param selectRes   选中的效果资源
     * @param unSelectRes 未选中的效果资源
     * @return
     */
    public CustomBanner<T> setIndicatorRes(int selectRes, int unSelectRes) {
        mIndicatorSelectRes = selectRes;
        mIndicatorUnSelectRes = unSelectRes;
        updateIndicator();
        return this;
    }

    /**
     * 设置指示器方向
     *
     * @param gravity 指示器方向 左、中、右三种
     * @return
     */
    public CustomBanner<T> setIndicatorGravity(IndicatorGravity gravity) {
        if (mIndicatorGravity != gravity) {
            mIndicatorGravity = gravity;
            setOrdinaryIndicatorGravity(gravity);
            setNumberIndicatorGravity(gravity);
        }
        return this;
    }

    private void setOrdinaryIndicatorGravity(IndicatorGravity gravity) {
        LayoutParams lp = (LayoutParams) mIndicatorLayout.getLayoutParams();
        lp.gravity = analysisGravity(gravity);
        mIndicatorLayout.setLayoutParams(lp);
    }

    private void setNumberIndicatorGravity(IndicatorGravity gravity) {
        LayoutParams lp = (LayoutParams) mNumberIndicator.getLayoutParams();
        lp.gravity = analysisGravity(gravity);
        mNumberIndicator.setLayoutParams(lp);
    }

    /**
     * 设置指示器类型
     *
     * @param style 指示器类型 普通指示器 数字指示器 没有指示器 三种
     * @return
     */
    public CustomBanner<T> setIndicatorStyle(IndicatorStyle style) {
        if (mIndicatorStyle != style) {
            mIndicatorStyle = style;
            mIndicatorLayout.setVisibility(mIndicatorStyle == IndicatorStyle.ORDINARY ? VISIBLE : GONE);
            mNumberIndicator.setVisibility(mIndicatorStyle == IndicatorStyle.NUMBER ? VISIBLE : GONE);
            updateIndicator();
        }
        return this;
    }

    /**
     * 设置指示器间隔
     *
     * @param interval
     * @return
     */
    public CustomBanner<T> setIndicatorInterval(int interval) {
        if (mIndicatorInterval != interval) {
            mIndicatorInterval = interval;
            mIndicatorLayout.setDividerDrawable(getDividerDrawable(interval));
        }
        return this;
    }

    public IndicatorGravity getIndicatorGravity() {
        return mIndicatorGravity;
    }

    private int analysisGravity(IndicatorGravity gravity) {
        if (gravity == IndicatorGravity.LEFT) {
            return Gravity.BOTTOM | Gravity.LEFT;
        } else if (gravity == IndicatorGravity.RIGHT) {
            return Gravity.BOTTOM | Gravity.RIGHT;
        } else {
            return Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
        }
    }

    /**
     * 启动轮播
     *
     * @param intervalTime 轮播间隔时间
     * @return
     */
    public CustomBanner<T> startTurning(long intervalTime) {
        if (isTurning) {
            stopTurning();
        }
        isTurning = true;
        mIntervalTime = intervalTime;
        mTimeHandler.postDelayed(mTurningTask, mIntervalTime);
        return this;
    }

    /**
     * 停止轮播
     *
     * @return
     */
    public CustomBanner<T> stopTurning() {
        isTurning = false;
        mTimeHandler.removeCallbacks(mTurningTask);
        return this;
    }

    /**
     * 是否轮播
     *
     * @return
     */
    public boolean isTurning() {
        return isTurning;
    }

    /**
     * 获取轮播间隔时间
     *
     * @return
     */
    public long getIntervalTime() {
        return mIntervalTime;
    }

    public int getCount() {
        if (mAdapter == null || mAdapter.getCount() == 0) {
            return 0;
        }
        return mAdapter.getCount() - 2;
    }

    public CustomBanner setCurrentItem(int position) {
        if (position >= 0 && position < mAdapter.getCount()) {
            mBannerViewPager.setCurrentItem(position + 1);
        }
        return this;
    }

    public int getCurrentItem() {
        return getActualPosition(mBannerViewPager.getCurrentItem());
    }

    private int getActualPosition(int position) {
        if (mAdapter == null || mAdapter.getCount() == 0) {
            return -1;
        }

        if (position == 0) {
            return getCount() - 1;
        } else if (position == getCount() + 1) {
            return 0;
        } else {
            return position - 1;
        }
    }

    private void initIndicator(int count) {
        mIndicatorLayout.removeAllViews();
        if (count > 0) {
            for (int i = 0; i < count; i++) {
                ImageView imageView = new ImageView(mContext);
                LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
                        ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
                mIndicatorLayout.addView(imageView, lp);
            }
        }
    }

    /**
     * 更新指示器
     */
    private void updateIndicator() {
        if (mIndicatorStyle == IndicatorStyle.ORDINARY) {
            int count = mIndicatorLayout.getChildCount();
            int currentPage = getCurrentItem();
            if (count > 0) {
                for (int i = 0; i < count; i++) {
                    ImageView view = (ImageView) mIndicatorLayout.getChildAt(i);
                    if (i == currentPage) {
                        if (mIndicatorSelectRes != 0) {
                            view.setImageResource(mIndicatorSelectRes);
                        } else {
                            view.setImageBitmap(null);
                        }
                    } else {
                        if (mIndicatorUnSelectRes != 0) {
                            view.setImageResource(mIndicatorUnSelectRes);
                        } else {
                            view.setImageBitmap(null);
                        }
                    }
                }
            }
        } else if (mIndicatorStyle == IndicatorStyle.NUMBER) {
            if (mBannerCount > 0) {
                mNumberIndicator.setVisibility(VISIBLE);
                mNumberIndicator.setText((getCurrentItem() + 1) + "/" + mBannerCount);
            } else {
                mNumberIndicator.setVisibility(GONE);
            }
        }
    }

    /**
     * 通过反射替换掉mBannerViewPager的mScroller属性。
     * 这样做是为了改变和控件ViewPager的滚动速度。
     */
    private void replaceViewPagerScroll() {
        try {
            Field field = ViewPager.class.getDeclaredField("mScroller");
            field.setAccessible(true);
            mScroller = new ViewPagerScroller(mContext,
                    new AccelerateInterpolator());
            field.set(mBannerViewPager, mScroller);
        } catch (Exception e) {
        }
    }

    /**
     * 设置轮播图的滚动速度
     *
     * @param scrollDuration
     */
    public CustomBanner<T> setScrollDuration(int scrollDuration) {
        mScroller.setScrollDuration(scrollDuration);
        return this;
    }

    public int getScrollDuration() {
        return mScroller.getScrollDuration();
    }

    public CustomBanner setOnPageChangeListener(ViewPager.OnPageChangeListener l) {
        mOnPageChangeListener = l;
        return this;
    }

    public CustomBanner<T> setOnPageClickListener(OnPageClickListener l) {
        if (mAdapter != null) {
            mAdapter.setOnPageClickListener(l);
        }

        mOnPageClickListener = l;
        return this;
    }

    public interface OnPageClickListener<T> {
        void onPageClick(int position, T t);
    }

    /**
     * 创建和更新轮播图View的接口
     *
     * @param <T>
     */
    public interface ViewCreator<T> {

        View createView(Context context, int position);

        void updateUI(Context context, View view, int position, T t);
    }
}

DensityUtils

import android.content.Context;
import android.util.TypedValue;

public class DensityUtils {

    private DensityUtils() {
        /* cannot be instantiated */
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * dp转px
     */
    public static int dp2px(Context context, float dpVal) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                dpVal, context.getResources().getDisplayMetrics());
    }

    /**
     * sp转px
     */
    public static int sp2px(Context context, float spVal) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
                spVal, context.getResources().getDisplayMetrics());
    }

    /**
     * px转dp
     */
    public static float px2dp(Context context, float pxVal) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (pxVal / scale);
    }

    /**
     * px转sp
     */
    public static float px2sp(Context context, float pxVal) {
        return (pxVal / context.getResources().getDisplayMetrics().scaledDensity);
    }

}

NumberIndicator

import android.content.Context;
import android.graphics.Color;
import android.support.v7.widget.AppCompatTextView;

import com.example.zl.myapplication.R;


public class NumberIndicator extends AppCompatTextView {

    public NumberIndicator(Context context) {
        super(context);
        setTextColor(Color.WHITE);
        setTextSize(14);
        setBackgroundResource(R.drawable.door_text_indicator_bg);
        int padding = DensityUtils.dp2px(context, 5);
        setPadding(padding, padding, padding, padding);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        //保证TextIndicator的宽高一致(正方形)
        super.onMeasure(widthMeasureSpec, widthMeasureSpec);
    }
}

ViewPagerScroller

import android.content.Context;
import android.view.animation.Interpolator;
import android.widget.Scroller;

public class ViewPagerScroller extends Scroller {

    private int mScrollDuration = 360;
    private boolean sudden;

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

    public ViewPagerScroller(Context context, Interpolator interpolator) {
        super(context, interpolator);
    }

    public ViewPagerScroller(Context context, Interpolator interpolator,
                             boolean flywheel) {
        super(context, interpolator, flywheel);
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        super.startScroll(startX, startY, dx, dy, sudden ? 0 : mScrollDuration);
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy) {
        super.startScroll(startX, startY, dx, dy, sudden ? 0 : mScrollDuration);
    }

    public int getScrollDuration() {
        return mScrollDuration;
    }

    public void setScrollDuration(int scrollDuration) {
        this.mScrollDuration = scrollDuration;
    }

    public boolean isSudden() {
        return sudden;
    }

    public void setSudden(boolean zero) {
        this.sudden = zero;
    }
}

资源文件

door_text_indicator_bg.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">

    <solid android:color="#7f1d1c1c"/>

</shape>

attr.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <declare-styleable name="custom_banner">
        <attr name="indicatorGravity" format="enum">
            <enum name="LEFT" value="1"/>
            <enum name="RIGHT" value="2"/>
            <enum name="CENTER" value="3"/>
        </attr>
        <attr name="indicatorStyle" format="enum">
            <enum name="NONE" value="1"/>
            <enum name="NUMBER" value="2"/>
            <enum name="ORDINARY" value="3"/>
        </attr>
        <attr name="indicatorSelectRes" format="reference"/>
        <attr name="indicatorUnSelectRes" format="reference"/>
        <attr name="indicatorInterval" format="dimension"/>
    </declare-styleable>
</resources>

 

 advertise1.png

  advertise2.png

 advertise3.png

  dian_selec.png                     dian_unsele.png

 

使用 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <com.example.zl.viewpager.CustomBanner
        android:id="@+id/banner"
        android:layout_width="900dp"
        android:layout_height="200dp"
        app:indicatorGravity="CENTER"
        app:indicatorInterval="15dp"
        app:indicatorSelectRes="@drawable/dian_selec"
        app:indicatorStyle="ORDINARY"
        app:indicatorUnSelectRes="@drawable/dian_unsele" />

</LinearLayout>
import android.content.Context;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;

import com.example.zl.myapplication.R;

import java.util.ArrayList;
import java.util.List;

public class MyActivity extends AppCompatActivity {

    private CustomBanner<String> mBanner;
    private List<Integer> list_adver = new ArrayList<>();

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_viewpager);

        mBanner = findViewById(R.id.banner);
        ArrayList<String> images = new ArrayList<>();
        images.add("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3778456200,3076998411&fm=23&gp=0.jpg");
        images.add("https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=3535338527,4000198595&fm=23&gp=0.jpg");
        images.add("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=1017904219,2460650030&fm=23&gp=0.jpg");
        list_adver.add(R.drawable.advertise1);
        list_adver.add(R.drawable.advertise2);
        list_adver.add(R.drawable.advertise3);

        mBanner.setPages(new CustomBanner.ViewCreator<String>() {
            @Override
            public View createView(Context context, int position) {
                ImageView imageView = new ImageView(context);
                imageView.setScaleType(ImageView.ScaleType.FIT_XY);
                return imageView;
            }

            @Override
            public void updateUI(Context context, View view, int position, String s) {
                view.setBackgroundResource(list_adver.get(position));
            }
        }, images)
                // 设置指示器类型（普通 ORDINARY、数字 NUMBER、没有 NONE）
                // 同作用：app:indicatorStyle="ORDINARY"
//                .setIndicatorStyle(CustomBanner.IndicatorStyle.ORDINARY)

                // 设置两个点图片作为翻页指示器，不设置则没有指示器，可以根据自己需求自行配合自己的指示器
                // 同作用：app:indicatorSelectRes="@drawable/dian_selec"；
                //         app:indicatorUnSelectRes="@drawable/dian_unsele"
//                .setIndicatorRes(R.drawable.dian_selec,R.drawable.dian_unsele)

                // 设置指示器的方向
                // 同作用：app:indicatorGravity="CENTER"
//                .setIndicatorGravity(CustomBanner.IndicatorGravity.LEFT)

                // 设置指示器的指示点之间间隔
                // 同作用：app:indicatorInterval="15dp"
//                .setIndicatorInterval(20)
                // 设置自动翻页间隔时间，不设就不自动翻页
                .startTurning(8000);

    }
}

 

ZhangLiangXWZ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
广告首页轮播
12-05
广告轮播，少时诵诗书所所所所所所所所所所所所所所所所所所所所所所所所所所所所
轮播广告两种方式
06-05 127
banner：依赖去GitHub网站 https://github.com/youth5201314/banner AndroidImageSlider：依赖去GitHub：https://github.com/daimajia/AndroidImageSlider ...
Android基础之首页广告轮播效果
chenliguan的博客
03-25 2311
1 我们经常打开一个App会看到有广告图片轮播的效果，首先上效果图2 实现的过程2.1 轮播页面他是一个ViewPager2.2 然后我们使用RelativeLayout来把小圆点放置在图片上，然后滑动时动态修改小圆点的背景，就产生了滑动的效果2.3 自动滑动的效果，我们可以利用ScheduledExecutorService这个类来实现，他可以周期性的执行任务，这样就可以自动滑动了3 要点说明3.
广告轮播效果的实现
yuanmei1986的博客
03-06 1177
使用Bootstrap中的carousel插件来实现，代码如下： <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta http-equiv="X-UA-Comp
安卓广告轮播效果
10-11
在Android开发中，实现“安卓广告轮播效果”是一种常见的需求，特别是在电商应用如淘宝、京东等的主页上，这种效果能吸引用户注意力并展示多种商品信息。这种功能通常被称为轮播图或滑动广告视图，是通过专门的组件...
广告轮播图
01-26
广告轮播图是一种常见的UI设计元素，主要用于展示多个广告或信息卡片，用户可以通过手动滑动或者自动滚动查看不同的内容。在iOS开发中，我们可以利用Swift或Objective-C来实现这一功能。下面将详细介绍如何封装一个...
易语言广告轮播
10-01
在“易语言广告轮播”这个主题中，我们主要关注如何利用易语言来实现广告的动态展示，即广告轮播功能。这个功能在很多软件中常见，比如桌面应用、网站或者移动应用，它可以用来显示不同的广告内容，提高广告的曝光率...
ViewPager 实现广告轮播图
11-02
本教程将深入讲解如何利用ViewPager来创建一个广告轮播图。 首先，我们需要了解ViewPager的基本原理。ViewPager是Android SDK中的一个视图容器，它可以展示一系列的页面，并且支持用户通过滑动手势在这些页面之间...
iOS广告轮播图
11-30
在iOS应用开发中，广告轮播图是一种常见的组件，它能有效地展示多个广告，并自动进行定时切换，以吸引用户的注意力。这种功能的实现通常涉及到UI设计、动画效果、数据加载和用户交互等多个方面。以下是对这个主题的...
轮播广告图片5张图片实现轮播
09-01
轮播广告图片5张图片实现轮播图片可自由更换，前端的小框架
首页图片轮播广告
weixin_34259159的博客
10-13 87
&lt;script type="text/javascript"&gt; var pic_width=417; //图片宽度 var pic_height=215; //图片高度 var button_pos=4; //按扭位置 1左 2右 3上 4下 var stop_time=4000; //图片停留时间(1000为1秒钟) var show_text=0; //是否显示文字标签 1显示 0...
JavaScript - 轮播广告实例
陆讯
04-26 2407
轮播广告<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>轮播广告<
【微信小程序】实现广告轮播图
xunming的专栏
02-25 3206
文章目录一、示例代码二、展示优化1、衔接滑动2、控件居中3、显示完整4、标题定位三、指示点样式四、切换特效五、所有代码六、参考博文 看个效果图 一、示例代码 在微信小程序开发文档里，组件模块，视图容器分类下，有swiper和swiper-item组件，这就是用来实现轮播图的组件，并且官方还提供了示例代码和演示效果 swiper 官方示例代码 Page({ onShareAppMessage() { return { title: 'swiper', path: 'pag
利用JQuery实现轮播图
热门推荐
changeie的博客
03-22 4万+
上一篇文章写了利用初级JS实现无缝轮播图，但是实际写起来有点费劲，量有些大，如果改用jQuery写无缝轮播图的话，写起来比较便捷，而已逻辑比较清晰，简单，实现起来比较快捷，性能相对于初级JS来说也会高很多。以下为代码，供大家学习和参考。&lt;!doctype html&gt;&lt;html&gt;&lt;head&gt;&lt;meta charset="utf-8"&gt;&lt;title...
酷炫轮播广告
奋斗&努力
12-13 947
一、广告轮播条的简介   广告轮播条在HTML网页设计以及APP界面设计中非常常见，如下图所示。在Android中，实现的方式可以是自定义ViewPager来实现，但是我们程序员中流传的一句名言，“不要重复造轮子”。因此我们也可以通过网上已经有的开源项目来进行开发，拿来主义，直接拿来用就可以了，这样极大地加快了我们的开发速度。     二、AndroidImageSlider简介
超简单的首页广告轮播图
mingyunxiaohai的专栏
01-11 767
好多应用首页都有一个轮播的图片，有一种实现的方法就是用ViewPager去实现，将图片放到ViewPager中，然后通过Handler定时的发送一个消息，收到消息之后通过ViewPager的setCurrentItem(currentItem);方法来实现轮播。本项目将上述方法封装了一下，平时用的时候非常方便。 package com.hsm.bxt.widgets; import andro
用jQuery实现广告轮播的效果
java_zhaoyanli的专栏
08-01 7124
图片轮播 jq(左右切换) body, div, ul, li, a, img { margin: 0; padding: 0; } ul, li { list-style: none; } a { text-
Android——支持图片加视频无限轮播的banner
Saqino的博客
11-25 8597
基于https://github.com/youth5201314/banner扩展，图片+视频无限轮播banner Demo地址 https://gitee.com/saqino/pic-video-banner-demo.git 说明 使用大佬的banner控件是很方便的，但是对视频+图片无限轮播的支持较弱，所以决定重写几个类实现功能。 不重写无法实现的原因如下： 无限轮播模式下，item大于1时， adapter会自动增加两个item，一个在最前，一个在最后，这样子做...
android 实现广告轮播代码
最新发布
08-14
以下是一个简单的Android实现广告轮播的代码示例： ``` public class MainActivity extends AppCompatActivity { private ViewPager2 viewPager2; private AdAdapter adAdapter; private Handler handler; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值