feat(chat): add scroll speed limit for streaming output and top positioning for non-streaming output (#1116)

app/src/main/java/com/ai/assistance/operit/data/preferences/DisplayPreferencesManager.kt

@@ -73,6 +73,39 @@ class DisplayPreferencesManager private constructor(private val context: Context
 
         // 工具折叠设置（多个只读工具 / 多个任意工具 / 全部工具）
         private val KEY_TOOL_COLLAPSE_MODE = stringPreferencesKey("tool_collapse_mode")
+        // 滚动行为相关设置的 Key
+        private val KEY_STREAM_SCROLL_MAX_SPEED_DP =
+            intPreferencesKey("stream_scroll_max_speed_dp")
+        private val KEY_ENABLE_NON_STREAMING_SCROLL_TO_TOP =
+            booleanPreferencesKey("enable_non_streaming_scroll_to_top")
+
+        /** 流式输出滚动速度上限的起步档（dp/s） */
+        const val STREAM_SCROLL_SPEED_MIN_DP = 50
+
+        /** 流式输出滚动速度上限的档位步进（dp/s） */
+        const val STREAM_SCROLL_SPEED_STEP_DP = 50
+
+        /**
+         * 流式输出滚动速度上限的最高有效限速档（dp/s）。
+         * 即倒数第二档；再往上一档为 [STREAM_SCROLL_SPEED_UNLIMITED]。
+         */
+        const val STREAM_SCROLL_SPEED_MAX_LIMITED_DP = 1000
+
+        /**
+         * 最后一档：不设上限。
+         * 此时滚动速度完全跟随模型吞吐量，模型输出多快屏幕就滚多快。
+         */
+        const val STREAM_SCROLL_SPEED_UNLIMITED = Int.MAX_VALUE
+
+        /** 流式输出滚动速度上限的默认值（dp/s），默认即启用限速 */
+        const val STREAM_SCROLL_SPEED_DEFAULT_DP = 600
+
+        /**
+         * 全部可选档位：50..1000（步进 50，共 20 档）+ 不限速（第 21 档）。
+         */
+        val STREAM_SCROLL_SPEED_OPTIONS: List<Int> =
+            (STREAM_SCROLL_SPEED_MIN_DP..STREAM_SCROLL_SPEED_MAX_LIMITED_DP step STREAM_SCROLL_SPEED_STEP_DP)
+                .toList() + STREAM_SCROLL_SPEED_UNLIMITED
     }
 
     /**
@@ -204,6 +237,25 @@ class DisplayPreferencesManager private constructor(private val context: Context
             ToolCollapseMode.fromValue(preferences[KEY_TOOL_COLLAPSE_MODE])
         }
 
+    /**
+     * 流式输出时页面自动滚动的速度上限（dp/s）。
+     * 取 [STREAM_SCROLL_SPEED_UNLIMITED] 时表示最后一档“不设上限”，滚动速度跟随模型吞吐量。
+     * 默认值：[STREAM_SCROLL_SPEED_DEFAULT_DP]
+     */
+    val streamScrollMaxSpeedDp: Flow<Int> =
+        context.displayPreferencesDataStore.data.map { preferences ->
+            preferences[KEY_STREAM_SCROLL_MAX_SPEED_DP] ?: STREAM_SCROLL_SPEED_DEFAULT_DP
+        }
+
+    /**
+     * 是否在非流式输出时将页面定位到消息开头
+     * 默认值：true
+     */
+    val enableNonStreamingScrollToTop: Flow<Boolean> =
+        context.displayPreferencesDataStore.data.map { preferences ->
+            preferences[KEY_ENABLE_NON_STREAMING_SCROLL_TO_TOP] ?: true
+        }
+
     /**
      * 保存显示设置
      */
@@ -226,7 +278,9 @@ class DisplayPreferencesManager private constructor(private val context: Context
         visitWebWaitSeconds: Int? = null,
         toolPkgHookTimeoutSeconds: Int? = null,
         virtualDisplayBitrateKbps: Int? = null,
-        toolCollapseMode: ToolCollapseMode? = null
+        toolCollapseMode: ToolCollapseMode? = null,
+        streamScrollMaxSpeedDp: Int? = null,
+        enableNonStreamingScrollToTop: Boolean? = null
     ) {
         context.displayPreferencesDataStore.edit { preferences ->
             showFpsCounter?.let { preferences[KEY_SHOW_FPS_COUNTER] = it }
@@ -264,6 +318,17 @@ class DisplayPreferencesManager private constructor(private val context: Context
             }
             virtualDisplayBitrateKbps?.let { preferences[KEY_VIRTUAL_DISPLAY_BITRATE_KBPS] = it }
             toolCollapseMode?.let { preferences[KEY_TOOL_COLLAPSE_MODE] = it.value }
+            streamScrollMaxSpeedDp?.let {
+                preferences[KEY_STREAM_SCROLL_MAX_SPEED_DP] =
+                    if (it == STREAM_SCROLL_SPEED_UNLIMITED) {
+                        STREAM_SCROLL_SPEED_UNLIMITED
+                    } else {
+                        it.coerceIn(STREAM_SCROLL_SPEED_MIN_DP, STREAM_SCROLL_SPEED_MAX_LIMITED_DP)
+                    }
+            }
+            enableNonStreamingScrollToTop?.let {
+                preferences[KEY_ENABLE_NON_STREAMING_SCROLL_TO_TOP] = it
+            }
         }
     }
 

app/src/main/java/com/ai/assistance/operit/ui/features/chat/components/ChatArea.kt

@@ -1,5 +1,5 @@
 package com.ai.assistance.operit.ui.features.chat.components
-
+import com.ai.assistance.operit.data.preferences.DisplayPreferencesManager
 import android.widget.Toast
 import androidx.compose.animation.core.RepeatMode
 import androidx.compose.animation.core.StartOffset
@@ -261,23 +261,28 @@ fun ChatArea(
     val showMessageTokenStats = themeSnapshot.showMessageTokenStats
     val showMessageTimingStats = themeSnapshot.showMessageTimingStats
     val showMessageTimestamp = themeSnapshot.showMessageTimestamp
+    val displayPreferencesManager = remember { DisplayPreferencesManager.getInstance(context) }
+    val streamScrollMaxSpeedDp by displayPreferencesManager.streamScrollMaxSpeedDp.collectAsState(
+        initial = DisplayPreferencesManager.STREAM_SCROLL_SPEED_DEFAULT_DP
+    )
+    val enableNonStreamingScrollToTop by displayPreferencesManager.enableNonStreamingScrollToTop.collectAsState(initial = true)
     var viewportHeightPx by remember { mutableStateOf(0) }
     val messageAnchors = remember(currentChatId) { mutableStateMapOf<Long, ChatScrollMessageAnchor>() }
+    val streamedAiMessageTimestamps = remember(currentChatId) { mutableSetOf<Long>() }
     var pendingJumpToMessageTimestamp by remember(currentChatId) { mutableStateOf<Long?>(null) }
     val lastMessage = chatHistory.lastOrNull()
     val pendingTargetAnchor =
         pendingJumpToMessageTimestamp?.let { targetTimestamp -> messageAnchors[targetTimestamp] }
     var hasLastAiMessageStartedStreaming by remember(lastMessage?.timestamp) {
         mutableStateOf(lastMessage?.run { sender == "ai" && content.isNotBlank() } == true)
     }
-
     val messagesCount = chatHistory.size
     LaunchedEffect(currentChatId, chatHistory.isEmpty()) {
         if (chatHistory.isEmpty()) {
             pendingJumpToMessageTimestamp = null
+            streamedAiMessageTimestamps.clear()
         }
     }
-
     val lastMessageContentLength = lastMessage?.content?.length
     LaunchedEffect(
         autoScrollToBottom,
@@ -297,7 +302,6 @@ fun ChatArea(
             pendingJumpToMessageTimestamp = lastMessage?.timestamp
         }
     }
-
     LaunchedEffect(
         pendingJumpToMessageTimestamp,
         messagesCount,
@@ -315,37 +319,56 @@ fun ChatArea(
         val targetAnchor = pendingTargetAnchor ?: return@LaunchedEffect
         val isActualLatestMessage = targetIndex == messagesCount - 1 && !hasNewerDisplayHistory
         onAutoScrollToBottomChange?.invoke(isActualLatestMessage)
-
         if (targetIndex == messagesCount - 1) {
-            scrollState.animateScrollTo(scrollState.maxValue)
+            val targetMessage = chatHistory.getOrNull(targetIndex)
+            val isTargetAi = targetMessage?.sender == "ai"
+            val isNonStreamingAi = isTargetAi &&
+                targetMessage?.contentStream == null &&
+                targetMessage?.timestamp !in streamedAiMessageTimestamps
+
+            if (isNonStreamingAi && enableNonStreamingScrollToTop) {
+                val targetOffset =
+                    targetAnchor.absoluteTopPx.roundToInt().coerceIn(0, scrollState.maxValue)
+                scrollState.animateScrollTo(targetOffset)
+            } else {
+                val isStreaming = isTargetAi && (targetMessage?.contentStream != null || targetMessage?.timestamp in streamedAiMessageTimestamps)
+                scrollState.animateScrollToWithSpeedLimit(
+                    targetValue = scrollState.maxValue,
+                    density = density,
+                    maxSpeedDpPerSecond =
+                        if (isStreaming) streamScrollMaxSpeedDp else UNLIMITED_SCROLL_SPEED
+                )
+            }
         } else {
             val targetOffset =
                 targetAnchor.absoluteTopPx.roundToInt().coerceIn(0, scrollState.maxValue)
             scrollState.animateScrollTo(targetOffset)
         }
         pendingJumpToMessageTimestamp = null
     }
-
     LaunchedEffect(lastMessage?.timestamp, lastMessage?.contentStream) {
         val lastAiMessageHasStaticContent =
             lastMessage?.let { it.sender == "ai" && it.content.isNotBlank() } == true
         hasLastAiMessageStartedStreaming = lastAiMessageHasStaticContent
-
         val shouldAwaitFirstChunk =
             lastMessage?.let {
                 it.sender == "ai" && it.content.isBlank() && it.contentStream != null
             } == true
         val stream = lastMessage?.contentStream
 
+        if (lastMessage?.sender == "ai" && stream != null) {
+            lastMessage.timestamp.let { streamedAiMessageTimestamps.add(it) }
+        }
+
         if (!lastAiMessageHasStaticContent && shouldAwaitFirstChunk && stream != null) {
             stream.collect { chunk ->
                 if (!hasLastAiMessageStartedStreaming && chunk.isNotEmpty()) {
                     hasLastAiMessageStartedStreaming = true
+                    lastMessage?.timestamp?.let { streamedAiMessageTimestamps.add(it) }
                 }
             }
         }
     }
-
     LaunchedEffect(
         messagesCount,
         chatHistory.firstOrNull()?.timestamp,
@@ -356,8 +379,8 @@ fun ChatArea(
             .toList()
             .filterNot { it in visibleTimestamps }
             .forEach(messageAnchors::remove)
+        streamedAiMessageTimestamps.retainAll(visibleTimestamps)
     }
-
     val isLatestMessageVisible = messagesCount > 0 && !hasNewerDisplayHistory
     val showLoadingIndicator =
         isLatestMessageVisible &&

app/src/main/java/com/ai/assistance/operit/ui/features/chat/components/ChatScrollSpeedLimit.kt

@@ -0,0 +1,61 @@
+package com.ai.assistance.operit.ui.features.chat.components
+
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.ScrollState
+import androidx.compose.ui.unit.Density
+import com.ai.assistance.operit.data.preferences.DisplayPreferencesManager
+
+/**
+ * 表示“不限速”的速度值：滚动速度完全跟随模型吞吐量。
+ */
+const val UNLIMITED_SCROLL_SPEED = DisplayPreferencesManager.STREAM_SCROLL_SPEED_UNLIMITED
+
+/**
+ * 根据位移像素与屏幕密度，计算限速滚动所需的动画持续时间（毫秒）。
+ * 当内容产生大量下移时，拉长动画时间以将滚动速度限制在 [maxSpeedDpPerSecond] 之下。
+ */
+internal fun calculateScrollDurationMs(
+    deltaPx: Int,
+    densityDpiRatio: Float,
+    maxSpeedDpPerSecond: Float,
+    minDurationMs: Long = 100L,
+    maxDurationMs: Long = 1000L
+): Int {
+    if (deltaPx <= 0 || densityDpiRatio <= 0f || maxSpeedDpPerSecond <= 0f) {
+        return minDurationMs.toInt()
+    }
+    val deltaDp = deltaPx / densityDpiRatio
+    val calculatedMs = ((deltaDp / maxSpeedDpPerSecond) * 1000f).toLong()
+    return calculatedMs.coerceIn(minDurationMs, maxDurationMs).toInt()
+}
+
+/**
+ * 带有最大速度限制的平滑滚动。
+ *
+ * [maxSpeedDpPerSecond] 是速度上限而非固定速度：模型输出较慢时不会介入，
+ * 只有在单次位移会导致滚动超速时才拉长动画时长削峰。
+ * 传入 [UNLIMITED_SCROLL_SPEED] 时不做任何限制，滚动速度完全跟随模型吞吐量。
+ */
+suspend fun ScrollState.animateScrollToWithSpeedLimit(
+    targetValue: Int,
+    density: Density,
+    maxSpeedDpPerSecond: Int
+) {
+    val clampedTarget = targetValue.coerceIn(0, maxValue)
+    val delta = clampedTarget - value
+    if (maxSpeedDpPerSecond == UNLIMITED_SCROLL_SPEED || delta <= 0) {
+        animateScrollTo(clampedTarget)
+        return
+    }
+
+    val duration = calculateScrollDurationMs(
+        deltaPx = delta,
+        densityDpiRatio = density.density,
+        maxSpeedDpPerSecond = maxSpeedDpPerSecond.toFloat()
+    )
+    animateScrollTo(
+        clampedTarget,
+        animationSpec = tween(durationMillis = duration, easing = LinearEasing)
+    )
+}

app/src/main/java/com/ai/assistance/operit/ui/features/chat/screens/AIChatScreen.kt

@@ -186,6 +186,10 @@ val actualViewModel: ChatViewModel = viewModel ?: viewModel { ChatViewModel(cont
     val chatHeaderOverlayMode = themeSnapshot.chatHeaderOverlayMode
     val showInputProcessingStatus = themeSnapshot.showInputProcessingStatus
     val enableEnterToSend by displayPreferencesManager.enableEnterToSend.collectAsState(initial = false)
+    val streamScrollMaxSpeedDp by displayPreferencesManager.streamScrollMaxSpeedDp.collectAsState(
+        initial = DisplayPreferencesManager.STREAM_SCROLL_SPEED_DEFAULT_DP
+    )
+    val enableNonStreamingScrollToTop by displayPreferencesManager.enableNonStreamingScrollToTop.collectAsState(initial = true)
     val showChatFloatingDotsAnimation = themeSnapshot.showChatFloatingDotsAnimation
     val hasBackgroundImageFromPrefs = useBackgroundImage && backgroundImageUri != null
     val effectiveHasBackgroundImage = hasBackgroundImage || hasBackgroundImageFromPrefs
@@ -676,8 +680,19 @@ val actualViewModel: ChatViewModel = viewModel ?: viewModel { ChatViewModel(cont
                     !latestIsLoadingDisplayWindow
             ) {
                 try {
+                    val lastMsg = latestChatHistory.lastOrNull()
+                    val isNonStreamingAi = lastMsg?.sender == "ai" && lastMsg.contentStream == null
+                    if (isNonStreamingAi && enableNonStreamingScrollToTop) {
+                        return@collect
+                    }
                     if (latestChatHistory.isNotEmpty()) {
-                        scrollState.animateScrollTo(scrollState.maxValue)
+                        val isStreaming = lastMsg?.sender == "ai" && lastMsg.contentStream != null
+                        scrollState.animateScrollToWithSpeedLimit(
+                            targetValue = scrollState.maxValue,
+                            density = density,
+                            maxSpeedDpPerSecond =
+                                if (isStreaming) streamScrollMaxSpeedDp else UNLIMITED_SCROLL_SPEED
+                        )
                     }
                 } catch (e: Exception) {
                     // AppLogger.e("AIChatScreen", "自动滚动失败", e)