Android ViewPager问题：onPageSelected循环调用及Tab适配异常

问题背景 #

使用TabLayout搭配ViewPager实现页面切换，未采用Fragment，而是通过自定义FlowViewPagerAdapter使用自定义Page。目前遇到三个核心问题：

• 极速连续点击Tab导致页面循环切换：应用启动前2-3秒内，用户快速点击所有Tab后，onPageSelected会在索引0和2之间循环触发，页面来回跳转无法停止。已通过onInterceptTouchEvent禁用Tab点击期间的交互，但问题依旧。
• instantiateItem()偶尔不调用：切换屏幕时该方法有时不执行，导致Page布局未初始化，需要确保每次切换都能触发它完成View变量初始化。
• Tab指示器动画速度不匹配：使用delayedScreenSelection延迟切换后，Tab指示器直接跳转无平滑动画；尝试自定义ViewPager的Scroller仅修改了页面滑动速度，指示器速度仍过快；移除延迟后，前两个页面切换完全无动画，视觉效果差。

核心代码片段 #

主页面核心逻辑

protected fun createCustomTabScreenFlow(){
        mainPagerAdapter = FlowViewPagerAdapter(mainFlowList)
        mainViewPager.adapter = mainPagerAdapter
        mainViewPager.offscreenPageLimit = mainFlowList.size

        mainViewPager.addOnPageChangeListener(object: ViewPager.OnPageChangeListener{
            override fun onPageScrollStateChanged(state: Int) {}
            override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {}
            override fun onPageSelected(position: Int) {
                backButtonStatus(isEnabled = true)
                App.log("AppNavigationFlow: MainTabActivity: -------")
                val page  = mainFlowList[position]
                App.log("AppNavigationFlow: MainTabActivity: onPageSelected: new: ${page::class.java} current: ${mainCurrentPage?.let { it::class.java }?:"null"}")
                App.log("AppNavigationFlow: MainTabActivity: setTabsEnabled: onPageSelected")
                setTabsEnabled(false)
                if (hasVisibleTabs){
                    if (page != mainCurrentPage){
                        //switch automatically
                        App.log("AppNavigationFlow: MainTabActivity: onPageSelected: switch to page: ${page::class.java}")
                        mainCurrentPage?.onScreenRemoved()
                        mainCurrentPage?.setScreenVisibleState(false)
                        switchScreen(page::class.java)
                    } else {
                        App.log("AppNavigationFlow: MainTabActivity: onPageSelected: switch to page: same page")
                        App.log("AppNavigationFlow: MainTabActivity: setTabsEnabled: onPageSelected - error")
                        setTabsEnabled(tabsInitialized)
                    }
                }
            }
        })

        mainTabLayout.setupWithViewPager(mainViewPager)
        (0..mainTabLayout.tabCount).forEach { tab->
            mainFlowList.getOrNull(tab)?.icon?.let {
                mainTabLayout.getTabAt(tab)?.let { tabItem->
                    val tabItemView = CustomResources.inflateLayout(layoutInflater, R.layout.custom_tab_item, null, false) as ViewGroup
                    tabItemView.findViewById<ImageView>(R.id.icon).setImageResource(it)
                    tabItem.customView = tabItemView
                    tabItem.customView?.requestLayout()
                }
            }
        }

        onPagerIntialized()
    }

    private var tabsInitialized = false
    open fun onPagerIntialized(){
        App.log("AppNavigationFlow: MainTabActivity: setTabsEnabled: onPagerInitialized")
        tabsInitialized = true
        setTabsEnabled(true)
    }


private var isInSwitchingProcess = false
fun switchScreen(
    screen: Class<out FlowScreen>,
    payload: List<ScreenPayload>? = null,
    action: (() -> Unit)? = null,
    useAnim: Boolean = true,
){
    try {
        val index = mainFlowList.indexOfFirst { item -> item::class.java == screen }
        if (index >= 0){
            delayedScreenSelection {
                if (!isInSwitchingProcess && tabsInitialized){
                    isInSwitchingProcess = true
                    mainTabLayout.getTabAt(index)?.select()
                    mainViewPager.setCurrentItem(index, useAnim)
                    mainPagerAdapter.getPageAtPos(index)?.apply {
                        mainCurrentPage = this
                        mainCurrentPage?.apply {
                            setScreenVisibleState(true)
                            clearPayload()
                            clearAction()
                        }
                        payload?.let { mainCurrentPage?.sendPayload(payload) }
                        action?.let { mainCurrentPage?.setAction(action) }
                        onScreenSwitched()
                        isInSwitchingProcess = false
                    }?:kotlin.run {
                        isInSwitchingProcess = false
                        setTabsEnabled(tabsInitialized)
                    }
                }
            }
        } else {
            setTabsEnabled(tabsInitialized)
        }
    }catch (e: IndexOutOfBoundsException){
        setTabsEnabled(tabsInitialized)
    }
}

FlowViewPagerAdapter代码

class FlowViewPagerAdapter(private var pageList: List<FlowScreen>): PagerAdapter() {

    override fun isViewFromObject(view: View, `object`: Any): Boolean {
        return view == `object`
    }

    override fun getCount(): Int {
        return pageList.size
    }

