Merge branch 'main' of https://github.com/pangeachat/client into toolbar-selection

lib/pages/chat_list/chat_list.dart

@@ -863,7 +863,7 @@ class ChatListController extends State<ChatList>
 
         if (space.canSendDefaultStates) {
           for (final roomId in selectedRoomIds) {
-            await space.pangeaSetSpaceChild(roomId);
+            await space.pangeaSetSpaceChild(roomId, suggested: true);
           }
         }
         // Pangea#

lib/pages/chat_list/space_view.dart

@@ -579,7 +579,12 @@ class _SpaceViewState extends State<SpaceView> {
                 : null,
           );
         }
-        await activeSpace.setSpaceChild(roomId);
+        await activeSpace.setSpaceChild(
+          roomId,
+          // #Pangea
+          suggested: true,
+          // Pangea#
+        );
       },
     );
     if (result.error != null) return;

lib/pangea/extensions/pangea_room_extension/pangea_room_extension.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:convert';
 import 'dart:developer';
 
 import 'package:adaptive_dialog/adaptive_dialog.dart';

lib/pangea/extensions/pangea_room_extension/room_analytics_extension.dart

@@ -203,30 +203,66 @@ extension AnalyticsRoomExtension on Room {
         creationContent?.tryGet<String>(ModelKey.oldLangCode) == langCode;
   }
 
-  Future<String?> sendSummaryAnalyticsEvent(
+  Future<void> sendSummaryAnalyticsEvent(
     List<RecentMessageRecord> records,
   ) async {
     final SummaryAnalyticsModel analyticsModel = SummaryAnalyticsModel(
       messages: records,
     );
-    final String? eventId = await sendEvent(
+    await sendEvent(
       analyticsModel.toJson(),
       type: PangeaEventTypes.summaryAnalytics,
     );
-    return eventId;
   }
 
-  Future<String?> sendConstructsEvent(
+  /// Sends construct events to the server.
+  ///
+  /// The [uses] parameter is a list of [OneConstructUse] objects representing the
+  /// constructs to be sent. To prevent hitting the maximum event size, the events
+  /// are chunked into smaller lists. Each chunk is sent as a separate event.
+  Future<void> sendConstructsEvent(
     List<OneConstructUse> uses,
   ) async {
-    final ConstructAnalyticsModel constructsModel = ConstructAnalyticsModel(
+    // these events can get big, so we chunk them to prevent hitting the max event size.
-      uses: uses,
+    // go through each of the uses being sent and add them to the current chunk until
-    );
+    // the size (in bytes) of the current chunk is greater than the max event size, then
+    // start a new chunk until all uses have been added.
+    final List<List<OneConstructUse>> useChunks = [];
+    List<OneConstructUse> currentChunk = [];
+    int currentChunkSize = 0;
 
-    final String? eventId = await sendEvent(
+    for (final use in uses) {
-      constructsModel.toJson(),
+      // get the size, in bytes, of the json representation of the use
-      type: PangeaEventTypes.construct,
+      final json = use.toJson();
-    );
+      final jsonString = jsonEncode(json);
-    return eventId;
+      final jsonSizeInBytes = utf8.encode(jsonString).length;
+
+      // If this use would tip this chunk over the size limit,
+      // add it to the list of all chunks and start a new chunk.
+      //
+      // I tested with using the maxPDUSize constant, but the events
+      // were still too large. 50000 seems to be a safe number of bytes.
+      if (currentChunkSize + jsonSizeInBytes > (maxPDUSize - 10000)) {
+        useChunks.add(currentChunk);
+        currentChunk = [];
+        currentChunkSize = 0;
+      }
+
+      // add this use to the current chunk
+      currentChunk.add(use);
+      currentChunkSize += jsonSizeInBytes;
+    }
+
+    if (currentChunk.isNotEmpty) {
+      useChunks.add(currentChunk);
+    }
+
+    for (final chunk in useChunks) {
+      final constructsModel = ConstructAnalyticsModel(uses: chunk);
+      await sendEvent(
+        constructsModel.toJson(),
+        type: PangeaEventTypes.construct,
+      );
+    }
   }
 }