msglist: Implement mark-read-on-scroll, without yet enabling

When we add the setting for this, coming up, this long-awaited
feature will become active. Hooray!

This still needs tests. We're tracking that as #1583 for early
post-launch. (The launch is coming up very soon.)

Author: chrisbobbe

lib/model/message.dart

@@ -1,10 +1,11 @@
 import 'dart:async';
-import 'dart:collection';
 import 'dart:convert';
 
+import 'package:collection/collection.dart';
 import 'package:crypto/crypto.dart';
 import 'package:flutter/foundation.dart';
 
+import '../api/exception.dart';
 import '../api/model/events.dart';
 import '../api/model/model.dart';
 import '../api/route/messages.dart';
@@ -28,6 +29,8 @@ mixin MessageStore {
   void registerMessageList(MessageListView view);
   void unregisterMessageList(MessageListView view);
 
+  void markReadFromScroll(Iterable<int> messageIds);
+
   Future<void> sendMessage({
     required MessageDestination destination,
     required String content,
@@ -180,6 +183,67 @@ class MessageStoreImpl extends PerAccountStoreBase with MessageStore, _OutboxMes
     _disposed = true;
   }
 
+  static const _markReadOnScrollBatchSize = 1000;
+  static const _markReadOnScrollDebounceDuration = Duration(milliseconds: 500);
+  final _markReadOnScrollQueue = _MarkReadOnScrollQueue();
+  bool _markReadOnScrollBusy = false;
+
+  /// Returns true on success, false on failure.
+  Future<bool> _sendMarkReadOnScrollRequest(List<int> toSend) async {
+    assert(toSend.isNotEmpty);
+
+    // TODO(#1581) mark as read locally for latency compensation
+    //   (in Unreads and on the message objects)
+    try {
+      await updateMessageFlags(connection,
+        messages: toSend,
+        op: UpdateMessageFlagsOp.add,
+        flag: MessageFlag.read);
+    } on ApiRequestException {
+      // TODO(#1581) un-mark as read locally?
+      return false;
+    }
+    return true;
+  }
+
+  @override
+  void markReadFromScroll(Iterable<int> messageIds) async {
+    assert(!_disposed);
+    _markReadOnScrollQueue.addAll(messageIds);
+    if (_markReadOnScrollBusy) return;
+
+    _markReadOnScrollBusy = true;
+    try {
+      do {
+        final toSend = <int>[];
+        int numFromQueue = 0;
+        for (final messageId in _markReadOnScrollQueue.iterable) {
+          if (toSend.length == _markReadOnScrollBatchSize) {
+            break;
+          }
+          final message = messages[messageId];
+          if (message != null && !message.flags.contains(MessageFlag.read)) {
+            toSend.add(message.id);
+          }
+          numFromQueue++;
+        }
+
+        if (toSend.isEmpty || await _sendMarkReadOnScrollRequest(toSend)) {
+          if (_disposed) return;
+          _markReadOnScrollQueue.removeFirstN(numFromQueue);
+        }
+        if (_disposed) return;
+
+        await Future<void>.delayed(_markReadOnScrollDebounceDuration);
+        if (_disposed) return;
+      } while (_markReadOnScrollQueue.isNotEmpty);
+    } finally {
+      if (!_disposed) {
+        _markReadOnScrollBusy = false;
+      }
+    }
+  }
+
   @override
   Future<void> sendMessage({required MessageDestination destination, required String content}) {
     assert(!_disposed);
@@ -517,6 +581,34 @@ class MessageStoreImpl extends PerAccountStoreBase with MessageStore, _OutboxMes
   }
 }
 
+class _MarkReadOnScrollQueue {
+  _MarkReadOnScrollQueue();
+
+  bool get isNotEmpty => _queue.isNotEmpty;
+
+  final _set = <int>{};
+  final _queue = QueueList<int>();
+
+  /// Add [messageIds] to the end of the queue,
+  /// if they aren't already in the queue.
+  void addAll(Iterable<int> messageIds) {
+    for (final messageId in messageIds) {
+      if (_set.add(messageId)) {
+        _queue.add(messageId);
+      }
+    }
+  }
+
+  Iterable<int> get iterable => _queue;
+
+  void removeFirstN(int n) {
+    for (int i = 0; i < n; i++) {
+      if (_queue.isEmpty) break;
+      _set.remove(_queue.removeFirst());
+    }
+  }
+}
+
 /// The duration an outbox message stays hidden to the user.
 ///
 /// See [OutboxMessageState.waiting].

lib/model/message_list.dart

@@ -222,6 +222,17 @@ mixin _MessageSequence {
     return binarySearchByKey(items, messageId, _compareItemToMessageId);
   }
 
+  Iterable<Message>? getMessagesRange(int firstMessageId, int lastMessageId) {
+    assert(firstMessageId <= lastMessageId);
+    final firstIndex = _findMessageWithId(firstMessageId);
+    final lastIndex = _findMessageWithId(lastMessageId);
+    if (firstIndex == -1 || lastIndex == -1) {
+      // TODO(log)
+      return null;
+    }
+    return messages.getRange(firstIndex, lastIndex + 1);
+  }
+
   static int _compareItemToMessageId(MessageListItem item, int messageId) {
     switch (item) {
       case MessageListRecipientHeaderItem(:var message):

lib/model/store.dart

@@ -758,6 +758,9 @@ class PerAccountStore extends PerAccountStoreBase with ChangeNotifier, EmojiStor
   void unregisterMessageList(MessageListView view) =>
     _messages.unregisterMessageList(view);
   @override
+  void markReadFromScroll(Iterable<int> messageIds) =>
+    _messages.markReadFromScroll(messageIds);
+  @override
   Future<void> sendMessage({required MessageDestination destination, required String content}) {
     assert(!_disposed);
     return _messages.sendMessage(destination: destination, content: content);

lib/widgets/action_sheet.dart

@@ -896,9 +896,11 @@ class MarkAsUnreadButton extends MessageActionSheetMenuItemButton {
   }
 
   @override void onPressed() async {
-    final narrow = findMessageListPage().narrow;
+    final messageListPage = findMessageListPage();
     unawaited(ZulipAction.markNarrowAsUnreadFromMessage(pageContext,
-      message, narrow));
+      message, messageListPage.narrow));
+    // TODO should we alert the user about this change somehow? A snackbar?
+    messageListPage.markReadOnScroll = false;
   }
 }