深度剖析 Android ViewPager：从源码探究其使用原理

深度剖析 Android ViewPager：从源码探究其使用原理

一、引言

在 Android 应用开发的世界里，界面的交互性和流畅性是至关重要的。ViewPager 作为 Android 开发中一个强大且常用的组件，在实现页面切换和滑动效果方面发挥着重要作用。无论是引导页、图片轮播，还是多页面展示，ViewPager 都能轻松胜任。本文将深入到 Android 源码的层面，全面且细致地分析 ViewPager 的使用原理，帮助开发者更好地理解和运用这个组件。

二、ViewPager 概述

2.1 基本概念

ViewPager 是 Android 支持库中的一个控件，它继承自 ViewGroup，用于实现页面之间的滑动切换效果。用户可以通过左右滑动屏幕来浏览不同的页面，就像翻阅书籍一样。ViewPager 提供了一种简单而高效的方式来管理多个页面，并且支持页面切换的动画效果，增强了用户体验。

2.2 核心特性

• 页面滑动切换：用户可以通过手指左右滑动来切换不同的页面，这是 ViewPager 最基本也是最核心的功能。
• 适配器模式：ViewPager 使用适配器（PagerAdapter）来管理页面的创建和销毁。适配器负责提供每个页面的视图，使得 ViewPager 可以动态地加载和显示不同的页面。
• 页面切换动画：支持自定义页面切换动画，开发者可以通过设置 PageTransformer 来实现各种炫酷的页面切换效果。
• 页面指示器支持：可以与 PageIndicator 配合使用，提供页面指示器，帮助用户直观地了解当前页面的位置。

2.3 基础使用示例

以下是一个简单的 ViewPager 使用示例，展示了如何使用 ViewPager 实现基本的页面切换功能：

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;
import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;

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

        // 获取 ViewPager 实例
        viewPager = findViewById(R.id.viewPager);

        // 准备页面数据
        List<String> pageData = new ArrayList<>();
        pageData.add("Page 1");
        pageData.add("Page 2");
        pageData.add("Page 3");

        // 创建适配器
        MyPagerAdapter adapter = new MyPagerAdapter(pageData);

        // 设置适配器
        viewPager.setAdapter(adapter);
    }

    private class MyPagerAdapter extends PagerAdapter {

        private List<String> data;

        public MyPagerAdapter(List<String> data) {
            this.data = data;
        }

        @Override
        public int getCount() {
            // 返回页面数量
            return data.size();
        }

        @Override
        public boolean isViewFromObject(View view, Object object) {
            // 判断视图是否来自对象
            return view == object;
        }

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            // 实例化页面视图
            View view = LayoutInflater.from(container.getContext()).inflate(R.layout.page_item, container, false);
            TextView textView = view.findViewById(R.id.textView);
            textView.setText(data.get(position));
            container.addView(view);
            return view;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            // 销毁页面视图
            container.removeView((View) object);
        }
    }
}

<!-- activity_main.xml -->
<androidx.viewpager.widget.ViewPager
    android:id="@+id/viewPager"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

<!-- page_item.xml -->
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/textView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:textSize="24sp" />

在这个示例中，我们创建了一个 ViewPager，并为其设置了一个自定义的 PagerAdapter。适配器负责提供每个页面的视图，当用户滑动 ViewPager 时，会根据适配器提供的视图进行页面切换。

三、ViewPager 的基本结构

3.1 类继承关系

ViewPager 的类继承层级如下：

java.lang.Object
    ↳ android.view.View
        ↳ android.view.ViewGroup
            ↳ androidx.viewpager.widget.ViewPager

从继承链可以看出，ViewPager 继承自 ViewGroup，因此它具有 ViewGroup 的特性，能够包含多个子视图。同时，ViewPager 在 ViewGroup 的基础上增加了页面滑动切换的功能。

3.2 核心成员变量

ViewPager 内部维护了多个关键的成员变量，用于存储页面相关的信息和控制页面的滑动：

// 适配器，用于管理页面的创建和销毁
private PagerAdapter mAdapter; 
// 当前显示的页面位置
private int mCurrentItem; 
// 页面滚动状态
private int mScrollState; 
// 页面滚动监听器列表
private ArrayList<OnPageChangeListener> mOnPageChangeListeners; 
// 用于处理滚动的 Scroller 对象
private Scroller mScroller; 

• mAdapter：负责提供页面的视图，管理页面的创建和销毁。
• mCurrentItem：记录当前显示的页面位置，从 0 开始计数。
• mScrollState：表示页面的滚动状态，有三种状态：SCROLL_STATE_IDLE（静止状态）、SCROLL_STATE_DRAGGING（拖动状态）、SCROLL_STATE_SETTLING（自动滚动状态）。
• mOnPageChangeListeners：存储所有注册的页面滚动监听器，当页面滚动状态或位置发生变化时，会通知这些监听器。
• mScroller：用于处理页面的平滑滚动效果，根据指定的起始位置、偏移量和持续时间来实现平滑的滚动动画。

3.3 关键方法定义

ViewPager 通过重写一些关键方法来实现页面的滑动切换功能：

// 设置适配器
public void setAdapter(PagerAdapter adapter) {
    // 如果之前已经有适配器，先进行清理操作
    if (mAdapter != null) {
        mAdapter.startUpdate(this);
        for (int i = 0; i < mItems.size(); i++) {
            final ItemInfo ii = mItems.get(i);
            mAdapter.destroyItem(this, ii.position, ii.object);
        }
        mAdapter.finishUpdate(this);
        mItems.clear();
        removeNonDecorViews();
    }
    // 更新适配器
    mAdapter = adapter;
    mExpectedAdapterCount = 0;
    if (mAdapter != null) {
        mPopulatePending = false;
        if (mObserver == null) {
            mObserver = new PagerObserver();
        }
        mAdapter.registerDataSetObserver(mObserver);
        mPopulatePending = true;
        // 计算页面数量
        mExpectedAdapterCount = mAdapter.getCount();
        // 填充页面
        populate();
    } else {
        mPopulatePending = false;
        removeNonDecorViews();
    }
    requestLayout();
}

// 获取当前显示的页面位置
public int getCurrentItem() {
    return mCurrentItem;
}

// 设置当前显示的页面位置
public void setCurrentItem(int item) {
    setCurrentItemInternal(item, true, false);
}

