feat: import Chinese-localized Buzz source snapshot

Signed-off-by: cls_宁波本机 <908705107@qq.com>

mobile/lib/features/channels/unread_badge/is_high_priority_event.dart

@@ -0,0 +1,14 @@
+bool isHighPriorityEvent(List<List<String>> tags, String currentPubkey) {
+  final normalizedPubkey = currentPubkey.toLowerCase();
+  for (final tag in tags) {
+    if (tag.length >= 2 &&
+        tag[0] == 'p' &&
+        tag[1].toLowerCase() == normalizedPubkey) {
+      return true;
+    }
+    if (tag.length >= 2 && tag[0] == 'broadcast' && tag[1] == '1') {
+      return true;
+    }
+  }
+  return false;
+}

mobile/lib/features/channels/unread_badge/observed_unread_event.dart

@@ -0,0 +1,133 @@
+import '../../../shared/read_state/read_state_format.dart';
+
+class ObservedUnreadEvent {
+  final String id;
+  final int createdAt;
+  final String? rootId;
+  final bool highPriority;
+  final bool countsTowardBadge;
+  final bool countsTowardAppBadge;
+
+  const ObservedUnreadEvent({
+    required this.id,
+    required this.createdAt,
+    required this.rootId,
+    required this.highPriority,
+    required this.countsTowardBadge,
+    required this.countsTowardAppBadge,
+  });
+}
+
+ObservedUnreadEvent makeObservedUnreadEvent({
+  required String id,
+  required int createdAt,
+  required String? rootId,
+  required bool highPriority,
+  required String? channelType,
+  required bool isThreadedReply,
+}) {
+  final isDm = channelType == 'dm';
+  return ObservedUnreadEvent(
+    id: id,
+    createdAt: createdAt,
+    rootId: rootId,
+    highPriority: highPriority,
+    countsTowardBadge: isDm || isThreadedReply || highPriority,
+    countsTowardAppBadge: isDm || (!isThreadedReply && highPriority),
+  );
+}
+
+bool recordObservedUnreadEvent(
+  Map<String, Map<String, ObservedUnreadEvent>> eventsByChannel,
+  String channelId,
+  ObservedUnreadEvent event,
+  int limit,
+) {
+  final eventsById = eventsByChannel.putIfAbsent(channelId, () => {});
+  if (eventsById.containsKey(event.id)) return false;
+
+  eventsById[event.id] = event;
+  if (eventsById.length <= limit) return true;
+
+  String? oldestId;
+  int? oldestCreatedAt;
+  for (final event in eventsById.values) {
+    if (oldestCreatedAt == null || event.createdAt < oldestCreatedAt) {
+      oldestCreatedAt = event.createdAt;
+      oldestId = event.id;
+    }
+  }
+  if (oldestId != null) {
+    eventsById.remove(oldestId);
+  }
+  return true;
+}
+
+int countUnreadObservedEvents(
+  Map<String, ObservedUnreadEvent>? eventsById,
+  int? Function(ObservedUnreadEvent event) getReadAt,
+) {
+  if (eventsById == null) return 0;
+  var count = 0;
+  for (final event in eventsById.values) {
+    final readAt = getReadAt(event);
+    if (readAt == null || event.createdAt > readAt) count++;
+  }
+  return count;
+}
+
+int countUnreadBadgeObservedEvents(
+  Map<String, ObservedUnreadEvent>? eventsById,
+  int? Function(ObservedUnreadEvent event) getReadAt,
+) {
+  if (eventsById == null) return 0;
+  var count = 0;
+  for (final event in eventsById.values) {
+    if (!event.countsTowardBadge) continue;
+    final readAt = getReadAt(event);
+    if (readAt == null || event.createdAt > readAt) count++;
+  }
+  return count;
+}
+
+int countUnreadAppBadgeObservedEvents(
+  Map<String, ObservedUnreadEvent>? eventsById,
+  int? Function(ObservedUnreadEvent event) getReadAt,
+) {
+  if (eventsById == null) return 0;
+  var count = 0;
+  for (final event in eventsById.values) {
+    if (!event.countsTowardAppBadge) continue;
+    final readAt = getReadAt(event);
+    if (readAt == null || event.createdAt > readAt) count++;
+  }
+  return count;
+}
+
+int countUnreadHighPriorityObservedEvents(
+  Map<String, ObservedUnreadEvent>? eventsById,
+  int? Function(ObservedUnreadEvent event) getReadAt,
+) {
+  if (eventsById == null) return 0;
+  var count = 0;
+  for (final event in eventsById.values) {
+    if (!event.highPriority) continue;
+    final readAt = getReadAt(event);
+    if (readAt == null || event.createdAt > readAt) count++;
+  }
+  return count;
+}
+
+int? observedUnreadEventReadAt(
+  ObservedUnreadEvent event,
+  int? channelReadAt,
+  int? Function(String rootId) getThreadOwnMarker,
+  int? Function(String messageId) getMessageOwnMarker,
+) {
+  final markers = <int?>[channelReadAt, getMessageOwnMarker(event.id)];
+  final rootId = event.rootId;
+  if (rootId != null) {
+    markers.add(getThreadOwnMarker(rootId));
+  }
+  return maxReadAt(markers);
+}

