feat: Send state event to timeline when sharing megolm session

Author: krille-chan

lib/encryption/key_manager.dart

@@ -293,6 +293,43 @@ class KeyManager {
     return sess;
   }
 
+  void _sendEncryptionInfoEvent({
+    required String roomId,
+    required List<String> userIds,
+    List<String>? deviceIds,
+  }) async {
+    await client.database?.transaction(() async {
+      await client.handleSync(
+        SyncUpdate(
+          nextBatch: '',
+          rooms: RoomsUpdate(
+            join: {
+              roomId: JoinedRoomUpdate(
+                timeline: TimelineUpdate(
+                  events: [
+                    MatrixEvent(
+                      eventId:
+                          'fake_event_${client.generateUniqueTransactionId()}',
+                      content: {
+                        'body':
+                            '${userIds.join(', ')} can now read along${deviceIds != null ? ' on a new device' : ''}',
+                        if (deviceIds != null) 'devices': deviceIds,
+                        'users': userIds,
+                      },
+                      type: 'sdk.dart.matrix.new_megolm_session',
+                      senderId: client.userID!,
+                      originServerTs: DateTime.now(),
+                    ),
+                  ],
+                ),
+              ),
+            },
+          ),
+        ),
+      );
+    });
+  }
+
   Map<String, Map<String, bool>> _getDeviceKeyIdMap(
     List<DeviceKeys> deviceKeys,
   ) {
@@ -328,21 +365,6 @@ class KeyManager {
       return true;
     }
 
-    if (!wipe) {
-      // first check if it needs to be rotated
-      final encryptionContent =
-          room.getState(EventTypes.Encryption)?.parsedRoomEncryptionContent;
-      final maxMessages = encryptionContent?.rotationPeriodMsgs ?? 100;
-      final maxAge = encryptionContent?.rotationPeriodMs ??
-          604800000; // default of one week
-      if ((sess.sentMessages ?? maxMessages) >= maxMessages ||
-          sess.creationTime
-              .add(Duration(milliseconds: maxAge))
-              .isBefore(DateTime.now())) {
-        wipe = true;
-      }
-    }
-
     final inboundSess = await loadInboundGroupSession(
       room.id,
       sess.outboundGroupSession!.session_id(),
@@ -357,8 +379,8 @@ class KeyManager {
       final newDeviceKeys = await room.getUserDeviceKeys();
       final newDeviceKeyIds = _getDeviceKeyIdMap(newDeviceKeys);
       // first check for user differences
-      final oldUserIds = Set.from(sess.devices.keys);
-      final newUserIds = Set.from(newDeviceKeyIds.keys);
+      final oldUserIds = sess.devices.keys.toSet();
+      final newUserIds = newDeviceKeyIds.keys.toSet();
       if (oldUserIds.difference(newUserIds).isNotEmpty) {
         // a user left the room, we must wipe the session
         wipe = true;
@@ -368,6 +390,7 @@ class KeyManager {
           // new user! Gotta send the megolm session to them
           devicesToReceive
               .addAll(newDeviceKeys.where((d) => newUsers.contains(d.userId)));
+          _sendEncryptionInfoEvent(roomId: roomId, userIds: newUsers.toList());
         }
         // okay, now we must test all the individual user devices, if anything new got blocked
         // or if we need to send to any new devices.
@@ -389,37 +412,45 @@ class KeyManager {
                       .map((e) => e.key),
                 )
               : <String>{};
-          // we don't really care about old devices that got dropped (deleted), we only care if new ones got added and if new ones got blocked
-          // check if new devices got blocked
-          if (newBlockedDevices.difference(oldBlockedDevices).isNotEmpty) {
-            wipe = true;
-            break;
-          }
           // and now add all the new devices!
           final oldDeviceIds = sess.devices.containsKey(userId)
-              ? Set.from(
-                  sess.devices[userId]!.entries
-                      .where((e) => !e.value)
-                      .map((e) => e.key),
-                )
+              ? sess.devices[userId]!.entries
+                  .where((e) => !e.value)
+                  .map((e) => e.key)
+                  .toSet()
               : <String>{};
           final newDeviceIds = newDeviceKeyIds.containsKey(userId)
-              ? Set.from(
-                  newDeviceKeyIds[userId]!
-                      .entries
-                      .where((e) => !e.value)
-                      .map((e) => e.key),
-                )
+              ? newDeviceKeyIds[userId]!
+                  .entries
+                  .where((e) => !e.value)
+                  .map((e) => e.key)
+                  .toSet()
               : <String>{};
 
+          // check if any new devices need keys
+          final newDevices = newDeviceIds.difference(oldDeviceIds);
+
+          if (userId != client.userID && newDevices.isNotEmpty) {
+            _sendEncryptionInfoEvent(
+              roomId: roomId,
+              userIds: [userId],
+              deviceIds: newDevices.toList(),
+            );
+          }
+
+          // we don't really care about old devices that got dropped (deleted), we only care if new ones got added and if new ones got blocked
+          // check if new devices got blocked
+          if (newBlockedDevices.difference(oldBlockedDevices).isNotEmpty) {
+            wipe = true;
+            continue;
+          }
+
           // check if a device got removed
           if (oldDeviceIds.difference(newDeviceIds).isNotEmpty) {
             wipe = true;
-            break;
+            continue;
           }
 
-          // check if any new devices need keys
-          final newDevices = newDeviceIds.difference(oldDeviceIds);
           if (newDeviceIds.isNotEmpty) {
             devicesToReceive.addAll(
               newDeviceKeys.where(
@@ -430,6 +461,21 @@ class KeyManager {
         }
       }
 
+      if (!wipe) {
+        // first check if it needs to be rotated
+        final encryptionContent =
+            room.getState(EventTypes.Encryption)?.parsedRoomEncryptionContent;
+        final maxMessages = encryptionContent?.rotationPeriodMsgs ?? 100;
+        final maxAge = encryptionContent?.rotationPeriodMs ??
+            604800000; // default of one week
+        if ((sess.sentMessages ?? maxMessages) >= maxMessages ||
+            sess.creationTime
+                .add(Duration(milliseconds: maxAge))
+                .isBefore(DateTime.now())) {
+          wipe = true;
+        }
+      }
+
       if (!wipe) {
         if (!use) {
           return false;

lib/src/utils/event_localizations.dart

@@ -119,6 +119,7 @@ abstract class EventLocalizations {
     EventTypes.Sticker: (event, i18n, body) => i18n.sentASticker(
           event.senderFromMemoryOrFallback.calcDisplayname(i18n: i18n),
         ),
+    'sdk.dart.matrix.new_megolm_session': (event, i18n, body) => body,
     EventTypes.Redaction: (event, i18n, body) => i18n.redactedAnEvent(event),
     EventTypes.RoomAliases: (event, i18n, body) => i18n.changedTheRoomAliases(
           event.senderFromMemoryOrFallback.calcDisplayname(i18n: i18n),