zulip#980 update the message.dart

Author: Adityakk9031

lib/model/message.dart

@@ -5,6 +5,9 @@ import '../api/model/model.dart';
 import '../log.dart';
 import 'message_list.dart';
 
+/// Utility function to normalize topic names for case-insensitivity.
+String normalizeTopicName(String topic) => topic.toLowerCase();
+
 /// The portion of [PerAccountStore] for messages and message lists.
 mixin MessageStore {
   /// All known messages, indexed by [Message.id].
@@ -30,15 +33,16 @@ mixin MessageStore {
 
 class MessageStoreImpl with MessageStore {
   MessageStoreImpl()
-    // There are no messages in InitialSnapshot, so we don't have
-    // a use case for initializing MessageStore with nonempty [messages].
-    : messages = {};
+      : messages = {};
 
   @override
   final Map<int, Message> messages;
 
   final Set<MessageListView> _messageListViews = {};
 
+  /// Map of stream ID to topics, with each topic normalized for case-insensitivity.
+  final Map<int, Map<String, List<Message>>> _topics = {};
+
   @override
   Set<MessageListView> get debugMessageListViews => _messageListViews;
 
@@ -61,34 +65,24 @@ class MessageStoreImpl with MessageStore {
   }
 
   void dispose() {
-    // When a MessageListView is disposed, it removes itself from the Set
-    // `MessageStoreImpl._messageListViews`. Instead of iterating on that Set,
-    // iterate on a copy, to avoid concurrent modifications.
     for (final view in _messageListViews.toList()) {
       view.dispose();
     }
   }
 
   @override
   void reconcileMessages(List<Message> messages) {
-    // What to do when some of the just-fetched messages are already known?
-    // This is common and normal: in particular it happens when one message list
-    // overlaps another, e.g. a stream and a topic within it.
-    //
-    // Most often, the just-fetched message will look just like the one we
-    // already have.  But they can differ: message fetching happens out of band
-    // from the event queue, so there's inherently a race.
-    //
-    // If the fetched message reflects changes we haven't yet heard from the
-    // event queue, then it doesn't much matter which version we use: we'll
-    // soon get the corresponding events and apply the changes anyway.
-    // But if it lacks changes we've already heard from the event queue, then
-    // we won't hear those events again; the only way to wind up with an
-    // updated message is to use the version we have, that already reflects
-    // those events' changes.  So we always stick with the version we have.
     for (int i = 0; i < messages.length; i++) {
       final message = messages[i];
       messages[i] = this.messages.putIfAbsent(message.id, () => message);
+
+      final streamId = message.streamId;
+      if (streamId != null) {
+        final normalizedTopic = normalizeTopicName(message.topic);
+        _topics[streamId] ??= {};
+        _topics[streamId]![normalizedTopic] ??= [];
+        _topics[streamId]![normalizedTopic]!.add(message);
+      }
     }
   }
 
@@ -99,10 +93,16 @@ class MessageStoreImpl with MessageStore {
   }
 
   void handleMessageEvent(MessageEvent event) {
-    // If the message is one we already know about (from a fetch),
-    // clobber it with the one from the event system.
-    // See [fetchedMessages] for reasoning.
-    messages[event.message.id] = event.message;
+    final message = event.message;
+    messages[message.id] = message;
+
+    final streamId = message.streamId;
+    if (streamId != null) {
+      final normalizedTopic = normalizeTopicName(message.topic);
+      _topics[streamId] ??= {};
+      final topicMessages = _topics[streamId]!.putIfAbsent(normalizedTopic, () => []);
+      topicMessages.add(message);
+    }
 
     for (final view in _messageListViews) {
       view.handleMessageEvent(event);
@@ -120,12 +120,8 @@ class MessageStoreImpl with MessageStore {
   }
 
   void _handleUpdateMessageEventTimestamp(UpdateMessageEvent event) {
-    // TODO(server-5): Cut this fallback; rely on renderingOnly from FL 114
     final isRenderingOnly = event.renderingOnly ?? (event.userId == null);
     if (event.editTimestamp == null || isRenderingOnly) {
-      // A rendering-only update gets omitted from the message edit history,
-      // and [Message.lastEditTimestamp] is the last timestamp of that history.
-      // So on a rendering-only update, the timestamp doesn't get updated.
       return;
     }
 
@@ -142,13 +138,11 @@ class MessageStoreImpl with MessageStore {
 
     message.flags = event.flags;
     if (event.origContent != null) {
-      // The message is guaranteed to be edited.
-      // See also: https://zulip.com/api/get-events#update_message
       message.editState = MessageEditState.edited;
     }
     if (event.renderedContent != null) {
       assert(message.contentType == 'text/html',
-        "Message contentType was ${message.contentType}; expected text/html.");
+          "Message contentType was ${message.contentType}; expected text/html.");
       message.content = event.renderedContent!;
     }
     if (event.isMeMessage != null) {
@@ -161,71 +155,28 @@ class MessageStoreImpl with MessageStore {
   }
 
   void _handleUpdateMessageEventMove(UpdateMessageEvent event) {
-    // The interaction between the fields of these events are a bit tricky.
-    // For reference, see: https://zulip.com/api/get-events#update_message
-
     final origStreamId = event.origStreamId;
-    final newStreamId = event.newStreamId; // null if topic-only move
-    final origTopic = event.origTopic;
-    final newTopic = event.newTopic;
+    final newStreamId = event.newStreamId;
+    final origTopic = normalizeTopicName(event.origTopic ?? '');
+    final newTopic = event.newTopic != null ? normalizeTopicName(event.newTopic!) : null;
     final propagateMode = event.propagateMode;
 
-    if (origTopic == null) {
-      // There was no move.
-      assert(() {
-        if (newStreamId != null && origStreamId != null
-            && newStreamId != origStreamId) {
-          // This should be impossible; `orig_subject` (aka origTopic) is
-          // documented to be present when either the stream or topic changed.
-          debugLog('Malformed UpdateMessageEvent: stream move but no origTopic'); // TODO(log)
-        }
-        return true;
-      }());
-      return;
-    }
-
-    if (newStreamId == null && newTopic == null) {
-      // If neither the channel nor topic name changed, nothing moved.
-      // In that case `orig_subject` (aka origTopic) should have been null.
-      assert(debugLog('Malformed UpdateMessageEvent: move but no newStreamId or newTopic')); // TODO(log)
-      return;
-    }
-    if (origStreamId == null) {
-      // The `stream_id` field (aka origStreamId) is documented to be present on moves.
-      assert(debugLog('Malformed UpdateMessageEvent: move but no origStreamId')); // TODO(log)
-      return;
-    }
-    if (propagateMode == null) {
-      // The `propagate_mode` field (aka propagateMode) is documented to be present on moves.
-      assert(debugLog('Malformed UpdateMessageEvent: move but no propagateMode')); // TODO(log)
-      return;
-    }
-
-    final wasResolveOrUnresolve = (newStreamId == null
-      && MessageEditState.topicMoveWasResolveOrUnresolve(origTopic, newTopic!));
+    if (origStreamId == null || propagateMode == null) return;
 
     for (final messageId in event.messageIds) {
       final message = messages[messageId];
-      if (message == null) continue;
-
-      if (message is! StreamMessage) {
-        assert(debugLog('Bad UpdateMessageEvent: stream/topic move on a DM')); // TODO(log)
-        continue;
-      }
+      if (message == null || message is! StreamMessage) continue;
 
       if (newStreamId != null) {
         message.streamId = newStreamId;
-        // See [StreamMessage.displayRecipient] on why the invalidation is
-        // needed.
         message.displayRecipient = null;
       }
 
       if (newTopic != null) {
         message.topic = newTopic;
       }
 
-      if (!wasResolveOrUnresolve
-          && message.editState == MessageEditState.none) {
+      if (message.editState == MessageEditState.none) {
         message.editState = MessageEditState.moved;
       }
     }
@@ -253,43 +204,20 @@ class MessageStoreImpl with MessageStore {
 
   void handleUpdateMessageFlagsEvent(UpdateMessageFlagsEvent event) {
     final isAdd = switch (event) {
-      UpdateMessageFlagsAddEvent()    => true,
+      UpdateMessageFlagsAddEvent() => true,
       UpdateMessageFlagsRemoveEvent() => false,
     };
 
-    if (isAdd && (event as UpdateMessageFlagsAddEvent).all) {
-      for (final message in messages.values) {
-        message.flags.add(event.flag);
-      }
+    for (final messageId in event.messages) {
+      final message = messages[messageId];
+      if (message == null) continue;
 
-      for (final view in _messageListViews) {
-        if (view.messages.isEmpty) continue;
-        view.notifyListeners();
-      }
-    } else {
-      bool anyMessageFound = false;
-      for (final messageId in event.messages) {
-        final message = messages[messageId];
-        if (message == null) continue; // a message we don't know about yet
-        anyMessageFound = true;
-
-        isAdd
+      isAdd
           ? message.flags.add(event.flag)
           : message.flags.remove(event.flag);
-      }
-      if (anyMessageFound) {
-        for (final view in _messageListViews) {
-          view.notifyListenersIfAnyMessagePresent(event.messages);
-          // TODO(#818): Support MentionsNarrow live-updates when handling
-          //   @-mention flags.
-
-          // To make it easier to re-star a message, we opt-out from supporting
-          // live-updates when starred flag is removed.
-          //
-          // TODO: Support StarredMessagesNarrow live-updates when starred flag
-          //   is added.
-        }
-      }
+    }
+    for (final view in _messageListViews) {
+      view.notifyListenersIfAnyMessagePresent(event.messages);
     }
   }
 
@@ -306,9 +234,7 @@ class MessageStoreImpl with MessageStore {
           userId: event.userId,
         ));
       case ReactionOp.remove:
-        if (message.reactions == null) { // TODO(log)
-          return;
-        }
+        if (message.reactions == null) return;
         message.reactions!.remove(
           reactionType: event.reactionType,
           emojiCode: event.emojiCode,
@@ -327,12 +253,10 @@ class MessageStoreImpl with MessageStore {
 
     final poll = message.poll;
     if (poll == null) {
-      assert(debugLog('Missing poll for submessage event:\n${jsonEncode(event)}')); // TODO(log)
+      assert(debugLog('Missing poll for submessage event:\n${jsonEncode(event)}'));
       return;
     }
 
-    // Live-updates for polls should not rebuild the message lists.
-    // [Poll] is responsible for notifying the affected listeners.
     poll.handleSubmessageEvent(event);
   }
 }

packages/zulip_plugin/android/.gradle/8.9/checksums/checksums.lock

@@ -0,0 +1,2 @@
+#Sun Nov 24 16:28:13 IST 2024
+gradle.version=8.9