feat: import Chinese-localized Buzz source snapshot

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

mobile/lib/shared/community/community.dart

@@ -0,0 +1,85 @@
+import 'package:uuid/uuid.dart';
+
+const _uuid = Uuid();
+const _sentinel = Object();
+
+class Community {
+  final String id;
+  final String name;
+  final String relayUrl;
+  final String? pubkey;
+  final String? nsec;
+  final DateTime addedAt;
+
+  const Community({
+    required this.id,
+    required this.name,
+    required this.relayUrl,
+    this.pubkey,
+    this.nsec,
+    required this.addedAt,
+  });
+
+  factory Community.create({
+    required String name,
+    required String relayUrl,
+    String? pubkey,
+    String? nsec,
+  }) {
+    return Community(
+      id: _uuid.v4(),
+      name: name,
+      relayUrl: relayUrl,
+      pubkey: pubkey,
+      nsec: nsec,
+      addedAt: DateTime.now(),
+    );
+  }
+
+  Community copyWith({
+    String? name,
+    String? relayUrl,
+    Object? pubkey = _sentinel,
+    Object? nsec = _sentinel,
+  }) {
+    return Community(
+      id: id,
+      name: name ?? this.name,
+      relayUrl: relayUrl ?? this.relayUrl,
+      pubkey: pubkey == _sentinel ? this.pubkey : pubkey as String?,
+      nsec: nsec == _sentinel ? this.nsec : nsec as String?,
+      addedAt: addedAt,
+    );
+  }
+
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'name': name,
+    'relayUrl': relayUrl,
+    if (pubkey != null) 'pubkey': pubkey,
+    if (nsec != null) 'nsec': nsec,
+    'addedAt': addedAt.toIso8601String(),
+  };
+
+  factory Community.fromJson(Map<String, dynamic> json) => Community(
+    id: json['id'] as String,
+    name: json['name'] as String,
+    relayUrl: json['relayUrl'] as String,
+    pubkey: json['pubkey'] as String?,
+    nsec: json['nsec'] as String?,
+    addedAt: DateTime.parse(json['addedAt'] as String),
+  );
+
+  /// Derive a human-friendly community name from a relay URL.
+  static String nameFromUrl(String url) {
+    try {
+      final host = Uri.parse(url).host;
+      if (host.contains('localhost') || host == '127.0.0.1') return 'Local Dev';
+      final parts = host.split('.');
+      if (parts.length > 2) return parts.first;
+      return host;
+    } catch (_) {
+      return 'Community';
+    }
+  }
+}

mobile/lib/shared/community/community_icon_provider.dart

@@ -0,0 +1,59 @@
+import 'dart:convert';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:http/http.dart' as http;
+
+/// Supplies the HTTP client used for NIP-11 community icon lookups.
+///
+/// Tests can override this provider to return deterministic relay responses.
+final communityIconHttpClientProvider = Provider<http.Client>((ref) {
+  final client = http.Client();
+  ref.onDispose(client.close);
+  return client;
+});
+
+/// Reads a community's icon from its public NIP-11 relay information document.
+///
+/// The lookup does not depend on the active relay session, so icons can render
+/// for every paired community in the switcher. Callers explicitly invalidate
+/// this family when opening the switcher so transient failures and relay
+/// metadata updates can be retried without background polling.
+final communityIconProvider = FutureProvider.autoDispose
+    .family<String?, String>((ref, relayUrl) async {
+      final uri = _relayInfoUri(relayUrl);
+      if (uri == null) return null;
+
+      try {
+        final response = await ref
+            .read(communityIconHttpClientProvider)
+            .get(uri, headers: const {'Accept': 'application/nostr+json'})
+            .timeout(const Duration(seconds: 5));
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+          return null;
+        }
+
+        final document = jsonDecode(response.body);
+        if (document is! Map<String, dynamic>) return null;
+
+        final icon = document['icon'];
+        if (icon is! String || icon.trim().isEmpty) return null;
+        return icon.trim();
+      } catch (_) {
+        return null;
+      }
+    });
+
+Uri? _relayInfoUri(String relayUrl) {
+  try {
+    final uri = Uri.parse(relayUrl.trim());
+    final scheme = switch (uri.scheme) {
+      'wss' => 'https',
+      'ws' => 'http',
+      'https' || 'http' => uri.scheme,
+      _ => null,
+    };
+    return scheme == null ? null : uri.replace(scheme: scheme);
+  } on FormatException {
+    return null;
+  }
+}

