autocomplete: Add "recent activity in current topic/stream" criterion

In @-mention autocomplete, users are suggested based on:
  1. Recent activity in the current topic/stream.
  2. Recent DM conversations.

Note: By "recent activity" we mean recent messages sent to a topic/stream.

Fixes part of: zulip#228

Author: sm-sayedi

lib/model/autocomplete.dart

@@ -188,8 +188,71 @@ class MentionAutocompleteView extends ChangeNotifier {
     required Narrow narrow,
   }) {
     assert(narrow is! CombinedFeedNarrow);
+
+    final (streamId, topic) = switch (narrow) {
+      StreamNarrow() => (narrow.streamId, null),
+      TopicNarrow() => (narrow.streamId, narrow.topic),
+      // The CombinedFeedNarrow case should be impossible anyway.
+      DmNarrow() || CombinedFeedNarrow() => (null, null),
+    };
+
     return store.users.values.toList()
-      ..sort((userA, userB) => compareByDms(userA, userB, store: store));
+      ..sort((userA, userB) => _compareByRelevance(userA, userB,
+          streamId: streamId,
+          topic: topic,
+          store: store));
+  }
+
+  static int _compareByRelevance(User userA, User userB, {
+    required int? streamId,
+    required String? topic,
+    required PerAccountStore store,
+  }) {
+    if (streamId != null) {
+      final result = compareByRecency(userA, userB,
+        streamId: streamId,
+        topic: topic,
+        store: store);
+      if (result != 0) {
+        return result;
+      }
+    }
+    return compareByDms(userA, userB, store: store);
+  }
+
+  /// Determines which of the two users has more recent activity (messages sent
+  /// recently) in the topic/stream.
+  ///
+  /// First checks for the activity in [topic] if provided.
+  ///
+  /// If no [topic] is provided, or there is no activity in the topic at all,
+  /// then checks for the activity in the stream with [streamId].
+  ///
+  /// Returns a negative number if [userA] has more recent activity than [userB],
+  /// returns a positive number if [userB] has more recent activity than [userA],
+  /// and returns `0` if both [userA] and [userB] have no activity at all.
+  @visibleForTesting
+  static int compareByRecency(User userA, User userB, {
+    required int streamId,
+    required String? topic,
+    required PerAccountStore store,
+  }) {
+    final recentSenders = store.recentSenders;
+    if (topic != null) {
+      final aMessageId = recentSenders.latestMessageIdOfSenderInTopic(
+        streamId: streamId, topic: topic, senderId: userA.userId);
+      final bMessageId = recentSenders.latestMessageIdOfSenderInTopic(
+        streamId: streamId, topic: topic, senderId: userB.userId);
+
+      final result = -compareNullable(aMessageId, bMessageId);
+      if (result != 0) return result;
+    }
+
+    final aMessageId = recentSenders.latestMessageIdOfSenderInStream(
+      streamId: streamId, senderId: userA.userId);
+    final bMessageId = recentSenders.latestMessageIdOfSenderInStream(
+      streamId: streamId, senderId: userB.userId);
+    return -compareNullable(aMessageId, bMessageId);
   }
 
   /// Determines which of the two users is more recent in DM conversations.

test/model/autocomplete_test.dart

@@ -359,10 +359,12 @@ void main() {
     Future<void> prepare({
       List<User> users = const [],
       List<RecentDmConversation> dmConversations = const [],
+      List<Message> messages = const [],
     }) async {
       store = eg.store(initialSnapshot: eg.initialSnapshot(
         recentPrivateConversations: dmConversations));
       await store.addUsers(users);
+      await store.addMessages(messages);
     }
 
     group('MentionAutocompleteView.compareNullable', () {
@@ -379,6 +381,62 @@ void main() {
 
       test('both of [a] and [b] are null', () async {
         check(MentionAutocompleteView.compareNullable(null, null)).equals(0);
+        check(MentionAutocompleteView.compareNullable(null, null)).equals(0);
+      });
+    });
+
+    group('MentionAutocompleteView.compareByRecency', () {
+      final userA = eg.otherUser;
+      final userB = eg.thirdUser;
+      final stream = eg.stream();
+      const topic1 = 'topic1';
+      const topic2 = 'topic2';
+
+      Message message(User sender, String topic) {
+        return eg.streamMessage(
+          sender: sender,
+          stream: stream,
+          topic: topic,
+        );
+      }
+
+      int compareAB({required String? topic}) {
+        return MentionAutocompleteView.compareByRecency(userA, userB,
+          streamId: stream.streamId,
+          topic: topic,
+          store: store,
+        );
+      }
+
+      test('prioritizes the user with more recent activity in the topic', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic1),
+        ]);
+        check(compareAB(topic: topic1)).isGreaterThan(0);
+      });
+
+      test('prioritizes the user with more recent activity in the stream '
+        'if there is no activity in the topic from both users', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic1),
+        ]);
+        check(compareAB(topic: topic2)).isGreaterThan(0);
+      });
+
+      test('prioritizes the user with more recent activity in the stream '
+        'if there is no topic provided', () async {
+        await prepare(messages: [
+          message(userA, topic1),
+          message(userB, topic2),
+        ]);
+        check(compareAB(topic: null)).isGreaterThan(0);
+      });
+
+      test('prioritizes none of the users if there is no activity in the stream from both users', () async {
+        await prepare(messages: []);
+        check(compareAB(topic: null)).equals(0);
       });
     });
 
@@ -436,8 +494,11 @@ void main() {
     });
 
     group('autocomplete suggests relevant users in the intended order', () {
-      // The order should be:
-      // 1. Users most recent in the DM conversations
+      // 1. Users most recent in the current topic/stream.
+      // 2. Users most recent in the DM conversations.
+
+      final stream = eg.stream();
+      const topic = 'topic';
 
       Future<void> checkResultsIn(Narrow narrow, {required List<int> expected}) async {
         final users = [
@@ -454,7 +515,15 @@ void main() {
           RecentDmConversation(userIds: [0, 1], maxMessageId: 100),
         ];
 
-        await prepare(users: users, dmConversations: dmConversations);
+        final messages = [
+          eg.streamMessage(sender: users[0], stream: stream, topic: topic),
+          eg.streamMessage(sender: users[4], stream: stream),
+        ];
+
+        await prepare(
+          users: users,
+          dmConversations: dmConversations,
+          messages: messages);
         final view = MentionAutocompleteView.init(store: store, narrow: narrow);
 
         bool done = false;
@@ -468,11 +537,11 @@ void main() {
       }
 
       test('StreamNarrow', () async {
-        await checkResultsIn(const StreamNarrow(1), expected: [3, 0, 1, 2, 4]);
+        await checkResultsIn(StreamNarrow(stream.streamId), expected: [4, 0, 3, 1, 2]);
       });
 
       test('TopicNarrow', () async {
-        await checkResultsIn(const TopicNarrow(1, 'topic'), expected: [3, 0, 1, 2, 4]);
+        await checkResultsIn(TopicNarrow(stream.streamId, topic), expected: [0, 4, 3, 1, 2]);
       });
 
       test('DmNarrow', () async {