// 内部设置当前显示的页面位置的方法
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
    setCurrentItemInternal(item, smoothScroll, always, 0);
}

// 内部设置当前显示的页面位置的方法，包含滚动偏移量
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
    if (mAdapter == null || mAdapter.getCount() <= 0) {
        setScrollingCacheEnabled(false);
        return;
    }
    if (!always && mCurrentItem == item && mItems.size() != 0) {
        setScrollingCacheEnabled(false);
        return;
    }
    if (item < 0) {
        item = 0;
    } else if (item >= mAdapter.getCount()) {
        item = mAdapter.getCount() - 1;
    }
    final int pageLimit = mOffscreenPageLimit;
    if (item > (mCurrentItem + pageLimit) || item < (mCurrentItem - pageLimit)) {
        // 如果页面跨度较大，直接跳转
        for (int i = 0; i < mItems.size(); i++) {
            mItems.get(i).scrolling = false;
        }
        populate(item);
    }
    final boolean dispatchSelected = mCurrentItem != item;
    if (mFirstLayout) {
        // 如果是第一次布局，先记录要显示的页面位置
        mCurrentItem = item;
        if (dispatchSelected) {
            dispatchOnPageSelected(item);
        }
        requestLayout();
    } else {
        // 进行页面切换
        scrollToItem(item, smoothScroll, velocity, dispatchSelected);
    }
}

// 滚动到指定页面
void scrollToItem(int item, boolean smoothScroll, int velocity, boolean dispatchSelected) {
    final ItemInfo curInfo = infoForPosition(mCurrentItem);
    final ItemInfo newInfo = infoForPosition(item);
    if (curInfo == null || newInfo == null) {
        return;
    }
    int destX = 0;
    if (newInfo.position > curInfo.position) {
        for (int i = curInfo.position; i < newInfo.position; i++) {
            destX += mItems.get(i).widthWithMargin;
        }
    } else if (newInfo.position < curInfo.position) {
        for (int i = newInfo.position; i < curInfo.position; i++) {
            destX -= mItems.get(i).widthWithMargin;
        }
    }
    if (smoothScroll) {
        // 平滑滚动到指定页面
        smoothScrollTo(destX, 0, velocity);
        if (dispatchSelected) {
            dispatchOnPageSelected(item);
        }
    } else {
        // 直接滚动到指定页面
        if (dispatchSelected) {
            dispatchOnPageSelected(item);
        }
        completeScroll(false);
        scrollTo(destX, 0);
        pageScrolled(destX);
    }
    mCurrentItem = item;
}

• setAdapter：用于设置 ViewPager 的适配器，当适配器发生变化时，会清理之前的页面并重新填充页面。
• getCurrentItem：获取当前显示的页面位置。
• setCurrentItem：设置当前显示的页面位置，可以选择是否使用平滑滚动效果。
• setCurrentItemInternal：内部设置当前显示页面位置的方法，处理了页面跨度较大时的情况。
• scrollToItem：根据指定的页面位置计算滚动的偏移量，并进行滚动操作，可以选择平滑滚动或直接滚动。

四、适配器（PagerAdapter）机制

4.1 适配器的作用

适配器是 ViewPager 的核心组成部分，它负责管理页面的创建和销毁。ViewPager 通过适配器获取每个页面的视图，并在需要时调用适配器的方法来创建或销毁页面。适配器的使用使得 ViewPager 可以动态地加载和显示不同的页面，提高了代码的灵活性和可维护性。

4.2 适配器的基本方法

PagerAdapter 是一个抽象类，使用时需要继承它并实现以下几个重要的方法：

// 返回页面的数量
@Override
public int getCount() {
    return data.size();
}

// 判断视图是否来自对象
@Override
public boolean isViewFromObject(View view, Object object) {
    return view == object;
}

// 实例化页面视图
@Override
public Object instantiateItem(ViewGroup container, int position) {
    View view = LayoutInflater.from(container.getContext()).inflate(R.layout.page_item, container, false);
    TextView textView = view.findViewById(R.id.textView);
    textView.setText(data.get(position));
    container.addView(view);
    return view;
}

// 销毁页面视图
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    container.removeView((View) object);
}

• getCount：返回 ViewPager 中页面的数量，ViewPager 会根据这个数量来确定可以显示的页面范围。
• isViewFromObject：用于判断一个视图是否来自指定的对象，通常直接返回 view == object。
• instantiateItem：在需要显示某个页面时，ViewPager 会调用该方法来实例化页面的视图。在该方法中，需要创建页面的视图并添加到容器中，最后返回该视图。
• destroyItem：当某个页面不再需要显示时，ViewPager 会调用该方法来销毁页面的视图。在该方法中，需要从容器中移除该视图。

4.3 不同类型的适配器

除了 PagerAdapter，Android 还提供了其他类型的适配器，用于不同的场景：

• FragmentPagerAdapter：适用于页面数量较少且页面为 Fragment 的场景。它会将每个 Fragment 保留在内存中，当页面切换时，只是隐藏或显示相应的 Fragment。

import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;

public class MyFragmentPagerAdapter extends FragmentPagerAdapter {

    private List<Fragment> fragments;

    public MyFragmentPagerAdapter(FragmentManager fm, List<Fragment> fragments) {
        super(fm);
        this.fragments = fragments;
    }

    @Override
    public Fragment getItem(int position) {
        return fragments.get(position);
    }

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

• FragmentStatePagerAdapter：适用于页面数量较多且页面为 Fragment 的场景。它会在页面不再需要显示时销毁 Fragment 的实例，以节省内存。

import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentStatePagerAdapter;

public class MyFragmentStatePagerAdapter extends FragmentStatePagerAdapter {

    private List<Fragment> fragments;

    public MyFragmentStatePagerAdapter(FragmentManager fm, List<Fragment> fragments) {
        super(fm);
        this.fragments = fragments;
    }

