Refactor Spotify service

Author: Mx-Iris

.gitignore

@@ -4,3 +4,5 @@ Sources/LyricsService/.DS_Store
 Sources/.DS_Store
 .DS_Store
 Package.resolved
+.claude
+.build

Sources/LyricsService/Provider/AuthenticationManager.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+public protocol AuthenticationManager: Sendable {
+    func isAuthenticated() async -> Bool
+    func authenticate() async throws
+    func getCredentials() async throws -> [String: String]
+}
+
+public enum AuthenticationError: Error {
+    case notAuthenticated
+    case credentialsNotFound
+    case authenticationFailed(Error)
+}

Sources/LyricsService/Provider/Group.swift

@@ -9,6 +9,10 @@ extension LyricsProviders {
             self.providers = service.map { $0.create() }
         }
 
+        public init(providers: [LyricsProvider]) {
+            self.providers = providers
+        }
+
         public func lyrics(for request: LyricsSearchRequest) -> AsyncThrowingStream<Lyrics, Error> {
             return AsyncThrowingStream { continuation in
                 Task {

Sources/LyricsService/Provider/Service.swift

@@ -1,12 +1,12 @@
 import Foundation
 
 extension LyricsProviders {
-    public enum Service {
+    public enum Service: CaseIterable, Equatable, Hashable {
         case qq
         case netease
         case kugou
         case lrclib
-        case spotify(searchAccessToken: String, lyricsAccessToken: String)
+        case spotify
 
         public var displayName: String {
             switch self {
@@ -18,6 +18,18 @@ extension LyricsProviders {
             }
         }
 
+        public var requiresAuthentication: Bool {
+            switch self {
+            case .spotify:
+                return true
+            case .qq,
+                 .netease,
+                 .kugou,
+                 .lrclib:
+                return false
+            }
+        }
+
         public static var noAuthenticationRequiredServices: [Service] {
             [
                 .qq,
@@ -26,18 +38,40 @@ extension LyricsProviders {
                 .lrclib,
             ]
         }
+
+        public static var authenticationRequiredServices: [Service] {
+            [
+                .spotify,
+            ]
+        }
     }
 }
 
 extension LyricsProviders.Service {
-    func create() -> LyricsProvider {
+    public func create() -> LyricsProvider {
         switch self {
         case .netease: return LyricsProviders.NetEase()
         case .qq: return LyricsProviders.QQMusic()
         case .kugou: return LyricsProviders.Kugou()
-        case .spotify(let searchAccessToken, let lyricsAccessToken): return LyricsProviders.Spotify(searchAccessToken: searchAccessToken, lyricsAccessToken: lyricsAccessToken)
+        case .spotify: return LyricsProviders.Spotify()
         case .lrclib: return LyricsProviders.LRCLIB()
-//        default:        return LyricsProviders.Unsupported()
+        }
+    }
+
+    public func create(with authManager: AuthenticationManager?) async throws -> LyricsProvider {
+        switch self {
+        case .spotify:
+            guard let authManager = authManager else {
+                throw AuthenticationError.notAuthenticated
+            }
+            let provider = LyricsProviders.Spotify()
+            provider.authenticationManager = authManager
+            return provider
+        case .netease,
+             .qq,
+             .kugou,
+             .lrclib:
+            return create()
         }
     }
 }

Sources/LyricsService/Provider/Services/Spotify.swift

@@ -4,13 +4,26 @@ import LyricsCore
 
 extension LyricsProviders {
     public final class Spotify {
-        let searchAccessToken: String
+        var authenticationManager: AuthenticationManager?
 
-        let lyricsAccessToken: String
+        init() {}
 
-        init(searchAccessToken: String, lyricsAccessToken: String) {
-            self.searchAccessToken = searchAccessToken
-            self.lyricsAccessToken = lyricsAccessToken
+        private func getAccessTokens() async throws -> (search: String, lyrics: String) {
+            guard let authManager = authenticationManager else {
+                throw AuthenticationError.notAuthenticated
+            }
+
+            if !(await authManager.isAuthenticated()) {
+                try await authManager.authenticate()
+            }
+
+            let credentials = try await authManager.getCredentials()
+            guard let searchToken = credentials["searchAccessToken"],
+                  let lyricsToken = credentials["lyricsAccessToken"] else {
+                throw AuthenticationError.credentialsNotFound
+            }
+
+            return (search: searchToken, lyrics: lyricsToken)
         }
     }
 }
@@ -23,6 +36,8 @@ extension LyricsProviders.Spotify: _LyricsProvider {
     public static let service: String = "Spotify"
 
     public func search(for request: LyricsSearchRequest) async throws -> [LyricsToken] {
+        let tokens = try await getAccessTokens()
+
         let url: URL
         switch request.searchTerm {
         case .keyword(let string):
@@ -35,7 +50,7 @@ extension LyricsProviders.Spotify: _LyricsProvider {
 
         var req = URLRequest(url: url)
         req.addValue("WebPlayer", forHTTPHeaderField: "app-platform")
-        req.addValue("Bearer \(searchAccessToken)", forHTTPHeaderField: "Authorization")
+        req.addValue("Bearer \(tokens.search)", forHTTPHeaderField: "Authorization")
 
         do {
             let (data, _) = try await URLSession.shared.data(for: req)
@@ -50,14 +65,15 @@ extension LyricsProviders.Spotify: _LyricsProvider {
     }
 
     public func fetch(with token: LyricsToken) async throws -> Lyrics {
+        let tokens = try await getAccessTokens()
         let token = token.value
         guard let url = URL(string: "https://spclient.wg.spotify.com/color-lyrics/v2/track/\(token.id)?format=json&vocalRemoval=false&market=from_token") else {
             throw LyricsProviderError.invalidURL(urlString: "Spotify fetch URL")
         }
 
         var request = URLRequest(url: url)
         request.addValue("WebPlayer", forHTTPHeaderField: "app-platform")
-        request.addValue("Bearer \(lyricsAccessToken)", forHTTPHeaderField: "Authorization")
+        request.addValue("Bearer \(tokens.lyrics)", forHTTPHeaderField: "Authorization")
 
         let singleLyricsResponse: SpotifyResponseSingleLyrics
         do {

Sources/LyricsServiceUI/Controller/SpotifyLoginManager.swift

@@ -1,6 +1,7 @@
 import AppKit
 import WebKit
 import Schedule
+import LyricsService
 
 private typealias Task = _Concurrency.Task
 private typealias ScheduleTask = Schedule.Task
@@ -152,3 +153,25 @@ public final class SpotifyLoginManager: NSObject, @unchecked Sendable {
         }
     }
 }
+
+extension SpotifyLoginManager: AuthenticationManager {
+    public func isAuthenticated() async -> Bool {
+        return await isAccessible
+    }
+
+    public func authenticate() async throws {
+        try await login()
+    }
+
+    public func getCredentials() async throws -> [String: String] {
+        guard let searchToken = await searchAccessTokenString,
+              let lyricsToken = await lyricsAccessTokenString else {
+            throw AuthenticationError.credentialsNotFound
+        }
+
+        return [
+            "searchAccessToken": searchToken,
+            "lyricsAccessToken": lyricsToken
+        ]
+    }
+}