mobile/lib/shared/community/community_provider.dart

@@ -0,0 +1,127 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+import '../auth/auth_provider.dart';
+import 'community.dart';
+import 'community_storage.dart';
+
+final communityStorageProvider = Provider<CommunityStorage>((ref) {
+  return CommunityStorage();
+});
+
+class CommunityListNotifier extends AsyncNotifier<List<Community>> {
+  @override
+  Future<List<Community>> build() async {
+    final storage = ref.read(communityStorageProvider);
+    return storage.loadAll();
+  }
+
+  /// Add a community. If one with the same relay URL already exists, update
+  /// its credentials instead. Returns the effective community ID.
+  Future<String> addCommunity(Community community) async {
+    final storage = ref.read(communityStorageProvider);
+    final current = state.value ?? [];
+
+    // If a community with the same relay URL exists, update its credentials
+    // instead of creating a duplicate entry.
+    final existingIndex = current.indexWhere(
+      (w) => w.relayUrl == community.relayUrl,
+    );
+    if (existingIndex >= 0) {
+      final existing = current[existingIndex];
+      final updated = existing.copyWith(
+        pubkey: community.pubkey,
+        nsec: community.nsec,
+      );
+      await storage.save(updated);
+      final updatedList = [...current];
+      updatedList[existingIndex] = updated;
+      state = AsyncData(updatedList);
+      return existing.id;
+    }
+
+    await storage.save(community);
+    state = AsyncData([...current, community]);
+    return community.id;
+  }
+
+  Future<void> removeCommunity(String id) async {
+    final storage = ref.read(communityStorageProvider);
+    await storage.remove(id);
+
+    final current = state.value ?? [];
+    state = AsyncData(current.where((w) => w.id != id).toList());
+
+    // If we removed the active community, switch to another or sign out.
+    final activeId = await storage.loadActiveId();
+    if (activeId == id) {
+      final remaining = state.value ?? [];
+      if (remaining.isNotEmpty) {
+        await switchCommunity(remaining.first.id);
+      } else {
+        await storage.clearActiveId();
+        // Invalidate auth so it re-evaluates against the now-empty storage
+        // and transitions to unauthenticated.
+        ref.invalidate(authProvider);
+      }
+    }
+  }
+
+  Future<void> switchCommunity(String id) async {
+    final storage = ref.read(communityStorageProvider);
+    await storage.saveActiveId(id);
+    // Reassign list state to trigger activeCommunityProvider (which watches
+    // communityListProvider.future) to rebuild and pick up the new active ID.
+    // We can't use ref.invalidate(activeCommunityProvider) here because that
+    // creates a circular dependency — activeCommunityProvider watches us.
+    state = AsyncData([...state.value ?? []]);
+    // Invalidate auth so AuthState.community reflects the new active community.
+    ref.invalidate(authProvider);
+  }
+
+  Future<void> renameCommunity(String id, String name) async {
+    final storage = ref.read(communityStorageProvider);
+    final current = state.value ?? [];
+    final index = current.indexWhere((w) => w.id == id);
+    if (index < 0) return;
+
+    final updated = current[index].copyWith(name: name);
+    await storage.save(updated);
+
+    final updatedList = [...current];
+    updatedList[index] = updated;
+    state = AsyncData(updatedList);
+  }
+}
+
+final communityListProvider =
+    AsyncNotifierProvider<CommunityListNotifier, List<Community>>(
+      CommunityListNotifier.new,
+    );
+
+/// The currently active community, derived from the stored active ID and
+/// the community list.
+final activeCommunityProvider = FutureProvider<Community?>((ref) async {
+  final communities = await ref.watch(communityListProvider.future);
+  final storage = ref.read(communityStorageProvider);
+  final activeId = await storage.loadActiveId();
+
+  if (communities.isEmpty) return null;
+
+  if (activeId == null) {
+    // No active ID stored but communities exist — fall back to first.
+    await storage.saveActiveId(communities.first.id);
+    return communities.first;
+  }
+
+  try {
+    return communities.firstWhere((w) => w.id == activeId);
+  } on StateError {
+    // Active ID points to a community that no longer exists.
+    // Fall back to first community.
+    if (communities.isNotEmpty) {
+      await storage.saveActiveId(communities.first.id);
+      return communities.first;
+    }
+    return null;
+  }
+});