    @Override
    public Fragment getItem(int position) {
        return fragments.get(position);
    }

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

4.4 适配器的数据更新

当适配器的数据发生变化时，需要调用适配器的 notifyDataSetChanged 方法来通知 ViewPager 数据已经更新。ViewPager 会重新调用适配器的方法来更新页面的显示：

// 假设 adapter 是 ViewPager 的适配器
adapter.notifyDataSetChanged();

在调用 notifyDataSetChanged 方法后，ViewPager 会重新计算页面的数量，并根据新的数据重新创建或销毁页面。

五、布局测量过程详解

5.1 测量流程总览

ViewPager 的测量过程与普通的 ViewGroup 类似，但由于其支持页面滑动切换，需要对测量结果进行一些特殊处理。具体流程如下：

1. 调用父类测量 ：首先调用 ViewGroup 的 onMeasure 方法进行基本的测量。
2. 测量子视图 ：遍历 ViewPager 的子视图，调用 measureChild 方法对其进行测量。
3. 处理页面宽度：根据页面的宽度和边距，计算 ViewPager 的总宽度。
4. 设置测量尺寸：根据测量结果，设置 ViewPager 的最终测量尺寸。

5.2 onMeasure 方法解析

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // 调用父类的测量方法进行基本测量
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);

    if (getChildCount() == 0) {
        // 如果没有子视图，设置测量尺寸为 0
        setMeasuredDimension(0, 0);
        return;
    }

    // 获取 ViewPager 的宽度测量模式和大小
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
    // 获取 ViewPager 的高度测量模式和大小
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);

    int childWidthMeasureSpec;
    int childHeightMeasureSpec;

    // 根据 ViewPager 的宽度测量模式确定子视图的宽度测量规格
    if (widthMode == MeasureSpec.EXACTLY) {
        // 如果 ViewPager 的宽度是精确值，子视图的宽度也为该精确值
        childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, MeasureSpec.EXACTLY);
    } else {
        // 否则，子视图的宽度根据自身内容确定
        childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
    }

    // 根据 ViewPager 的高度测量模式确定子视图的高度测量规格
    if (heightMode == MeasureSpec.EXACTLY) {
        // 如果 ViewPager 的高度是精确值，子视图的高度也为该精确值
        childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY);
    } else {
        // 否则，子视图的高度根据自身内容确定
        childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
    }

    // 测量子视图
    for (int i = 0; i < getChildCount(); i++) {
        View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        }
    }

    // 处理 ViewPager 的宽度测量结果
    if (widthMode != MeasureSpec.EXACTLY) {
        int maxChildWidth = 0;
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                int childWidth = child.getMeasuredWidth();
                if (childWidth > maxChildWidth) {
                    maxChildWidth = childWidth;
                }
            }
        }
        widthSize = maxChildWidth;
    }

    // 处理 ViewPager 的高度测量结果
    if (heightMode != MeasureSpec.EXACTLY) {
        int maxChildHeight = 0;
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                int childHeight = child.getMeasuredHeight();
                if (childHeight > maxChildHeight) {
                    maxChildHeight = childHeight;
                }
            }
        }
        heightSize = maxChildHeight;
    }

    // 设置 ViewPager 的测量尺寸
    setMeasuredDimension(widthSize, heightSize);
}

在 onMeasure 方法中，首先调用父类的 onMeasure 方法进行基本测量。然后根据 ViewPager 的宽度和高度测量模式，确定子视图的测量规格，并对其进行测量。最后，根据子视图的测量结果，调整 ViewPager 的宽度和高度测量尺寸，并调用 setMeasuredDimension 方法设置最终的测量结果。

5.3 测量子视图的规则

在测量子视图时，ViewPager 根据自身的测量模式来确定子视图的测量规格：

• 宽度测量 ：
  • 如果 ViewPager 的宽度测量模式为 EXACTLY，则子视图的宽度测量规格也为 EXACTLY，且宽度值为 ViewPager 的宽度。
  • 如果 ViewPager 的宽度测量模式为 AT_MOST 或 UNSPECIFIED，则子视图的宽度测量规格为 UNSPECIFIED，子视图的宽度根据自身内容确定。
• 高度测量 ：
  • 如果 ViewPager 的高度测量模式为 EXACTLY，则子视图的高度测量规格也为 EXACTLY，且高度值为 ViewPager 的高度。
  • 如果 ViewPager 的高度测量模式为 AT_MOST 或 UNSPECIFIED，则子视图的高度测量规格为 UNSPECIFIED，子视图的高度根据自身内容确定。

5.4 处理页面宽度的逻辑

在测量过程中，ViewPager 会考虑页面的宽度和边距。如果页面有边距，会将边距也计算到总宽度中。同时，如果 ViewPager 的宽度测量模式不是 EXACTLY，会根据子视图的最大宽度来确定 ViewPager 的宽度。

六、布局摆放过程解析

6.1 onLayout 方法实现

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    // 获取 ViewPager 的宽度和高度
    int width = r - l;
    int height = b - t;

    // 遍历子视图进行布局
    for (int i = 0; i < getChildCount(); i++) {
        View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            // 计算子视图的位置
            int childLeft = i * width;
            int childTop = 0;
            int childRight = childLeft + child.getMeasuredWidth();
            int childBottom = childTop + child.getMeasuredHeight();
            // 摆放子视图
            child.layout(childLeft, childTop, childRight, childBottom);
        }
    }
}

在 onLayout 方法中，首先获取 ViewPager 的宽度和高度。然后遍历所有子视图，根据子视图的索引计算其在水平方向上的位置，垂直方向上从顶部开始摆放。最后调用 layout 方法将子视图摆放在合适的位置。

6.2 子视图布局规则

ViewPager 的子视图布局规则是按照水平方向依次排列，每个子视图的宽度通常为 ViewPager 的宽度。子视图的高度根据其测量结果确定。

6.3 页面切换时的布局调整

当用户滑动 ViewPager 进行页面切换时，ViewPager 会根据滚动的偏移量来调整子视图的显示位置。通过 scrollTo 方法将 ViewPager 滚动到指定的位置，从而显示不同的页面。

// 滚动到指定的 X 位置
scrollTo(x, 0);

在滚动过程中，ViewPager 会不断调用 invalidate 方法来刷新视图，确保页面的显示效果流畅。

七、滚动事件处理

7.1 触摸事件分发

ViewPager 通过重写 onTouchEvent 方法来处理用户的触摸事件。在 onTouchEvent 方法中，会根据不同的触摸事件类型进行相应的处理：

