updates

lib/subsonic/credentials.dart

@@ -1,7 +1,10 @@
+import 'dart:convert';
+
+import 'package:crypto/crypto.dart';
 import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 
 /// A Subsonic server connection. The password is only ever held in memory and
-/// in the platform secure store — never in plain app storage (mirrors Ratune's
+/// in the platform secure store — never in plain app storage (mirrors Timbre's
 /// keyring-first secret handling).
 class SubsonicCredentials {
   const SubsonicCredentials({
@@ -15,50 +18,121 @@ class SubsonicCredentials {
   final String username;
   final String password;
 
-  /// Optional display label shown instead of the raw URL (Ratune `[server].alias`).
+  /// Optional display label shown instead of the raw URL (Timbre `[server].alias`).
   final String? alias;
 
   String get display => alias?.isNotEmpty == true ? alias! : Uri.parse(url).host;
+
+  /// Stable identity for a saved server: `md5(baseUrl|username)`, matching the
+  /// cache key in `serverKeyProvider` so per-server data lines up. Two entries
+  /// with the same URL + username are the "same" server (different password /
+  /// alias overwrites it).
+  String get id {
+    final base = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
+    return md5.convert(utf8.encode('$base|$username')).toString();
+  }
+
+  Map<String, dynamic> toJson() => {
+        'url': url,
+        'username': username,
+        'password': password,
+        if (alias != null && alias!.isNotEmpty) 'alias': alias,
+      };
+
+  factory SubsonicCredentials.fromJson(Map<String, dynamic> j) {
+    final alias = j['alias'] as String?;
+    return SubsonicCredentials(
+      url: j['url'] as String? ?? '',
+      username: j['username'] as String? ?? '',
+      password: j['password'] as String? ?? '',
+      alias: (alias == null || alias.isEmpty) ? null : alias,
+    );
+  }
 }
 
-/// Persists [SubsonicCredentials] to the platform secure store
-/// (Keychain / Keystore / libsecret).
+/// Persists a *list* of [SubsonicCredentials] plus a pointer to the active one
+/// to the platform secure store (Keychain / Keystore / libsecret). Legacy
+/// single-server installs are migrated into the list on first load.
 class CredentialStore {
   CredentialStore([FlutterSecureStorage? storage])
       : _storage = storage ?? const FlutterSecureStorage();
 
   final FlutterSecureStorage _storage;
 
+  /// JSON array of all saved servers.
+  static const _kServers = 'subsonic_servers';
+
+  /// Id ([SubsonicCredentials.id]) of the active server.
+  static const _kActive = 'subsonic_active';
+
+  // Legacy single-server keys, read once for migration then removed.
   static const _kUrl = 'subsonic_url';
   static const _kUser = 'subsonic_username';
   static const _kPass = 'subsonic_password';
   static const _kAlias = 'subsonic_alias';
 
-  Future<void> save(SubsonicCredentials creds) async {
-    await _storage.write(key: _kUrl, value: creds.url);
-    await _storage.write(key: _kUser, value: creds.username);
-    await _storage.write(key: _kPass, value: creds.password);
-    await _storage.write(key: _kAlias, value: creds.alias ?? '');
+  /// All saved servers. Empty if none configured. Migrates a legacy
+  /// single-server install into the new list format on first call.
+  Future<List<SubsonicCredentials>> loadAll() async {
+    final raw = await _storage.read(key: _kServers);
+    if (raw != null && raw.isNotEmpty) {
+      try {
+        final list = (jsonDecode(raw) as List)
+            .whereType<Map>()
+            .map((m) => SubsonicCredentials.fromJson(m.cast<String, dynamic>()))
+            .where((c) => c.url.isNotEmpty && c.username.isNotEmpty)
+            .toList();
+        return list;
+      } catch (_) {
+        return const [];
+      }
+    }
+    // Migrate a legacy single-server install, if present.
+    final migrated = await _migrateLegacy();
+    return migrated == null ? const [] : [migrated];
   }
 
-  Future<SubsonicCredentials?> load() async {
+  /// Id of the active server, or null.
+  Future<String?> loadActiveId() => _storage.read(key: _kActive);
+
+  /// Overwrite the saved list and active pointer atomically-ish (two writes).
+  Future<void> saveAll(
+      List<SubsonicCredentials> servers, String? activeId) async {
+    await _storage.write(
+      key: _kServers,
+      value: jsonEncode([for (final s in servers) s.toJson()]),
+    );
+    if (activeId == null) {
+      await _storage.delete(key: _kActive);
+    } else {
+      await _storage.write(key: _kActive, value: activeId);
+    }
+  }
+
+  Future<SubsonicCredentials?> _migrateLegacy() async {
     final url = await _storage.read(key: _kUrl);
     final user = await _storage.read(key: _kUser);
     final pass = await _storage.read(key: _kPass);
     if (url == null || user == null || pass == null) return null;
     final alias = await _storage.read(key: _kAlias);
-    return SubsonicCredentials(
+    final creds = SubsonicCredentials(
       url: url,
       username: user,
       password: pass,
       alias: (alias == null || alias.isEmpty) ? null : alias,
     );
-  }
-
-  Future<void> clear() async {
+    // Write the new format, point at it, then drop the legacy keys.
+    await saveAll([creds], creds.id);
     await _storage.delete(key: _kUrl);
     await _storage.delete(key: _kUser);
     await _storage.delete(key: _kPass);
     await _storage.delete(key: _kAlias);
+    return creds;
+  }
+
+  /// Remove all saved servers and the active pointer.
+  Future<void> clear() async {
+    await _storage.delete(key: _kServers);
+    await _storage.delete(key: _kActive);
   }
 }