feat: import Chinese-localized Buzz source snapshot

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

mobile/lib/features/profile/user_status_cache_provider.dart

@@ -0,0 +1,180 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+import '../../shared/relay/relay.dart';
+import 'user_status.dart';
+
+/// In-memory cache of other users' NIP-38 statuses (kind:30315, d=general).
+///
+/// Subscribes to kind:30315 events over WebSocket for real-time updates.
+/// Falls back to a 120-second backstop refresh via fetchHistory.
+class UserStatusCacheNotifier extends Notifier<Map<String, UserStatus?>> {
+  static const _refreshInterval = Duration(seconds: 120);
+
+  final Set<String> _tracked = {};
+  final Set<String> _pending = {};
+  Timer? _batchTimer;
+  Timer? _refreshTimer;
+  void Function()? _statusUnsub;
+  int _subscriptionVersion = 0;
+
+  @override
+  Map<String, UserStatus?> build() {
+    ref.watch(relayClientProvider);
+    final sessionState = ref.watch(relaySessionProvider);
+
+    ref.onDispose(() {
+      _batchTimer?.cancel();
+      _batchTimer = null;
+      _refreshTimer?.cancel();
+      _refreshTimer = null;
+      _statusUnsub?.call();
+      _statusUnsub = null;
+    });
+
+    if (sessionState.status == SessionStatus.connected) {
+      _subscribeStatusUpdates();
+    }
+
+    return {};
+  }
+
+  /// Track status for [pubkeys]. Fetches immediately if not cached,
+  /// and includes them in periodic refreshes.
+  void track(List<String> pubkeys) {
+    final normalized = pubkeys.map((pk) => pk.toLowerCase()).toList();
+    final uncached = normalized
+        .where((pk) => !state.containsKey(pk) && !_pending.contains(pk))
+        .toList();
+
+    _tracked.addAll(normalized);
+    _ensureRefreshTimer();
+
+    if (uncached.isEmpty) return;
+    _pending.addAll(uncached);
+    _batchTimer ??= Timer(const Duration(milliseconds: 50), _flushPending);
+  }
+
+  void _ensureRefreshTimer() {
+    _refreshTimer ??= Timer.periodic(_refreshInterval, (_) => _refreshAll());
+  }
+
+  Future<void> _subscribeStatusUpdates() async {
+    _statusUnsub?.call();
+    _statusUnsub = null;
+    _subscriptionVersion++;
+    final version = _subscriptionVersion;
+
+    final session = ref.read(relaySessionProvider.notifier);
+    try {
+      final unsub = await session.subscribe(
+        const NostrFilter(
+          kinds: [EventKind.userStatus],
+          tags: {
+            '#d': ['general'],
+          },
+          limit: 0,
+        ),
+        _handleStatusEvent,
+      );
+      if (version != _subscriptionVersion) {
+        unsub();
+        return;
+      }
+      _statusUnsub = unsub;
+    } catch (error) {
+      debugPrint(
+        '[UserStatusCacheNotifier] status subscription failed: $error',
+      );
+    }
+  }
+
+  void _handleStatusEvent(NostrEvent event) {
+    // Defense-in-depth: guard d-tag even though filter includes it.
+    if (event.getTagValue('d') != 'general') return;
+
+    final pubkey = event.pubkey.toLowerCase();
+    if (!_tracked.contains(pubkey)) return;
+
+    final parsed = UserStatus.fromEvent(event);
+    final existing = state[pubkey];
+
+    // Staleness guard: discard if we already have a newer-or-equal event.
+    if (existing != null && existing.updatedAt >= parsed.updatedAt) return;
+
+    final status = parsed.isEmpty ? null : parsed;
+    final updated = Map<String, UserStatus?>.from(state);
+    updated[pubkey] = status;
+    state = updated;
+  }
+
+  /// Directly update a pubkey's cached status. Used by [UserStatusNotifier]
+  /// for optimistic updates after publishing.
+  void updateStatus(String pubkey, UserStatus? status) {
+    final pk = pubkey.toLowerCase();
+    final updated = Map<String, UserStatus?>.from(state);
+    updated[pk] = status;
+    state = updated;
+  }
+
+  Future<void> _refreshAll() async {
+    if (_tracked.isEmpty) return;
+    await _fetchStatuses(_tracked.toList());
+  }
+
+  Future<void> _flushPending() async {
+    _batchTimer = null;
+    if (_pending.isEmpty) return;
+
+    final pubkeys = _pending.toList();
+    _pending.clear();
+    await _fetchStatuses(pubkeys);
+  }
+
+  Future<void> _fetchStatuses(List<String> pubkeys) async {
+    try {
+      final session = ref.read(relaySessionProvider.notifier);
+      final events = await session.fetchHistory(
+        NostrFilter(
+          kinds: const [EventKind.userStatus],
+          authors: pubkeys,
+          tags: const {
+            '#d': ['general'],
+          },
+          limit: pubkeys.length,
+        ),
+      );
+
+      final updated = Map<String, UserStatus?>.from(state);
+
+      // Initialise requested pubkeys that had no events to null (cleared).
+      for (final pk in pubkeys) {
+        if (!updated.containsKey(pk)) {
+          updated[pk] = null;
+        }
+      }
+
+      for (final event in events) {
+        if (event.getTagValue('d') != 'general') continue;
+        final pk = event.pubkey.toLowerCase();
+        final parsed = UserStatus.fromEvent(event);
+        final existing = updated[pk];
+        if (existing != null && existing.updatedAt >= parsed.updatedAt) {
+          continue;
+        }
+        updated[pk] = parsed.isEmpty ? null : parsed;
+      }
+
+      state = updated;
+    } catch (_) {
+      // Silently fail — backstop will retry.
+    }
+  }
+}
+
+final userStatusCacheProvider =
+    NotifierProvider<UserStatusCacheNotifier, Map<String, UserStatus?>>(
+      UserStatusCacheNotifier.new,
+    );