@Override
public boolean onTouchEvent(MotionEvent ev) {
    if (mIsBeingDragged) {
        // 如果正在拖动，处理拖动事件
        mLastMotionX = ev.getX();
        int deltaX = (int) (mLastMotionX - mInitialMotionX);
        scrollBy(-deltaX, 0);
        return true;
    }

    switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN:
            // 处理按下事件
            mInitialMotionX = ev.getX();
            mLastMotionX = mInitialMotionX;
            mIsBeingDragged = false;
            break;
        case MotionEvent.ACTION_MOVE:
            // 处理移动事件
            float x = ev.getX();
            float dx = x - mLastMotionX;
            if (!mIsBeingDragged && Math.abs(dx) > mTouchSlop) {
                mIsBeingDragged = true;
            }
            if (mIsBeingDragged) {
                mLastMotionX = x;
                scrollBy((int) -dx, 0);
            }
            break;
        case MotionEvent.ACTION_UP:
            // 处理抬起事件
            if (mIsBeingDragged) {
                mIsBeingDragged = false;
                // 计算滚动到的页面
                int position = calculateTargetPosition();
                setCurrentItem(position, true);
            }
            break;
    }
    return true;
}

在 onTouchEvent 方法中，首先检查是否正在拖动。如果正在拖动，则根据手指的移动距离进行滚动。对于不同的触摸事件类型：

• ACTION_DOWN：记录按下时的 X 坐标，并将拖动状态标记为 false。
• ACTION_MOVE：计算手指的移动距离，如果移动距离超过了一定的阈值（mTouchSlop），则将拖动状态标记为 true，并进行滚动操作。
• ACTION_UP：如果正在拖动，停止拖动状态，并根据滚动的位置计算要滚动到的页面，然后调用 setCurrentItem 方法进行页面切换。

7.2 手势检测与滚动逻辑

ViewPager 还使用了手势检测器（GestureDetector）来检测用户的手势，如快速滑动等。通过手势检测器可以实现更丰富的滚动效果：

private GestureDetector mGestureDetector;

@Override
public boolean onTouchEvent(MotionEvent ev) {
    if (mGestureDetector.onTouchEvent(ev)) {
        return true;
    }
    // 处理其他触摸事件
    return super.onTouchEvent(ev);
}

private GestureDetector.SimpleOnGestureListener mGestureListener = new GestureDetector.SimpleOnGestureListener() {
    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        // 处理快速滑动事件
        if (Math.abs(velocityX) > mMinimumVelocity) {
            if (velocityX > 0) {
                // 向左快速滑动，切换到上一页
                setCurrentItem(mCurrentItem - 1, true);
            } else {
                // 向右快速滑动，切换到下一页
                setCurrentItem(mCurrentItem + 1, true);
            }
            return true;
        }
        return false;
    }
};

在 onTouchEvent 方法中，将触摸事件传递给手势检测器处理。在手势监听器的 onFling 方法中，根据快速滑动的速度和方向来判断是切换到上一页还是下一页。

7.3 滚动边界处理

在滚动过程中，需要处理滚动边界问题，即确保 ViewPager 不会滚动超出页面的范围。在 scrollTo 方法中，会进行边界检查：

@Override
public void scrollTo(int x, int y) {
    if (getChildCount() > 0) {
        int maxScrollX = (getChildCount() - 1) * getWidth();
        if (x < 0) {
            x = 0;
        } else if (x > maxScrollX) {
            x = maxScrollX;
        }
        if (x != getScrollX()) {
            super.scrollTo(x, y);
        }
    }
}

在 scrollTo 方法中，计算出最大的滚动偏移量 maxScrollX，并检查传入的滚动位置 x 是否超出了这个范围。如果超出，则将滚动位置调整到合法范围内。

八、平滑滚动实现

8.1 Scroller 类介绍

Scroller 是 Android 提供的一个用于实现平滑滚动效果的类。它可以根据指定的起始位置、偏移量和持续时间来计算滚动的中间位置，从而实现平滑的滚动动画。ViewPager 中使用 Scroller 来实现页面的平滑切换效果。

8.2 smoothScrollTo 方法解析

private void smoothScrollTo(int x, int y, int velocity) {
    if (getChildCount() == 0) {
        return;
    }
    int sx = getScrollX();
    int sy = getScrollY();
    int dx = x - sx;
    int dy = y - sy;
    if (dx == 0 && dy == 0) {
        completeScroll(false);
        return;
    }
    // 开始平滑滚动
    mScroller.startScroll(sx, sy, dx, dy, calculateDuration(dx, velocity));
    invalidate();
}

在 smoothScrollTo 方法中，首先获取当前的滚动位置 sx 和 sy，计算出要滚动的偏移量 dx 和 dy。如果偏移量为 0，则直接完成滚动。否则，调用 Scroller 的 startScroll 方法开始平滑滚动，传入起始位置、偏移量和持续时间。最后调用 invalidate 方法刷新视图，触发 computeScroll 方法。

8.3 computeScroll 方法的作用

computeScroll 方法是 ViewPager 实现平滑滚动的关键方法。在 computeScroll 方法中，会不断更新滚动位置，直到滚动结束：

@Override
public void computeScroll() {
    if (mScroller.computeScrollOffset()) {
        // 获取 Scroller 当前的滚动位置
        int x = mScroller.getCurrX();
        int y = mScroller.getCurrY();
        // 滚动到指定位置
        scrollTo(x, y);
        // 继续刷新视图
        postInvalidate();
    }
}

在 computeScroll 方法中，首先调用 Scroller 的 computeScrollOffset 方法来计算当前的滚动位置。如果滚动还未结束，则获取当前的滚动位置 x 和 y，并调用 scrollTo 方法将 ViewPager 滚动到该位置。最后调用 postInvalidate 方法继续刷新视图，直到滚动结束。

九、页面切换动画

9.1 基本动画原理

ViewPager 支持通过设置 PageTransformer 来实现自定义的页面切换动画。PageTransformer 是一个接口，需要实现其 transformPage 方法来定义页面切换的动画效果。在 transformPage 方法中，可以通过修改页面的属性（如位置、旋转、缩放等）来实现不同的动画效果。

9.2 简单动画示例

以下是一个简单的 PageTransformer 示例，实现了页面缩放的动画效果：

import android.view.View;
import androidx.viewpager.widget.ViewPager;

