Description:

The request is to change visibility modifier of androidx.compose.foundation.pager.PagerState.snapToItem and .pageAvailableSpace to public as it makes synchronizing multiple PagerStates much easier and/or setting scroll state in fast-paced non-coroutine scope.

Use Case:

Consider the following example:

@Composable
fun MyScreen() = Column {
    val stateA = rememberPagerState { … }
    val stateB = rememberPagerState { … }
    HorizontalPager(state = stateA, userScrollEnabled = false) { … }
    HorizontalPager(state = stateB) { … }
}

where the stateA and stateB are to be synchronized in the terms of currentPage and currentPageOffsetFraction.

This is not an easy task as launching many LaunchedEffects is not efficient and introduces extreme lag, dropping to almost 10fps on the most performant hardware.

Therefore a subclass of PagerState is required:

class MultiChildPagerState(
    initialPage: Int,
    initialPageOffsetFraction: Float,
    updatedPageCount: () -> Int,
    private vararg val children: PagerState
) : PagerState(initialPage, initialPageOffsetFraction) {

    var pageCountState = mutableStateOf(updatedPageCount)
    override val pageCount: Int get() = pageCountState.value.invoke()

    override suspend fun scroll(
        scrollPriority: MutatePriority,
        block: suspend ScrollScope.() -> Unit
    ) {
        super.scroll(scrollPriority) {
            val scope = ScrollScope { pixels ->
                scrollBy(pixels).also { _ ->
                    for (child in children)
                        child.snapToItem(currentPage, currentPageOffsetFraction)
                }
            }
            scope.block()
        }
    }

    override fun dispatchRawDelta(delta: Float): Float {
        return super.dispatchRawDelta(delta).also {
            for (child in children)
                child.dispatchRawDelta(delta)
        }
    }

    private fun ScrollScope(scrollBy: (Float) -> Float) = object : ScrollScope {
        override fun scrollBy(pixels: Float): Float {
            return scrollBy(pixels)
        }
    }

    // <-- NOTE THE REFLECTION ACCESS HERE
    private fun PagerState.snapToItem(page: Int, offset: Float) {
        val actualOffset = offset * pageAvailableSpace.invoke(this) as Int
        snapToItem.invoke(this, page, actualOffset.toInt())
    }

    companion object {

        private val pagerState = PagerState::class.java
        private val pageAvailableSpace = pagerState.getDeclaredMethod("getPageAvailableSpace")
        private val snapToItem = pagerState.getDeclaredMethod(
            "snapToItem\$foundation_release",
            Int::class.java,
            Int::class.java
        )

        init {
            pageAvailableSpace.isAccessible = true
            snapToItem.isAccessible = true
        }
    }

}

Where piggy-backing on the scroll method produces the wanted result in a way that's very performant. These changes are sufficient to have a clear, flexible public API for this task, however…

If it would be possible to create a PagerState-embedded subroutine which scrolls attached states automatically without the need for PagerState subclass, that would be also cool. I can image the API looking similar to this:

@Composable
fun MyComposable() {
    val stateA = rememberPagerState { … }
    val stateB = rememberPagerState { … }
    SideEffect {
        stateB.addPagerChild(stateA)
    }
}

Moreover I find synchronizing generic ScrollableState (or Lazy*-owned) with the Pager could lead to easier Pager Indicator integration if it were implemented.