android ViewPager 轮播

最新推荐文章于 2024-04-14 19:36:54 发布
最新推荐文章于 2024-04-14 19:36:54 发布
阅读量202 收藏
点赞数
分类专栏： android 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d850269838d/article/details/79582274
版权 
package com.xin.ui.widget;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.annotation.AttrRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.StyleRes;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.VelocityTrackerCompat;
import android.support.v4.view.ViewConfigurationCompat;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseArray;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;
import android.widget.Scroller;

import com.xin.dbmbase.R;

import java.util.ArrayList;

/**
 * viewpager 包一层，添加了对应展示第几张的标识，并且可以无限滑动
 */

public class LoopViewPager extends FrameLayout {

    public static final int SCROLL_STATE_IDLE = 0;
    public static final int SCROLL_STATE_DRAGGING = 1;
    public static final int SCROLL_STATE_SETTLING = 2;
    private static final String TAG = "LoopViewPager";
    private static final boolean DEBUG = true;
    private static final int MIN_FLING_VELOCITY = 400;
    private static final int MIN_DISTANCE_FOR_FLING = 200;
    private static final Interpolator sInterpolator = new Interpolator() {
        public float getInterpolation(float t) {
            t -= 1.0f;
            return t * t * t * t * t + 1.0f;
        }
    };
    private int mOffsetLimit = 1;
    private int mCurrentPos;
    private NextRunnable runnable;
    private PagerAdapter mAdapter;
    private VelocityTracker mVelocityTracker;
    private ArrayList<ViewPager.OnPageChangeListener> mListener;
    private float mDownX;
    private float mDownY;
    private int mTouchSlop;
    private int mMinimumVelocity;
    private int mMaximumVelocity;
    private int mFlingDistance;
    private Scroller mScroller;
    private int mState = SCROLL_STATE_IDLE;
    private Drawable mDotChosed;
    private Drawable mDotNormal;
    private int mMarginDot;
    private int mMinShow = 2;//有两个才显示，1个点太奇怪了
    private FrameLayout.LayoutParams mParamsDot;
    private int mDotTop;
    private int mDotLeft;
    private DataSetObserver mObserever = new DataSetObserver() {
        @Override
        public void onChanged() {
            removeAllViews();
            populate(mCurrentPos);
            postDelayed(runnable, runnable.mDelay);
        }
    };

    public LoopViewPager(@NonNull Context context) {
        super(context);
        init();
    }

    public LoopViewPager(@NonNull Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public LoopViewPager(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public LoopViewPager(@NonNull Context context, @Nullable AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init();
    }

    private void init() {
        runnable = new NextRunnable(this);
        mScroller = new Scroller(getContext(), sInterpolator);
        final float density = getResources().getDisplayMetrics().density;
        ViewConfiguration configuration = ViewConfiguration.get(getContext());
        mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
        mMinimumVelocity = (int) (MIN_FLING_VELOCITY * density);
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
        mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);
        mDotChosed = getContext().getResources().getDrawable(R.drawable.action_index_bj);
        mDotNormal = getContext().getResources().getDrawable(R.drawable.action_index_deg_bj);
        mDotNormal.setBounds(0, 0, mDotNormal.getMinimumWidth(), mDotNormal.getMinimumHeight());
        mDotChosed.setBounds(0, 0, mDotChosed.getMinimumWidth(), mDotChosed.getMinimumHeight());
        mMarginDot = mDotNormal.getMinimumWidth();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (mDotNormal != null && mDotChosed != null && mAdapter != null) {
            if (mParamsDot == null) {
                final float density = getResources().getDisplayMetrics().density;
                mParamsDot = generateDotLayoutParams((int) (density * 10));
            }
            mDotTop = (mParamsDot.gravity & Gravity.TOP) == Gravity.TOP ? mParamsDot.topMargin : ((mParamsDot.gravity & Gravity.BOTTOM) == Gravity.BOTTOM ? getMeasuredHeight() - mParamsDot.bottomMargin - mDotNormal.getBounds().height() : (getMeasuredHeight() - mDotNormal.getBounds().height()) / 2);
            mDotLeft = (mParamsDot.gravity & Gravity.LEFT) == Gravity.LEFT ? mParamsDot.leftMargin : ((mParamsDot.gravity & Gravity.RIGHT) == Gravity.RIGHT ? getMeasuredWidth() - mParamsDot.leftMargin - mDotNormal.getBounds().width() : (getMeasuredWidth() - (mDotNormal.getBounds().width() + mMarginDot) * (mAdapter.getCount() - 1) - mDotChosed.getBounds().width()) / 2);
        }
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        int count = getChildCount();
        int parentWidth = right - left;
        int parentHeight = bottom - top;
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            final int width = child.getMeasuredWidth();
            final int height = child.getMeasuredHeight();
            int childLeft = lp.layout * parentWidth + ((lp.gravity & Gravity.LEFT) != 0 ? lp.leftMargin : parentWidth - width - lp.rightMargin);
            int childTop = (lp.gravity & Gravity.TOP) != 0 ? lp.topMargin : parentHeight - height - lp.topMargin;
            child.layout(childLeft, childTop, childLeft + width, childTop + height);
        }
        scrollTo(mCurrentPos * parentWidth, 0);
    }