public class ZoomOutPageTransformer implements ViewPager.PageTransformer {
    private static final float MIN_SCALE = 0.85f;
    private static final float MIN_ALPHA = 0.5f;

    @Override
    public void transformPage(View page, float position) {
        int pageWidth = page.getWidth();
        int pageHeight = page.getHeight();

        if (position < -1) { // [-Infinity,-1)
            // 页面在左侧，完全不可见
            page.setAlpha(0f);
        } else if (position <= 1) { // [-1,1]
            // 修改缩放比例
            float scaleFactor = Math.max(MIN_SCALE, 1 - Math.abs(position));
            float vertMargin = pageHeight * (1 - scaleFactor) / 2;
            float horzMargin = pageWidth * (1 - scaleFactor) / 2;

            if (position < 0) {
                page.setTranslationX(horzMargin - vertMargin / 2);
            } else {
                page.setTranslationX(-horzMargin + vertMargin / 2);
            }

            // 缩放页面
            page.setScaleX(scaleFactor);
            page.setScaleY(scaleFactor);

            // 修改透明度
            page.setAlpha(MIN_ALPHA +
                    (scaleFactor - MIN_SCALE) /
                            (1 - MIN_SCALE) * (1 - MIN_ALPHA));
        } else { // (1,+Infinity]
            // 页面在右侧，完全不可见
            page.setAlpha(0f);
        }
    }
}

在这个示例中，ZoomOutPageTransformer 实现了 PageTransformer 接口。在 transformPage 方法中，根据页面的位置 position 来修改页面的缩放比例和透明度。当页面在中间时，缩放比例为 1，透明度为 1；当页面向两侧滑动时，缩放比例逐渐减小，透明度也逐渐降低。

9.3 设置页面切换动画

要为 ViewPager 设置页面切换动画，只需要调用 setPageTransformer 方法，并传入自定义的 PageTransformer 实例：

ViewPager viewPager = findViewById(R.id.viewPager);
viewPager.setPageTransformer(true, new ZoomOutPageTransformer());

在调用 setPageTransformer 方法时，第一个参数表示是否支持页面重叠显示，第二个参数是自定义的 PageTransformer 实例。

十、页面指示器

10.1 页面指示器的作用

页面指示器用于帮助用户直观地了解当前页面的位置和页面的总数。在 ViewPager 中，通常会使用一个小圆点或数字来表示每个页面，当前页面的指示器会有不同的样式，以突出显示。

10.2 自定义页面指示器示例

以下是一个简单的自定义页面指示器示例，使用 LinearLayout 来显示小圆点：

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.view.Gravity;
import android.view.View;
import android.widget.LinearLayout;
import androidx.core.content.ContextCompat;
import androidx.viewpager.widget.ViewPager;

public class CustomPageIndicator extends LinearLayout {

    private Context mContext;
    private int mDotCount;
    private Drawable mActiveDot;
    private Drawable mInactiveDot;
    private ViewPager mViewPager;

    public CustomPageIndicator(Context context, ViewPager viewPager) {
        super(context);
        mContext = context;
        mViewPager = viewPager;
        mActiveDot = ContextCompat.getDrawable(context, R.drawable.active_dot);
        mInactiveDot = ContextCompat.getDrawable(context, R.drawable.inactive_dot);
        setOrientation(HORIZONTAL);
        setGravity(Gravity.CENTER);
        setupDots();
        setupViewPagerListener();
    }

    private void setupDots() {
        mDotCount = mViewPager.getAdapter().getCount();
        for (int i = 0; i < mDotCount; i++) {
            View dot = new View(mContext);
            dot.setLayoutParams(new LayoutParams(20, 20));
            dot.setPadding(10, 0, 10, 0);
            if (i == 0) {
                dot.setBackground(mActiveDot);
            } else {
                dot.setBackground(mInactiveDot);
            }
            addView(dot);
        }
    }

    private void setupViewPagerListener() {
        mViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset

10.2 自定义页面指示器示例（续）

            {
                // 页面滚动时的回调，这里暂不做处理
            }

            @Override
            public void onPageSelected(int position) {
                // 当页面被选中时，更新指示器的状态
                for (int i = 0; i < mDotCount; i++) {
                    View dot = getChildAt(i);
                    if (i == position) {
                        // 当前选中的页面，设置为激活状态的圆点
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                            dot.setBackground(mActiveDot);
                        } else {
                            dot.setBackgroundDrawable(mActiveDot);
                        }
                    } else {
                        // 其他页面，设置为未激活状态的圆点
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                            dot.setBackground(mInactiveDot);
                        } else {
                            dot.setBackgroundDrawable(mInactiveDot);
                        }
                    }
                }
            }

            @Override
            public void onPageScrollStateChanged(int state) {
                // 页面滚动状态改变时的回调，这里暂不做处理
            }
        });
    }
}

<!-- res/drawable/active_dot.xml -->
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">
    <solid android:color="#FFFFFF" />
    <size android:width="10dp" android:height="10dp" />
</shape>

<!-- res/drawable/inactive_dot.xml -->
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">
    <solid android:color="#80FFFFFF" />
    <size android:width="10dp" android:height="10dp" />
</shape>

在上述代码中，CustomPageIndicator 类继承自 LinearLayout，用于创建自定义的页面指示器。在构造函数中，首先初始化了上下文、ViewPager 实例以及激活和未激活状态的圆点图标。然后调用 setupDots 方法，根据 ViewPager 的页面数量创建相应数量的圆点视图，并将第一个圆点设置为激活状态。接着调用 setupViewPagerListener 方法，为 ViewPager 添加一个 OnPageChangeListener 监听器。当页面被选中时，onPageSelected 方法会被调用，在该方法中会遍历所有的圆点视图，将当前选中页面的圆点设置为激活状态，其他圆点设置为未激活状态。

10.3 常见的页面指示器库

除了自定义页面指示器，还有一些常见的开源库可以方便地实现页面指示器功能，如 CircleIndicator 和 TabLayout。

10.3.1 CircleIndicator

CircleIndicator 是一个简单易用的圆形页面指示器库，它可以与 ViewPager 无缝集成。以下是使用 CircleIndicator 的示例：

<!-- 在布局文件中添加 ViewPager 和 CircleIndicator -->
<androidx.viewpager.widget.ViewPager
    android:id="@+id/viewPager"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