mobile/lib/shared/community/community_storage.dart

@@ -0,0 +1,111 @@
+import 'dart:convert';
+
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+
+import 'community.dart';
+
+class CommunityStorage {
+  static const _keyCommunities = 'buzz_communities';
+  static const _keyActiveId = 'buzz_active_community_id';
+
+  // Legacy keys for migration.
+  static const _legacyCommunities = 'buzz_workspaces';
+  static const _legacyActiveId = 'buzz_active_workspace_id';
+  static const _legacyRelayUrl = 'buzz_relay_url';
+  static const _legacyToken = 'buzz_token';
+  static const _legacyPubkey = 'buzz_pubkey';
+  static const _legacyNsec = 'buzz_nsec';
+
+  final FlutterSecureStorage _secure;
+
+  CommunityStorage({FlutterSecureStorage? secure})
+    : _secure = secure ?? const FlutterSecureStorage();
+
+  /// Load all communities. On first call, migrates legacy single-community
+  /// credentials if present.
+  Future<List<Community>> loadAll() async {
+    final raw = await _secure.read(key: _keyCommunities);
+    if (raw != null) return _decodeList(raw);
+
+    final legacyCommunities = await _secure.read(key: _legacyCommunities);
+    if (legacyCommunities != null) {
+      final communities = _decodeList(legacyCommunities);
+      await _saveList(communities);
+      final legacyActiveId = await _secure.read(key: _legacyActiveId);
+      if (legacyActiveId != null) await saveActiveId(legacyActiveId);
+      await _secure.delete(key: _legacyCommunities);
+      await _secure.delete(key: _legacyActiveId);
+      return communities;
+    }
+
+    // Migration: check for legacy single-community keys.
+    final legacyUrl = await _secure.read(key: _legacyRelayUrl);
+    final legacyToken = await _secure.read(key: _legacyToken);
+    if (legacyUrl != null && legacyToken != null) {
+      final legacyPubkey = await _secure.read(key: _legacyPubkey);
+      final legacyNsec = await _secure.read(key: _legacyNsec);
+
+      final name = Community.nameFromUrl(legacyUrl);
+      final community = Community.create(
+        name: name,
+        relayUrl: legacyUrl,
+        pubkey: legacyPubkey,
+        nsec: legacyNsec,
+      );
+
+      await _saveList([community]);
+      await saveActiveId(community.id);
+
+      // Delete legacy keys.
+      await _secure.delete(key: _legacyRelayUrl);
+      await _secure.delete(key: _legacyToken);
+      await _secure.delete(key: _legacyPubkey);
+      await _secure.delete(key: _legacyNsec);
+
+      return [community];
+    }
+
+    return [];
+  }
+
+  Future<void> save(Community community) async {
+    final all = await loadAll();
+    final index = all.indexWhere((w) => w.id == community.id);
+    if (index >= 0) {
+      all[index] = community;
+    } else {
+      all.add(community);
+    }
+    await _saveList(all);
+  }
+
+  Future<void> remove(String id) async {
+    final all = await loadAll();
+    all.removeWhere((w) => w.id == id);
+    await _saveList(all);
+  }
+
+  Future<String?> loadActiveId() async {
+    return _secure.read(key: _keyActiveId);
+  }
+
+  Future<void> saveActiveId(String id) async {
+    await _secure.write(key: _keyActiveId, value: id);
+  }
+
+  Future<void> clearActiveId() async {
+    await _secure.delete(key: _keyActiveId);
+  }
+
+  List<Community> _decodeList(String raw) {
+    final list = jsonDecode(raw) as List<dynamic>;
+    return list
+        .map((entry) => Community.fromJson(entry as Map<String, dynamic>))
+        .toList();
+  }
+
+  Future<void> _saveList(List<Community> communities) async {
+    final json = jsonEncode(communities.map((item) => item.toJson()).toList());
+    await _secure.write(key: _keyCommunities, value: json);
+  }
+}