    @Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);
        if (mDotChosed != null && mDotNormal != null && mAdapter != null && mAdapter.getCount() >= mMinShow) {
            canvas.save();
            canvas.translate(getScrollX() + mDotLeft, mDotTop);
            for (int i = 0; i < mAdapter.getCount(); i++) {
                if (i == mCurrentPos) {
                    mDotChosed.draw(canvas);
                    canvas.translate(mDotChosed.getMinimumWidth() + mMarginDot, 0);
                } else {
                    mDotNormal.draw(canvas);
                    canvas.translate(mDotNormal.getMinimumWidth() + mMarginDot, 0);
                }
            }
            canvas.restore();
        }
    }

    /**
     * 自动循环播放
     *
     * @param delay，下一张的时间间隔，如果小于等于0取消自动播放
     */
    public void setAutoNext(final int delay) {
        postDelayed(runnable, runnable.mDelay = delay);
    }


    public void setDot(Drawable dotChosed, Drawable dotNormal) {
        this.mDotChosed = dotChosed;
        this.mDotNormal = dotNormal;
    }

    public void setDotLayoutParams(FrameLayout.LayoutParams params) {
        this.mParamsDot = params;
    }

    public void setMarginDot(int mMarginDot) {
        this.mMarginDot = mMarginDot;
    }

    public PagerAdapter getAdapter() {
        return mAdapter;
    }

    public void setAdapter(PagerAdapter adapter) {
        if (mAdapter != null) {
            removeAllViews();
            mAdapter.unregisterDataSetObserver(mObserever);
        }
        if (adapter != null) {
            mAdapter = adapter;
            mAdapter.registerDataSetObserver(mObserever);
            mAdapter.notifyDataSetChanged();
        } else {
            mAdapter = null;
        }
    }

    public void showDot(FrameLayout.LayoutParams params) {

    }

    public int getOffscreenPageLimit() {
        return mOffsetLimit;
    }

    public void setOffscreenPageLimit(int limit) {
        mOffsetLimit = limit;
        mAdapter.notifyDataSetChanged();
    }

    public void addOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
        if (mListener == null) {
            mListener = new ArrayList<ViewPager.OnPageChangeListener>();
        }
        mListener.add(listener);
    }

    public void clearOnPageChangeListeners() {
        if (mListener != null) {
            mListener.clear();
        }
    }


    public int getCurrentItem() {
        return mCurrentPos;
    }

    public void setCurrentItem(int item) {
        setCurrentItem(item, true);
    }

    public void setCurrentItem(final int item, final boolean smoothScroll) {
        final int width = getWidth();
        if (width == 0) {
            getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
                @Override
                public void onGlobalLayout() {
                    getViewTreeObserver().removeGlobalOnLayoutListener(this);
                    setCurrentItemInner(smoothScroll, item * getWidth());
                }
            });
        } else {
            setCurrentItemInner(smoothScroll, item * width);
        }

    }

    private void setCurrentItemInner(boolean smoothScroll, int x) {
        if (smoothScroll) {
            smoothScrollTo(x);
        } else {
            scrollTo(x, 0);
        }
    }


    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean touchEvent = super.dispatchTouchEvent(ev);
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                removeCallbacks(runnable);
                mVelocityTracker = VelocityTracker.obtain();
                break;
            case MotionEvent.ACTION_MOVE:
                mVelocityTracker.addMovement(ev);
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mVelocityTracker.clear();
                mVelocityTracker.recycle();
                postDelayed(runnable, runnable.mDelay);
                break;
        }
        return touchEvent;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mDownX = ev.getRawX();
                mDownY = ev.getRawY();
                break;
            case MotionEvent.ACTION_MOVE:
                float diffX = Math.abs(ev.getRawX() - mDownX);
                float diffY = Math.abs(ev.getRawY() - mDownY);
                if (mAdapter != null && mAdapter.getCount() > 1 && diffX > mTouchSlop && diffX > diffY) {//只有一个 item 不要滑动， 当手指拖动值大于TouchSlop值时，认为应该进行滚动，拦截子控件的事件
                    if (mState == SCROLL_STATE_SETTLING) {//还没有停止，又按下了
                        setScrollState(SCROLL_STATE_IDLE);
                        mScroller.abortAnimation();
                        int newPos = mScroller.getFinalX() / getWidth();
                        if (newPos != mCurrentPos) {
                            populate(newPos);
                            setPageSelected(newPos);
                        }
                    }
                    return true;
                }
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
        }
        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                break;
            case MotionEvent.ACTION_MOVE:
                getParent().requestDisallowInterceptTouchEvent(true);
                scrollTo((int) (mDownX - event.getRawX() + mCurrentPos * getWidth()), 0);
                setScrollState(SCROLL_STATE_DRAGGING);
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(mVelocityTracker, 0);
                if (Math.abs(mDownX - event.getRawX()) > mFlingDistance || Math.abs(initialVelocity) > mMinimumVelocity) {
                    if (mDownX < event.getRawX()) {
                        smoothScrollTo((mCurrentPos - 1) * getWidth());
                    } else {
                        smoothScrollTo((mCurrentPos + 1) * getWidth());
                    }
                } else {
                    smoothScrollTo(mCurrentPos * getWidth());
                }
                break;
        }
        return true;
    }

    private void populate(int newPos) {
        if (mAdapter == null) {
            return;
        }
        int count = mAdapter.getCount();
        if (count > 0) {
            if (DEBUG) {
                Log.i(TAG, mCurrentPos + " newpos " + newPos + "   populate  " + hashCode());
            }
            if (newPos <= -1) {
                mCurrentPos = count - 1;
            } else if (newPos >= count) {
                mCurrentPos = 0;
            } else {
                mCurrentPos = newPos;
            }
            int offsetLimit = Math.max(0, Math.min(count - 1, mOffsetLimit));
            int fist = mCurrentPos - offsetLimit;
            int last = mCurrentPos + offsetLimit;
            int childCount = getChildCount();
            ArrayList<LayoutParams> list = new ArrayList<LayoutParams>();
            SparseArray<View> cache = new SparseArray<View>();
            for (int i = 0; i < childCount; i++) {//如果是第一个和最后一个之间 就缓存上，其他的已经不需要缓存了
                View view = getChildAt(i);
                LayoutParams layoutParmas = (LayoutParams) view.getLayoutParams();
                if (layoutParmas.index < fist || layoutParmas.index > last) {
                    list.add(layoutParmas);
                } else {
                    cache.put(layoutParmas.index, view);
                }
            }
            for (LayoutParams layoutParams : list) {
                mAdapter.destroyItem(this, layoutParams.index, layoutParams.obj);
            }

            for (int i = fist, j = 0; i <= last; i++, j++) {//
                if (i < 0) {
                    View itemInfo = cache.get(i + count);
                    LayoutParams params;
                    if (itemInfo == null) {
                        Object res = mAdapter.instantiateItem(this, i + count);
                        params = (LayoutParams) getChildAt(getChildCount() - 1).getLayoutParams();
                        params.obj = res;
                    } else {
                        params = (LayoutParams) itemInfo.getLayoutParams();
                    }
                    params.index = i + count;//i=-1 当是0的时候，缓存前一个，index 是 adapter 的最后一个
                    params.layout = i;//i=-1  记录布局所在的位置
                } else if (i >= count) {
                    View itemInfo = cache.get(i);
                    LayoutParams params;
                    if (itemInfo == null) {
                        Object res = mAdapter.instantiateItem(this, i - count);
                        params = (LayoutParams) getChildAt(getChildCount() - 1).getLayoutParams();
                        params.obj = res;
                    } else {
                        params = (LayoutParams) itemInfo.getLayoutParams();
                    }
                    params.index = i - count;
                    params.layout = i;
                } else {
                    View itemInfo = cache.get(i);
                    LayoutParams params;
                    if (itemInfo == null) {
                        Object res = mAdapter.instantiateItem(this, i);
                        params = (LayoutParams) getChildAt(getChildCount() - 1).getLayoutParams();
                        params.obj = res;
                    } else {
                        params = (LayoutParams) itemInfo.getLayoutParams();
                    }
                    params.index = i;
                    params.layout = i;
                }
            }
            requestLayout();
        }
    }

    private void smoothScrollTo(int x) {
        if (DEBUG) {
            Log.i(TAG, mCurrentPos + "   smoothScrollTo  " + hashCode());
        }
        mScroller.startScroll(getScrollX(), 0, x - getScrollX(), 0);
        setScrollState(SCROLL_STATE_SETTLING);
        invalidate();
    }

    public void setScrollState(int state) {
        mState = state;
        if (mListener != null) {
            for (ViewPager.OnPageChangeListener onPageChangeListener : mListener) {
                onPageChangeListener.onPageScrollStateChanged(state);
            }
        }
    }

    @Override
    public void computeScroll() {
        int width = getWidth();
        if (SCROLL_STATE_SETTLING == mState && width > 0) {
            if (mScroller.computeScrollOffset()) {
                scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
                if (mListener != null) {
                    int dx = mScroller.getFinalX() - getScrollX();
                    for (ViewPager.OnPageChangeListener onPageChangeListener : mListener) {
                        if (dx < 0) {
                            onPageChangeListener.onPageScrolled(mCurrentPos - 1, -dx / width, -dx);
                        } else {
                            onPageChangeListener.onPageScrolled(mCurrentPos, dx / width, dx);
                        }
                    }
                }
                invalidate();
            } else {
                setScrollState(SCROLL_STATE_IDLE);
                int newPos = getScrollX() / width;
                if (newPos != mCurrentPos) {
                    populate(newPos);
                    setPageSelected(newPos);
                }
            }
        }
    }

    private void setPageSelected(int newPos) {
        if (mListener != null) {
            for (ViewPager.OnPageChangeListener onPageChangeListener : mListener) {
                onPageChangeListener.onPageSelected(newPos);
            }
        }
    }

    @Override
    protected void onVisibilityChanged(@NonNull View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            postDelayed(runnable, runnable.mDelay);
        } else {
            removeCallbacks(runnable);
        }
    }

    public void setLoop(boolean loop) {
        if (loop) {
            postDelayed(runnable, runnable.mDelay);
        } else {
            removeCallbacks(runnable);
        }
    }

    public FrameLayout.LayoutParams generateDotLayoutParams(int density) {
        FrameLayout.LayoutParams paramsDot = new FrameLayout.LayoutParams(-2, -2);
        paramsDot.gravity = Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
        paramsDot.bottomMargin = density;
        return paramsDot;
    }

    @Override
    public void addView(View child, int index, ViewGroup.LayoutParams params) {
        super.addView(child, -1, params);//每次都添加到最后一个 view
    }

    protected LayoutParams generateDefaultLayoutParams() {
        return new LayoutParams(-1, -1);
    }

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

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

    public static class LayoutParams extends FrameLayout.LayoutParams {
        private Object obj;
        private int index;
        private int layout;

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

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

    private static class NextRunnable implements Runnable {
        private final LoopViewPager vp;
        private int mDelay;

        public NextRunnable(LoopViewPager loopViewPager) {
            this.vp = loopViewPager;
        }

        @Override
        public void run() {
            vp.removeCallbacks(this);
            if (mDelay == 0 || vp.mAdapter == null || vp.mAdapter.getCount() <= 1 || (vp.getContext() instanceof Activity && ((Activity) vp.getContext()).isFinishing())) {//如果没有任何引用了，证明 activity 销毁了，停止循环
                return;
            }
            vp.setCurrentItem(vp.mCurrentPos + 1, true);
            vp.postDelayed(this, mDelay);
            if (DEBUG) {
                Log.i(TAG, "run  " + hashCode() + "  " + vp.hashCode());
            }
        }
    }

}
丁绍然
关注
专栏目录
android viewpager 轮播,Android ViewPager实现轮播图效果
weixin_42301009的博客
05-31 845
先上一张效果图：说到ViewPager实现轮播图效果，那么肯定会用到PagerAdapter，下面先介绍下这个类。PagerAdapter简介PagerAdapter是Android.support.v4包中的类，是一个抽象类，直接继承于Object，导入包android.support.v4.view.PagerAdapter即可使用。PagerAdapter主要是viewpager的适配器，而...
android viewpager实现轮播
热门推荐
qingwangwang的博客
10-20 9万+
本文是基于ViewPager实现的无限自动轮播banner 分为三步：第一部分是有限手动轮播；第二部分是无限轮播；第三部分是自动轮播；第四部分是指示器适配 有限手动轮播实现： 布局： <androidx.viewpager.widget.ViewPager android:id="@+id/banner" android:layout_width="match_parent" android:layout_height="wrap_content" andro
Android ViewPager轮播
qq_37841387的博客
11-05 239
Android ViewPager 不用最大值轮播
android-ViewPager的轮播
火星男孩的分享空间
06-13 658
viewpager的轮播实现需要 1、定时切换：每隔一定时间自动播放，也支持手动切换 2、无限播放：最后一张切到第一张重新播放第一步：主界面布局activity_main.xml<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.and
Android ViewPager 循环轮播
AntichristM's Blog
05-20 585
在很多App中，例如淘宝、京东的主界面都会有一个Banner轮播图，左右是无限循环滚动的，网上找解决方案确实能够搜索出非常多的帖子来，但是却没有看到一个是完善可用的方案。而这里这个方案能够完美解决这个问题。
Android Viewpager轮播
11-24
本项目"Android Viewpager轮播"就是一个典型的示例，它展示了如何利用ViewPager来实现广告轮播功能，类似于网易新闻和搜狐新闻顶部的广告展示。 首先，我们需要理解ViewPager的基本概念。ViewPager是Android ...
android viewpager轮播
11-19
综上所述，实现Android中的ViewPager轮播功能涉及到多个方面，包括数据源管理、适配器设计、无限轮播逻辑、自动滚动机制、指示器实现、事件监听以及性能优化。通过巧妙地组合和定制这些部分，可以创建出符合需求的...
Android使用ViewPager加载图片和轮播视频
01-20
在Android开发中，ViewPager是一个非常重要的组件，常用于实现页面滑动效果，比如常见的轮播图、tab切换等。在给定的标题和描述中，我们看到开发者正在尝试使用ViewPager来加载并展示聊天界面中的图片和视频，实现...
Android:ViewPager轮播图
07-10
自定义的viewpager，实现功能如下：无限自动轮播，pager点击事件处理，手指长按停止自动轮播，手指抬起恢复自动轮播；
android使用ViewPager实现轮播效果
01-04
ViewPager：一个可以实现视图左右滑动切换的控件。 ViewPager的基本使用： ViewPager的视图需要通过PagerAdapter来实现显示。 PagerAdapter的主要方法：   ● getCount 视图的数量   ● instantiateItem 添加视图   ● destroyItem 销毁视图   ● isViewFromObject 是否由对象创建视图 ViewPager的常用方法： setAdapter 设置适配器 addOnPageChangeListener 监听页面切换的状态 setCurrentItem 设置当前页面的索引 实现广告轮播 技
Android ViewPager实现轮播图效果
01-04
先上一张效果图： 说到ViewPager实现轮播图效果，那么肯定会用到PagerAdapter，下面先介绍下这个类。 PagerAdapter简介 PagerAdapter是Android.support.v4包中的类，是一个抽象类，直接继承于Object，导入包android.support.v4.view.PagerAdapter即可使用。 PagerAdapter主要是viewpager的适配器，而viewPager则也是在android.support.v4扩展包中新添加的一个强大的控件，可以实现控件的滑动效果，比如咱们在软件中常见的广告栏的滑动效果，用viewPager就可以实现。
Android中可无限循环轮播的ViewPager
03-19
技术要点：伪无限循环，加载本地图片，带标题和指示器，长按停止滚动，也可通过按钮控制滚动及停止，详细了解请移步http://blog.csdn.net/zxc514257857/article/details/63688217
Android使用ViewPager简单实现图片轮播效果
08-08
这个demo我在网上看了好多篇案例，可是没有一个案例是完整的demo,最后问我朋友才知道轮播方法的，里面有详细的介绍。适合新手...
Android-ViewPager实现广告轮播图
05-08
Android-ViewPager实现广告轮播图,集成过程请见CSDN博客介绍https://blog.csdn.net/weimeig/article/details/80242315
android的viewpager轮播,android ViewPager 轮播图的实现
weixin_35912261的博客
06-01 218
原理很简单，发送一个延迟消息就可以了，具体说明看代码：universal-imageloader 进行的图片加载;MainActivity：packagecom.hong.autoshowpager;importandroid.os.Handler;importandroid.os.Message;importandroid.support.v4.view.PagerAdapter;imp...
Android ViewPager+轮播图，android开发应用实战详解
m0_66145114的博客
01-23 509
v.setBackgroundResource(R.drawable.indicator_selected); LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(UIUtils.dip2px(6), UIUtils.dip2px(6));// dp // --> // px if (i != 0) { params.leftMargin = UIUtils.dip2px(8); params.bottomMargin =
Android ViewPager+轮播图
最新发布
2401_84121980的博客
04-14 677
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套腾讯、字节跳动、阿里、百度2019-2021面试真题解析，我把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包知识脉络 + 诸多细节。还有高级架构技术进阶脑图、Android开发面试专题资料帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。
Android使用ViewPager实现图片轮播系列之二：自动轮播
songzi1228的博客
12-31 745
目录 0、介绍 系列文章： 1、布局文件 2、VPTest2Activity.java 0、介绍 用Handler实现自动轮播 系列文章： Android使用ViewPager实现图片轮播系列之一：简单实现 Android使用ViewPager实现图片轮播系列之三：手动滑动 + 左右箭头 Android使用ViewPager实现图片轮播系列之四：手动滑动 + 左右箭头 + 删除...
android viewpager 轮播
10-10
Android的ViewPager是一种常用的布局容器，用于在屏幕上滑动显示多个页面。在实现轮播效果时，可以通过以下步骤来实现： 1. 首先，在XML布局文件中添加ViewPager组件。可以设置该组件的宽度和高度，以及其他属性，如指示器dots等。 2. 创建一个适配器类（如PagerAdapter），用于管理ViewPager中的页面。适配器需要重写一些方法，如获取页面数量、创建页面和销毁页面等。 3. 在创建页面的方法中，可以使用LayoutInflater.inflate()方法来加载布局文件，然后将其添加到ViewPager中。可以根据需求自定义每个页面的布局。 4. 在Activity或Fragment中，通过findViewById()方法获取ViewPager组件的实例，并设置适配器。例如： ViewPager viewPager = findViewById(R.id.viewPager); viewPager.setAdapter(adapter); 5. 如果需要实现轮播效果，可以通过设置ViewPager的setCurrentItem()方法来切换页面。可以使用Handler类来实现定时切换页面的效果。例如： Handler handler = new Handler(); Runnable runnable = new Runnable() { @Override public void run() { int currentItem = viewPager.getCurrentItem(); if (currentItem < adapter.getCount() - 1) { currentItem++; } else { currentItem = 0; } viewPager.setCurrentItem(currentItem); handler.postDelayed(this, 3000); // 间隔3秒切换页面 } }; handler.postDelayed(runnable, 3000); 以上就是使用Android的ViewPager实现轮播效果的简要步骤。通过设置适配器和定时切换页面，可以让多个页面在屏幕上自动滑动显示，从而实现轮播效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值