Jetpack Compose version: 1.1.1 Jetpack Compose component used: LazyColumn Android Studio Build: Kotlin version: 1.6.10

@Composable
fun NestScrollDemo() {
    val headerHeight = 200.dp
    val headerHeightPx = with(LocalDensity.current){
        headerHeight.toPx()
    }
    val offset = remember {
        mutableStateOf(0f)
    }

    val offsetDp = with(LocalDensity.current){
        offset.value.toDp()
    }


    val nestScrollConnection = remember {
        object: NestedScrollConnection {
            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
                if(source == NestedScrollSource.Fling){
                    return Offset.Zero
                }
                val currentOffset = offset.value
                if(available.y < 0 && currentOffset > 0){
                    val consume = available.y.coerceAtLeast(-currentOffset)
                    offset.value = currentOffset + consume
                    return Offset(0f, consume)
                }
                return Offset.Zero
            }

            override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource): Offset {
                if(source == NestedScrollSource.Fling){
                    return Offset.Zero
                }
                if (available.y > 0) {
                    offset.value = (offset.value + available.y).coerceAtMost(headerHeightPx)
                    return Offset(0f, available.y)
                }
                return Offset.Zero
            }

            override suspend fun onPreFling(available: Velocity): Velocity {
                // the velocity here may be wraong.
                Log.i("NestScrollDemo", "the available velocity is $available")
                return Velocity.Zero
            }
        }
    }

    Box(
        modifier = Modifier
            .fillMaxSize()
            .nestedScroll(nestScrollConnection)
    ) {
        Box(
            modifier = Modifier
                .fillMaxWidth()
                .height(headerHeight)
                .background(Color.Gray)
        )
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .offset(y = offsetDp)
                .background(Color.White)
        ) {
            items(50) {
                Text(text = "item", modifier = Modifier.padding(20.dp))
            }
        }
    }
}

When I use nestedScroll in this case, If the list can not scrll up, I expect to move LazyColumn self. So I use nestedScroll and offset. But I found that the velocity is negative sometimes when I scrolled up that should be positive.

I think it's because of offset change the LazyColumn's layout coordinates, but VelocityTracker does't know this, so touch position's coordinates collected by VelocityTracker are not same. This make the wrong velocity calculation.