<me.relex.circleindicator.CircleIndicator
    android:id="@+id/circleIndicator"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="bottom|center_horizontal"
    android:padding="10dp" />

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;
import me.relex.circleindicator.CircleIndicator;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;
    private CircleIndicator circleIndicator;

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

        viewPager = findViewById(R.id.viewPager);
        circleIndicator = findViewById(R.id.circleIndicator);

        // 设置 ViewPager 的适配器
        MyPagerAdapter adapter = new MyPagerAdapter();
        viewPager.setAdapter(adapter);

        // 将 CircleIndicator 与 ViewPager 关联
        circleIndicator.setViewPager(viewPager);
    }
}

在上述代码中，首先在布局文件中添加了 ViewPager 和 CircleIndicator。然后在 MainActivity 中，为 ViewPager 设置适配器，并调用 CircleIndicator 的 setViewPager 方法将其与 ViewPager 关联起来。这样，CircleIndicator 就会自动根据 ViewPager 的页面切换更新指示器的状态。

10.3.2 TabLayout

TabLayout 是 Android 设计支持库中的一个组件，它不仅可以作为页面指示器，还可以实现标签页的切换功能。以下是使用 TabLayout 的示例：

<!-- 在布局文件中添加 ViewPager 和 TabLayout -->
<com.google.android.material.tabs.TabLayout
    android:id="@+id/tabLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@color/colorPrimary" />

<androidx.viewpager.widget.ViewPager
    android:id="@+id/viewPager"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;
    private TabLayout tabLayout;

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

        viewPager = findViewById(R.id.viewPager);
        tabLayout = findViewById(R.id.tabLayout);

        // 设置 ViewPager 的适配器
        MyPagerAdapter adapter = new MyPagerAdapter(getSupportFragmentManager());
        viewPager.setAdapter(adapter);

        // 将 TabLayout 与 ViewPager 关联
        tabLayout.setupWithViewPager(viewPager);
    }
}

在上述代码中，首先在布局文件中添加了 ViewPager 和 TabLayout。然后在 MainActivity 中，为 ViewPager 设置适配器，并调用 TabLayout 的 setupWithViewPager 方法将其与 ViewPager 关联起来。这样，TabLayout 会根据 ViewPager 的页面数量自动创建相应的标签页，并且在页面切换时会自动更新选中的标签页。

十一、与 Fragment 的结合使用

11.1 使用 FragmentPagerAdapter

FragmentPagerAdapter 是 PagerAdapter 的一个子类，专门用于管理 Fragment 页面。它适用于页面数量较少且需要保留 Fragment 实例的场景。以下是使用 FragmentPagerAdapter 的示例：

import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import java.util.ArrayList;
import java.util.List;

public class MyFragmentPagerAdapter extends FragmentPagerAdapter {

    private List<Fragment> fragmentList = new ArrayList<>();
    private List<String> titleList = new ArrayList<>();

    public MyFragmentPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    public void addFragment(Fragment fragment, String title) {
        fragmentList.add(fragment);
        titleList.add(title);
    }

    @Override
    public Fragment getItem(int position) {
        // 根据位置返回对应的 Fragment 实例
        return fragmentList.get(position);
    }

    @Override
    public int getCount() {
        // 返回 Fragment 的数量
        return fragmentList.size();
    }

    @Override
    public CharSequence getPageTitle(int position) {
        // 返回每个页面的标题
        return titleList.get(position);
    }
}

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;
    private TabLayout tabLayout;

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

        viewPager = findViewById(R.id.viewPager);
        tabLayout = findViewById(R.id.tabLayout);

        MyFragmentPagerAdapter adapter = new MyFragmentPagerAdapter(getSupportFragmentManager());

        // 添加 Fragment 页面
        adapter.addFragment(new FirstFragment(), "First");
        adapter.addFragment(new SecondFragment(), "Second");
        adapter.addFragment(new ThirdFragment(), "Third");

        viewPager.setAdapter(adapter);
        tabLayout.setupWithViewPager(viewPager);
    }
}

在上述代码中，MyFragmentPagerAdapter 继承自 FragmentPagerAdapter，并实现了 getItem、getCount 和 getPageTitle 方法。getItem 方法根据位置返回对应的 Fragment 实例，getCount 方法返回 Fragment 的数量，getPageTitle 方法返回每个页面的标题。在 MainActivity 中，创建了 MyFragmentPagerAdapter 实例，并添加了三个 Fragment 页面，然后将适配器设置给 ViewPager，并将 TabLayout 与 ViewPager 关联起来。

11.2 使用 FragmentStatePagerAdapter

FragmentStatePagerAdapter 也是 PagerAdapter 的一个子类，同样用于管理 Fragment 页面。它适用于页面数量较多且需要节省内存的场景，因为它会在 Fragment 不可见时销毁其实例。以下是使用 FragmentStatePagerAdapter 的示例：

import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentStatePagerAdapter;
import java.util.ArrayList;
import java.util.List;

public class MyFragmentStatePagerAdapter extends FragmentStatePagerAdapter {

    private List<Fragment> fragmentList = new ArrayList<>();
    private List<String> titleList = new ArrayList<>();

    public MyFragmentStatePagerAdapter(FragmentManager fm) {
        super(fm);
    }

    public void addFragment(Fragment fragment, String title) {
        fragmentList.add(fragment);
        titleList.add(title);
    }

    @Override
    public Fragment getItem(int position) {
        // 根据位置返回对应的 Fragment 实例
        return fragmentList.get(position);
    }

    @Override
    public int getCount() {
        // 返回 Fragment 的数量
        return fragmentList.size();
    }

    @Override
    public CharSequence getPageTitle(int position) {
        // 返回每个页面的标题
        return titleList.get(position);
    }
}

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;
    private TabLayout tabLayout;

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

        viewPager = findViewById(R.id.viewPager);
        tabLayout = findViewById(R.id.tabLayout);

        MyFragmentStatePagerAdapter adapter = new MyFragmentStatePagerAdapter(getSupportFragmentManager());

        // 添加 Fragment 页面
        adapter.addFragment(new FirstFragment(), "First");
        adapter.addFragment(new SecondFragment(), "Second");
        adapter.addFragment(new ThirdFragment(), "Third");

        viewPager.setAdapter(adapter);
        tabLayout.setupWithViewPager(viewPager);
    }
}

