Import apps/android/src/screens/chat/use-chat-scroll.ts

This commit is contained in:
QQ 2026-11-14 14:15:17 +08:00
parent d1f1433834
commit 4d95deb3e0
1 changed files with 352 additions and 0 deletions

View File

@ -0,0 +1,352 @@
import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
import { FlatList, Keyboard, type LayoutChangeEvent, type NativeScrollEvent, type NativeSyntheticEvent } from 'react-native'
import { updateBrowseEntry, useBrowseMemory } from '../../services/browse-memory'
import { computeStreamingSignature, LATEST_EDGE_PX, type ChatSection } from '../../state/message-helpers'
import type { ChatItem, RemoteSession } from '../../types'
type Options = {
session: RemoteSession | undefined
messages: ChatItem[]
visibleMessages: ChatItem[]
visibleSections: readonly ChatSection[]
memoryScope: string
memoryKey: string
panelOpen: boolean
historyLoadingOlder: boolean
busy: string | undefined
setTrajectory: (value: boolean) => void
}
export function useChatScroll({ session, messages, visibleMessages, visibleSections, memoryScope, memoryKey, panelOpen, historyLoadingOlder, busy, setTrajectory }: Options) {
const sessionId = session?.sessionId
const listRef = useRef<FlatList<ChatSection>>(null)
const lastAutoScrollAt = useRef(0)
const scrollTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
const scrollFrameRef = useRef<number | null>(null)
const listViewportRef = useRef({ width: 0, height: 0 })
const listContentRef = useRef({ width: 0, height: 0 })
const userScrollingRef = useRef(false)
const hasTrailingScrollRef = useRef(false)
const pendingScrollStreakRef = useRef(0)
const scrollIntentGenerationRef = useRef(0)
/** Keep the viewport on the latest turn until the user scrolls away. */
const pinToBottomRef = useRef(true)
/** Re-pin while the first session layout (markdown / images) is still settling. */
const initialPinRef = useRef(true)
const [newContent, setNewContent] = useState(false)
const visibleAnchor = useRef<string | undefined>(undefined)
const laidOutSessionRef = useRef<string | undefined>(undefined)
const restoringPosition = useRef(false)
const savedPosition = useRef(useBrowseMemory.getState().entries[memoryKey]?.position)
const lastPositionSave = useRef(0)
const lastContentVersion = useMemo(() => visibleMessageVersion(messages), [messages])
const contentBefore = useRef<{ key: string; version?: string }>({ key: memoryKey })
const viewability = useRef(({ viewableItems }: { viewableItems: Array<{ key: string }> }) => {
visibleAnchor.current = viewableItems[0]?.key
}).current
/** Last reported scroll offset; content and viewport changes re-check the latest turn from it. */
const listOffsetRef = useRef(0)
/** Mirrors the floating jump button so scroll events only re-render on a crossing. */
const awayFromLatestRef = useRef(false)
const [awayFromLatest, setAwayFromLatest] = useState(false)
const autoScrollAllowedRef = useRef(false)
autoScrollAllowedRef.current = !panelOpen && !historyLoadingOlder && sessionId !== undefined && visibleMessages.length > 0
const cancelPendingScroll = useCallback(() => {
hasTrailingScrollRef.current = false
pendingScrollStreakRef.current = 0
if (scrollTimerRef.current !== null) clearTimeout(scrollTimerRef.current)
if (scrollFrameRef.current !== null) cancelAnimationFrame(scrollFrameRef.current)
scrollTimerRef.current = null
scrollFrameRef.current = null
}, [])
// Follow measured content and viewport changes (including the keyboard).
// Keep a trailing command so the last streaming measurement is never lost,
// while coalescing high-frequency deltas (~30 Hz) with no React state updates.
const scheduleScrollToBottom = useCallback(() => {
if (!pinToBottomRef.current && !initialPinRef.current) return
if (userScrollingRef.current) return
if (scrollTimerRef.current !== null || scrollFrameRef.current !== null) {
hasTrailingScrollRef.current = true
return
}
const runScroll = () => {
scrollFrameRef.current = requestAnimationFrame(() => {
scrollFrameRef.current = null
if (!autoScrollAllowedRef.current || userScrollingRef.current
|| (!pinToBottomRef.current && !initialPinRef.current)) {
hasTrailingScrollRef.current = false
pendingScrollStreakRef.current = 0
return
}
lastAutoScrollAt.current = Date.now()
// Nonanimated commands also keep native momentum callbacks reserved
// for user flings, so they cannot disable following during a reply.
listRef.current?.scrollToEnd({ animated: false })
if (hasTrailingScrollRef.current && pendingScrollStreakRef.current < 2) {
hasTrailingScrollRef.current = false
pendingScrollStreakRef.current += 1
scheduleScrollToBottom()
} else {
hasTrailingScrollRef.current = false
pendingScrollStreakRef.current = 0
}
})
}
const elapsed = Date.now() - lastAutoScrollAt.current
const delay = Math.max(0, 33 - elapsed)
if (delay === 0) {
runScroll()
} else {
scrollTimerRef.current = setTimeout(() => {
scrollTimerRef.current = null
runScroll()
}, delay)
}
}, [])
// Following the latest turn is suspended once the user scrolls away, so the
// floating button is the only way back without a manual fling. It follows
// measured metrics rather than a gesture, so an older history page loading
// above, a window resize or a running reply also re-check it.
const syncLatestTurnIndicator = useCallback((distanceFromEnd: number) => {
const away = !pinToBottomRef.current && !initialPinRef.current && distanceFromEnd > LATEST_EDGE_PX
if (awayFromLatestRef.current === away) return
awayFromLatestRef.current = away
setAwayFromLatest(away)
}, [])
// Re-enable follow mode before jumping, so a reply that streams in right
// after the tap keeps appending at the end. The queued follow pass also
// re-asserts the end once the rows below finish re-measuring, which a single
// scroll command cannot guarantee on a virtualized list.
const jumpToLatest = useCallback(() => {
scrollIntentGenerationRef.current++
cancelPendingScroll()
userScrollingRef.current = false
pinToBottomRef.current = true
initialPinRef.current = true
awayFromLatestRef.current = false
setAwayFromLatest(false)
setNewContent(false)
restoringPosition.current = false
if (session !== undefined) {
updateBrowseEntry(memoryScope, session.sessionId, {
position: { offset: 0, atBottom: true }, seenAt: session.updatedAt,
})
}
listRef.current?.scrollToEnd({ animated: false })
scheduleScrollToBottom()
}, [cancelPendingScroll, scheduleScrollToBottom, memoryScope, session?.sessionId, session?.updatedAt])
// Restore reading position before the new list can emit scroll events.
useLayoutEffect(() => {
scrollIntentGenerationRef.current++
cancelPendingScroll()
setTrajectory(false)
savedPosition.current = useBrowseMemory.getState().entries[memoryKey]?.position
const bottom = savedPosition.current?.atBottom !== false
pinToBottomRef.current = bottom
initialPinRef.current = bottom
restoringPosition.current = !bottom
setNewContent(false)
laidOutSessionRef.current = undefined
userScrollingRef.current = false
listViewportRef.current = { width: 0, height: 0 }
listContentRef.current = { width: 0, height: 0 }
listOffsetRef.current = 0
awayFromLatestRef.current = !bottom
setAwayFromLatest(!bottom)
}, [memoryKey, cancelPendingScroll])
useEffect(() => cancelPendingScroll, [cancelPendingScroll])
// A sheet or picker owns the user's next touch. Cancel a queued list jump
// as soon as it opens so a streaming update cannot move the responder under
// the panel.
useEffect(() => {
if (panelOpen) cancelPendingScroll()
}, [panelOpen, cancelPendingScroll])
// Let the first layout frame finish before jumping to the end. This keeps
// the top bar and Android back dispatch responsive while a large history
// page is being mounted, without relying on the deprecated InteractionManager.
useEffect(() => {
if (panelOpen || visibleMessages.length === 0 || historyLoadingOlder || sessionId === undefined) return
if (!pinToBottomRef.current && !initialPinRef.current) return
const timer = setTimeout(() => {
if (pinToBottomRef.current || initialPinRef.current) scheduleScrollToBottom()
}, 32)
return () => clearTimeout(timer)
}, [historyLoadingOlder, panelOpen, scheduleScrollToBottom, sessionId, visibleMessages.length])
// Loading older history prepends above the viewport — do not yank to the end.
useEffect(() => {
if (!historyLoadingOlder) return
pinToBottomRef.current = false
initialPinRef.current = false
}, [historyLoadingOlder])
// Streaming deltas keep the same item id, but update text length / reasoning.
// Compute a cheap signature of the last item so streaming increments trigger auto-scroll.
const streamingSignature = useMemo(() => computeStreamingSignature(visibleMessages), [visibleMessages])
// Scroll when a brand-new item is appended or the last message receives streaming tokens.
useEffect(() => {
if (panelOpen || visibleMessages.length === 0 || historyLoadingOlder || sessionId === undefined) return
if (!pinToBottomRef.current && !initialPinRef.current) return
scheduleScrollToBottom()
}, [streamingSignature, visibleMessages.length, historyLoadingOlder, panelOpen, scheduleScrollToBottom, sessionId])
const onListLayout = useCallback((event: LayoutChangeEvent) => {
const { width, height } = event.nativeEvent.layout
const previous = listViewportRef.current
if (previous.width === width && previous.height === height) return
listViewportRef.current = { width, height }
// The viewport can change while the content stays put (keyboard, rotation,
// tablet split), which is exactly when the newest turn may leave the screen.
syncLatestTurnIndicator(listContentRef.current.height - height - listOffsetRef.current)
if (!autoScrollAllowedRef.current || (!pinToBottomRef.current && !initialPinRef.current)) return
scheduleScrollToBottom()
}, [scheduleScrollToBottom, syncLatestTurnIndicator])
const onListContentSizeChange = useCallback((width: number, height: number) => {
const previous = listContentRef.current
if (previous.width === width && previous.height === height) return
listContentRef.current = { width, height }
syncLatestTurnIndicator(height - listViewportRef.current.height - listOffsetRef.current)
if (!autoScrollAllowedRef.current || (!pinToBottomRef.current && !initialPinRef.current)) return
scheduleScrollToBottom()
}, [scheduleScrollToBottom, syncLatestTurnIndicator])
const restoreReadingPosition = useCallback(() => {
// A session switch can render the list before its viewport and markdown
// rows have measured. Defer one extra frame so the initial jump reaches
// the actual end rather than the pre-layout content height.
if (panelOpen || visibleMessages.length === 0 || historyLoadingOlder || sessionId === undefined) return
if (laidOutSessionRef.current === sessionId) return
const position = savedPosition.current
const anchorIndex = visibleSections.findIndex(item => item.key === position?.key)
if (position?.atBottom === false && anchorIndex < 0 && busy?.startsWith('session:')) return
laidOutSessionRef.current = sessionId
if (position?.atBottom === false) {
requestAnimationFrame(() => {
if (anchorIndex >= 0) listRef.current?.scrollToIndex({ index: anchorIndex, animated: false, viewPosition: 0 })
else listRef.current?.scrollToOffset({ offset: position.key === undefined ? position.offset : 0, animated: false })
restoringPosition.current = false
})
} else scheduleScrollToBottom()
}, [historyLoadingOlder, panelOpen, scheduleScrollToBottom, sessionId, visibleMessages.length, visibleSections, busy])
useEffect(() => { restoreReadingPosition() }, [restoreReadingPosition])
const onListScroll = useCallback((event: NativeSyntheticEvent<NativeScrollEvent>) => {
const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent
listOffsetRef.current = contentOffset.y
const distanceFromEnd = contentSize.height - layoutMeasurement.height - contentOffset.y
// Content growth and IME resizing can also emit scroll events. Only a
// user's drag/fling changes the intent to follow the latest response.
if (restoringPosition.current) {
syncLatestTurnIndicator(distanceFromEnd)
return
}
const atBottom = distanceFromEnd <= LATEST_EDGE_PX
if (userScrollingRef.current) {
if (distanceFromEnd > LATEST_EDGE_PX) {
pinToBottomRef.current = false
initialPinRef.current = false
} else {
pinToBottomRef.current = true
}
} else if (atBottom) {
pinToBottomRef.current = true
initialPinRef.current = false
}
syncLatestTurnIndicator(distanceFromEnd)
if (atBottom) setNewContent(false)
if (session !== undefined && (Date.now() - lastPositionSave.current > 200 || atBottom)) {
lastPositionSave.current = Date.now()
updateBrowseEntry(memoryScope, session.sessionId, {
position: { key: visibleAnchor.current, offset: contentOffset.y, atBottom },
...(atBottom ? { seenAt: session.updatedAt } : {})
})
}
}, [memoryScope, session?.sessionId, session?.updatedAt, syncLatestTurnIndicator])
useEffect(() => {
if (contentBefore.current.key === memoryKey && contentBefore.current.version !== undefined
&& contentBefore.current.version !== lastContentVersion && !pinToBottomRef.current) setNewContent(true)
contentBefore.current = { key: memoryKey, version: lastContentVersion }
}, [lastContentVersion, memoryKey])
const finishListScroll = useCallback((event: NativeSyntheticEvent<NativeScrollEvent>) => {
userScrollingRef.current = false
const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent
const distanceFromEnd = contentSize.height - layoutMeasurement.height - contentOffset.y
if (distanceFromEnd <= LATEST_EDGE_PX) {
pinToBottomRef.current = true
initialPinRef.current = false
scheduleScrollToBottom()
}
}, [onListScroll, scheduleScrollToBottom])
const onListDragEnd = useCallback((event: NativeSyntheticEvent<NativeScrollEvent>) => {
onListScroll(event)
const velocityY = Math.abs(event.nativeEvent.velocity?.y ?? 0)
if (velocityY <= 0.05) {
finishListScroll(event)
}
}, [onListScroll, finishListScroll])
const onListMomentumEnd = useCallback((event: NativeSyntheticEvent<NativeScrollEvent>) => {
onListScroll(event)
finishListScroll(event)
}, [onListScroll, finishListScroll])
const beginSendScroll = () => {
const generation = ++scrollIntentGenerationRef.current
const previousPin = pinToBottomRef.current
const previousInitialPin = initialPinRef.current
const previousAway = awayFromLatestRef.current
pinToBottomRef.current = true
initialPinRef.current = true
pendingScrollStreakRef.current = 0
awayFromLatestRef.current = false
setAwayFromLatest(false)
setNewContent(false)
scheduleScrollToBottom()
return () => {
if (scrollIntentGenerationRef.current !== generation) return
cancelPendingScroll()
pinToBottomRef.current = previousPin
initialPinRef.current = previousInitialPin
awayFromLatestRef.current = previousAway
setAwayFromLatest(previousAway)
if (previousPin || previousInitialPin) scheduleScrollToBottom()
}
}
const onScrollBeginDrag = () => {
scrollIntentGenerationRef.current++
cancelPendingScroll()
userScrollingRef.current = true
Keyboard.dismiss()
}
const onMomentumScrollBegin = () => {
cancelPendingScroll()
userScrollingRef.current = true
}
return {
listRef, viewability, awayFromLatest, newContent, jumpToLatest, beginSendScroll,
onListLayout, onListContentSizeChange, onListScroll, onListDragEnd, onListMomentumEnd,
onScrollBeginDrag, onMomentumScrollBegin
}
}
function visibleMessageVersion(items: ChatItem[]): string {
const last = items[items.length - 1]
return last === undefined ? '' : JSON.stringify(last)
}