    override fun destroyItem(container: ViewGroup, position: Int, `object`: Any) {
        container.removeView(`object` as View)
    }

    override fun instantiateItem(container: ViewGroup, position: Int): View {
        val page = pageList[position]
        val layout = page.getScreen(container)
        container.addView(layout)
        return layout
    }

    var mCurrentView: View? = null
    override fun setPrimaryItem(container: ViewGroup, position: Int, `object`: Any) {
        mCurrentView = `object` as View
        val pager = container as? CustomizableViewPager
        mCurrentView?.let { v->
            pager?.measureCurrentView(v)
        }
    }

    fun getPageAtPos(pos: Int): FlowScreen?{
        return pageList.getOrNull(pos)
    }

    override fun getPageTitle(position: Int): CharSequence? {
        return getPageAtPos(position)?.name
    }
}

自定义Scroller代码

init {
        try {
            val mScroller = ViewPager::class.java.getDeclaredField("mScroller")
            mScroller.isAccessible = true
            val scroller = FixedSpeedScroller(this.context)
            mScroller.set(this, scroller)
        } catch (_: NoSuchFieldException) {
        } catch (_: IllegalArgumentException) {
        } catch (_: IllegalAccessException) {
        }
    }

解决方案 #

1. 解决页面循环切换问题 #

循环切换的根源是**onPageSelected中调用switchScreen，而switchScreen又触发setCurrentItem，进而再次触发onPageSelected形成闭环**，加上延迟任务堆积，导致状态混乱。

修复步骤：

• 移除onPageSelected中的switchScreen调用，setupWithViewPager已自动关联Tab和ViewPager的选中状态，无需手动切换。
• 将页面切换后的逻辑（如onScreenRemoved、setScreenVisibleState）移到onPageScrollStateChanged中，仅在页面切换完成（状态为SCROLL_STATE_IDLE）时执行：

override fun onPageScrollStateChanged(state: Int) {
    if (state == ViewPager.SCROLL_STATE_IDLE) {
        val currentPos = mainViewPager.currentItem
        val page = mainFlowList[currentPos]
        if (page != mainCurrentPage) {
            mainCurrentPage?.onScreenRemoved()
            mainCurrentPage?.setScreenVisibleState(false)
            mainCurrentPage = page
            mainCurrentPage?.setScreenVisibleState(true)
            onScreenSwitched()
        }
        setTabsEnabled(tabsInitialized)
    } else {
        setTabsEnabled(false) // 切换过程中禁用Tab
    }
}

• 删除switchScreen中的mainTabLayout.getTabAt(index)?.select()，setCurrentItem会自动同步Tab选中状态，手动调用会造成冲突。

2. 确保instantiateItem()每次切换都调用 #

instantiateItem不调用的原因是ViewPager预加载机制和状态同步问题，修复方案：

• 不要设置offscreenPageLimit为列表总长度，改为合理值（如1），避免一次性加载过多页面导致初始化异常。
• 重写PagerAdapter的getItemPosition方法，返回POSITION_NONE，强制ViewPager在状态变化时重新初始化页面：

override fun getItemPosition(`object`: Any): Int {
    return POSITION_NONE
}

• 需要刷新页面时，调用mainPagerAdapter.notifyDataSetChanged()触发instantiateItem重新执行。

3. 调整Tab指示器动画速度 #

TabLayout指示器动画由内部SlidingTabIndicator控制，可通过以下两种方式调整：

方法1：反射修改指示器动画时长

fun setTabIndicatorAnimationDuration(tabLayout: TabLayout, duration: Long) {
    try {
        val slidingTabIndicatorField = TabLayout::class.java.getDeclaredField("mTabStrip")
        slidingTabIndicatorField.isAccessible = true
        val tabStrip = slidingTabIndicatorField.get(tabLayout) as ViewGroup
        val scrollerField = tabStrip::class.java.getDeclaredField("mScroller")
        scrollerField.isAccessible = true
        val scroller = object : Scroller(tabLayout.context) {
            override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int, duration: Int) {
                super.startScroll(startX, startY, dx, dy, duration.toInt())
            }
        }
        scrollerField.set(tabStrip, scroller)
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

在onPagerIntialized中调用：setTabIndicatorAnimationDuration(mainTabLayout, 500)（500ms为动画时长，可按需调整）

方法2：移除delayedScreenSelection延迟

延迟会打断TabLayout和ViewPager的同步动画，移除后确保switchScreen仅调用mainViewPager.setCurrentItem(index, useAnim)，让两者动画自然同步：

fun switchScreen(
    screen: Class<out FlowScreen>,
    payload: List<ScreenPayload>? = null,
    action: (() -> Unit)? = null,
    useAnim: Boolean = true,
){
    try {
        val index = mainFlowList.indexOfFirst { item -> item::class.java == screen }
        if (index >= 0 && !isInSwitchingProcess && tabsInitialized){
            isInSwitchingProcess = true
            mainViewPager.setCurrentItem(index, useAnim)
            // 页面切换完成逻辑移至onPageScrollStateChanged处理
        }
    }catch (e: IndexOutOfBoundsException){
        setTabsEnabled(tabsInitialized)
    }
}

内容的提问来源于stack exchange，提问作者Martin