MyFragmentStatePagerAdapter 的实现与 MyFragmentPagerAdapter 类似，只是继承自 FragmentStatePagerAdapter。在 MainActivity 中，使用 MyFragmentStatePagerAdapter 作为 ViewPager 的适配器，同样可以实现 Fragment 页面的切换和标签页的显示。

11.3 Fragment 生命周期管理

当 ViewPager 与 Fragment 结合使用时，需要注意 Fragment 的生命周期管理。FragmentPagerAdapter 和 FragmentStatePagerAdapter 对 Fragment 的生命周期管理有所不同：

• FragmentPagerAdapter ：它会保留所有已创建的 Fragment 实例，即使 Fragment 不可见也不会销毁。因此，当页面数量较少时，使用 FragmentPagerAdapter 可以提高页面切换的速度，但会占用较多的内存。
• FragmentStatePagerAdapter ：它会在 Fragment 不可见时销毁其实例，只保留 Fragment 的状态。当再次需要显示该 Fragment 时，会重新创建实例并恢复状态。因此，当页面数量较多时，使用 FragmentStatePagerAdapter 可以节省内存，但页面切换的速度可能会稍慢一些。

在实际开发中，需要根据具体的需求选择合适的适配器来管理 Fragment 的生命周期。

十二、ViewPager 的性能优化

12.1 减少视图创建和销毁

在使用 ViewPager 时，频繁地创建和销毁视图会影响性能。可以通过以下方法减少视图的创建和销毁：

• 使用视图复用 ：在适配器的 instantiateItem 和 destroyItem 方法中，尽量复用已有的视图，而不是每次都创建新的视图。例如，可以使用一个视图池来管理视图，当需要显示新的页面时，先从视图池中获取可用的视图，如果没有则创建新的视图；当页面不再需要显示时，将视图放回视图池中。

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.viewpager.widget.PagerAdapter;
import java.util.ArrayList;
import java.util.List;

public class MyPagerAdapter extends PagerAdapter {

    private List<String> data;
    private List<View> viewPool = new ArrayList<>();

    public MyPagerAdapter(List<String> data) {
        this.data = data;
    }

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

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

    @Override
    public Object instantiateItem(ViewGroup container, int position) {
        View view;
        if (viewPool.size() > 0) {
            // 从视图池中获取可用的视图
            view = viewPool.remove(0);
        } else {
            // 创建新的视图
            view = LayoutInflater.from(container.getContext()).inflate(R.layout.page_item, container, false);
        }
        // 更新视图内容
        TextView textView = view.findViewById(R.id.textView);
        textView.setText(data.get(position));
        container.addView(view);
        return view;
    }

    @Override
    public void destroyItem(ViewGroup container, int position, Object object) {
        View view = (View) object;
        container.removeView(view);
        // 将视图放回视图池中
        viewPool.add(view);
    }
}

• 调整预加载页面数量 ：ViewPager 有一个 setOffscreenPageLimit 方法，可以设置预加载的页面数量。默认情况下，预加载的页面数量为 1，即当前页面的左右各预加载一个页面。可以根据实际情况调整这个值，避免预加载过多的页面导致内存占用过高。

ViewPager viewPager = findViewById(R.id.viewPager);
// 设置预加载页面数量为 2
viewPager.setOffscreenPageLimit(2);

12.2 优化图片加载

如果 ViewPager 中包含图片，图片的加载和显示会对性能产生较大影响。可以使用图片加载库（如 Glide 或 Picasso）来优化图片的加载：

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;
import com.bumptech.glide.Glide;
import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private ViewPager viewPager;
    private List<String> imageUrls = new ArrayList<>();

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

        viewPager = findViewById(R.id.viewPager);

        // 添加图片 URL
        imageUrls.add("https://example.com/image1.jpg");
        imageUrls.add("https://example.com/image2.jpg");
        imageUrls.add("https://example.com/image3.jpg");

        MyPagerAdapter adapter = new MyPagerAdapter();
        viewPager.setAdapter(adapter);
    }

    private class MyPagerAdapter extends PagerAdapter {

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

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

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            View view = LayoutInflater.from(container.getContext()).inflate(R.layout.page_item, container, false);
            ImageView imageView = view.findViewById(R.id.imageView);
            // 使用 Glide 加载图片
            Glide.with(MainActivity.this)
                   .load(imageUrls.get(position))
                   .into(imageView);
            container.addView(view);
            return view;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            container.removeView((View) object);
        }
    }
}

在上述代码中，使用 Glide 库来加载图片。Glide 会自动处理图片的缓存、压缩和缩放等操作，提高图片的加载速度和性能。

12.3 避免不必要的绘制

在 ViewPager 的子视图中，避免进行不必要的绘制操作。可以通过以下方法来实现：

• 设置 setWillNotDraw ：如果子视图不需要进行绘制操作，可以调用 setWillNotDraw 方法将其标记为不进行绘制，从而减少绘制的开销。

// 在子视图的构造函数或初始化方法中调用
view.setWillNotDraw(true);

• 使用 invalidate 和 postInvalidate 精确控制刷新 ：在需要刷新视图时，尽量使用 invalidate 和 postInvalidate 方法精确控制刷新的区域，避免不必要的全局刷新。

// 只刷新指定区域
view.invalidate(left, top, right, bottom);

十三、ViewPager 的事件监听

13.1 OnPageChangeListener 接口

OnPageChangeListener 是 ViewPager 提供的一个接口，用于监听页面的滚动、选中和滚动状态改变事件。它包含以下三个方法：

import androidx.viewpager.widget.ViewPager;

public class MainActivity extends AppCompatActivity implements ViewPager.OnPageChangeListener {

    private ViewPager viewPager;

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

        viewPager = findViewById(R.id.viewPager);
        // 设置适配器
        MyPagerAdapter adapter = new MyPagerAdapter();
        viewPager.setAdapter(adapter);
        // 添加页面滚动监听器
        viewPager.addOnPageChangeListener(this);
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        // 页面滚动时的回调
        // position：当前可见页面的位置
        // positionOffset：当前页面滚动的偏移比例，范围是 0 到 1
        // positionOffsetPixels：当前页面滚动的偏移像素值
    }

    @Override
    public void onPageSelected(int position) {
        // 页面被选中时的回调
        // position：被选中页面的位置
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        // 页面滚动状态改变时的回调
        // state：滚动状态，有三种值：
        // ViewPager.SCROLL_STATE_IDLE：静止状态
        // ViewPager.SCROLL_STATE_DRAGGING：拖动状态
        // ViewPager.SCROLL_STATE_SETTLING：自动滚动状态
    }
}