mobile/lib/features/channels/unread_badge/should_notify_for_event.dart

@@ -0,0 +1,50 @@
+import '../../../shared/relay/nostr_models.dart';
+
+bool shouldNotifyForEvent(
+  NostrEvent event,
+  String myPubkey, {
+  Set<String> participatedRootIds = const {},
+  Set<String> followedRootIds = const {},
+  Set<String> authoredRootIds = const {},
+  Set<String> mutedRootIds = const {},
+  Set<String> mutedChannelIds = const {},
+  String? channelId,
+}) {
+  if (!EventKind.channelMessageEventKinds.contains(event.kind)) return false;
+
+  if (event.pubkey.toLowerCase() == myPubkey.toLowerCase()) return false;
+
+  final ref = event.threadReference;
+
+  for (final tag in event.tags) {
+    if (tag.length >= 2 && tag[0] == 'broadcast' && tag[1] == '1') {
+      return true;
+    }
+  }
+
+  final normalizedPk = myPubkey.toLowerCase();
+  for (final tag in event.tags) {
+    if (tag.length >= 2 &&
+        tag[0] == 'p' &&
+        tag[1].toLowerCase() == normalizedPk) {
+      return true;
+    }
+  }
+
+  final eventChannelId = channelId ?? event.channelId;
+  if (eventChannelId != null && mutedChannelIds.contains(eventChannelId)) {
+    return false;
+  }
+
+  if (ref.parentId == null) return true;
+
+  final rootId = ref.rootId;
+  if (rootId != null && mutedRootIds.contains(rootId)) {
+    return false;
+  }
+
+  return rootId != null &&
+      (participatedRootIds.contains(rootId) ||
+          followedRootIds.contains(rootId) ||
+          authoredRootIds.contains(rootId));
+}

mobile/lib/features/channels/unread_badge/unread_badge_provider.dart

@@ -0,0 +1,87 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+import '../channels_provider.dart';
+import '../../../shared/read_state/read_state_provider.dart';
+import '../../../shared/read_state/read_state_format.dart';
+import 'observed_unread_event.dart';
+
+class UnreadBadgeState {
+  const UnreadBadgeState({
+    this.highPriorityCount = 0,
+    this.generalUnreadCount = 0,
+  });
+
+  final int highPriorityCount;
+  final int generalUnreadCount;
+}
+
+final unreadBadgeProvider = Provider<UnreadBadgeState>((ref) {
+  final channelsAsync = ref.watch(channelsProvider);
+  final readState = ref.watch(readStateProvider);
+
+  return channelsAsync.when(
+    data: (channels) {
+      final notifier = ref.read(channelsProvider.notifier);
+      final observedEventsByChannel = notifier.observedUnreadEventsByChannel;
+      final latestObservedByChannel = notifier.latestObservedByChannel;
+
+      var highPriority = 0;
+      var general = 0;
+
+      for (final channel in channels) {
+        if (!channel.isMember || channel.isArchived) continue;
+
+        if (readState.locallyForcedChannelIds.contains(channel.id)) {
+          general++;
+          continue;
+        }
+
+        if (!latestObservedByChannel.containsKey(channel.id)) continue;
+
+        final observedEvents = observedEventsByChannel[channel.id];
+        final channelReadAt = readState.effectiveTimestamp(channel.id);
+        int? readAtForObservedEvent(ObservedUnreadEvent event) =>
+            observedUnreadEventReadAt(
+              event,
+              channelReadAt,
+              (rootId) =>
+                  readState.effectiveTimestamp(threadContextKey(rootId)),
+              (messageId) =>
+                  readState.effectiveTimestamp(msgContextKey(messageId)),
+            );
+
+        final unreadCount = countUnreadObservedEvents(
+          observedEvents,
+          readAtForObservedEvent,
+        );
+        if (unreadCount == 0) continue;
+
+        if (channel.isDm ||
+            countUnreadHighPriorityObservedEvents(
+                  observedEvents,
+                  readAtForObservedEvent,
+                ) >
+                0) {
+          final appBadgeCount = countUnreadAppBadgeObservedEvents(
+            observedEvents,
+            readAtForObservedEvent,
+          );
+          highPriority += appBadgeCount > 0 ? appBadgeCount : 1;
+        } else {
+          final badgeCount = countUnreadBadgeObservedEvents(
+            observedEvents,
+            readAtForObservedEvent,
+          );
+          general += badgeCount > 0 ? badgeCount : 1;
+        }
+      }
+
+      return UnreadBadgeState(
+        highPriorityCount: highPriority,
+        generalUnreadCount: general,
+      );
+    },
+    loading: () => const UnreadBadgeState(),
+    error: (_, _) => const UnreadBadgeState(),
+  );
+});