在上述代码中，MainActivity 实现了 ViewPager.OnPageChangeListener 接口，并在 onCreate 方法中为 ViewPager 添加了该监听器。当页面滚动、选中或滚动状态改变时，相应的回调方法会被调用。

13.2 事件监听的应用场景

• 页面指示器更新 ：在 onPageSelected 方法中更新页面指示器的状态，如前面自定义页面指示器示例中所示。
• 标题栏更新 ：根据当前选中的页面更新标题栏的内容，如在 onPageSelected 方法中获取当前页面的标题并设置给标题栏。

@Override
public void onPageSelected(int position) {
    String title = getPageTitle(position);
    getSupportActionBar().setTitle(title);
}

• 数据加载 ：在 onPageSelected 方法中判断当前页面是否需要加载数据，如果需要则进行数据加载操作。

@Override
public void onPageSelected(int position) {
    if (position == 2) {
        // 加载第三个页面的数据
        loadDataForPage3();
    }
}

十四、ViewPager 的兼容性问题及解决方法

14.1 不同 Android 版本的兼容性

在不同的 Android 版本中，ViewPager 的行为和性能可能会有所不同。例如，在早期的 Android 版本中，ViewPager 的滚动效果可能不够流畅，而在较新的版本中，可能会有一些新的特性和优化。为了确保 ViewPager 在不同版本的 Android 系统上都能正常工作，可以采取以下措施：

• 使用支持库 ：使用 Android 支持库中的 ViewPager，它会对不同版本的 Android 系统进行兼容性处理，确保在各个版本上都能有较好的表现。

// 在 build.gradle 中添加支持库依赖
implementation 'androidx.viewpager:viewpager:1.0.0'

• 进行版本检查：在代码中进行 Android 版本检查，根据不同的版本采取不同的处理方式。例如，在较新的版本中使用一些新的特性，而在旧版本中使用兼容的实现。

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // 使用 Android 5.0 及以上版本的特性
} else {
    // 使用兼容的实现
}

14.2 与其他控件的兼容性

ViewPager 可能会与其他控件（如 RecyclerView、ListView 等）存在兼容性问题，例如滚动冲突。以下是一些常见的兼容性问题及解决方法：

• 滚动冲突 ：当 ViewPager 与 RecyclerView 或 ListView 嵌套使用时，可能会出现滚动冲突。可以通过重写 onInterceptTouchEvent 方法来解决滚动冲突。

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import androidx.viewpager.widget.ViewPager;

public class CustomViewPager extends ViewPager {

    private float startX;
    private float startY;

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

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

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                startX = ev.getX();
                startY = ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                float dx = Math.abs(ev.getX() - startX);
                float dy = Math.abs(ev.getY() - startY);
                if (dx > dy) {
                    // 水平滚动，拦截事件
                    return true;
                }
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
}

在上述代码中，自定义了一个 CustomViewPager，重写了 onInterceptTouchEvent 方法。在 ACTION_MOVE 事件中，判断手指的移动方向，如果是水平滚动，则拦截事件，让 ViewPager 处理滚动；如果是垂直滚动，则不拦截事件，让子控件处理滚动。

十五、总结与展望

15.1 总结

通过对 Android ViewPager 的深入分析，我们可以看到它是一个功能强大且灵活的控件，在 Android 应用开发中有着广泛的应用。以下是对 ViewPager 的主要特性和使用要点的总结：

• 核心功能：ViewPager 主要用于实现页面之间的滑动切换效果，用户可以通过左右滑动屏幕来浏览不同的页面。
• 适配器模式：通过适配器（PagerAdapter）来管理页面的创建和销毁，支持不同类型的适配器（如 FragmentPagerAdapter 和 FragmentStatePagerAdapter），可以方便地管理不同类型的页面（如 View 和 Fragment）。
• 布局与滚动：在布局测量和摆放过程中，ViewPager 会根据子视图的大小和位置进行合理的布局，并通过 Scroller 类实现平滑的滚动效果。
• 事件处理 ：通过重写 onTouchEvent 方法处理用户的触摸事件，支持手势检测和滚动边界处理，确保滚动的流畅性和准确性。
• 动画与指示器：支持通过设置 PageTransformer 来实现自定义的页面切换动画，同时可以与页面指示器（如 CircleIndicator 和 TabLayout）配合使用，增强用户体验。
• 性能优化：可以通过减少视图创建和销毁、优化图片加载和避免不必要的绘制等方法来提高 ViewPager 的性能。
• 兼容性 ：使用 Android 支持库中的 ViewPager 可以确保在不同版本的 Android 系统上都能正常工作，同时可以通过重写 onInterceptTouchEvent 方法解决与其他控件的滚动冲突问题。

15.2 展望

随着 Android 技术的不断发展，ViewPager 也有望在以下方面得到进一步的改进和完善：

• 性能提升：未来的 Android 系统可能会对 ViewPager 的性能进行进一步优化，例如采用更高效的视图复用机制和滚动算法，减少内存占用和滚动卡顿现象。
• 功能扩展：可能会增加更多的功能和特性，如支持更多类型的滚动效果（如垂直滚动、循环滚动等）、更丰富的页面切换动画和交互效果等。
• 与新技术的融合：随着 Android 开发中新技术的不断涌现，如 Jetpack Compose，ViewPager 可能会与这些新技术进行更好的融合，提供更简洁、高效的开发方式。
• 无障碍支持：进一步优化 ViewPager 的无障碍功能，为视障用户等特殊群体提供更好的使用体验。

总之，ViewPager 在 Android 应用开发中仍然具有重要的地位，开发者可以根据具体的需求和场景，合理选择和使用 ViewPager，并结合其他控件和技术，打造出更加优秀的 Android 应用。同时，我们也期待 Android 系统能够不断对 ViewPager 进行优化和改进，为开发者提供更好的开发体验。