Fix Spotify search feature

Author: Mx-Iris

Sources/LyricsService/JSONModel/LRCLIB/LRCLIBResponse.swift

@@ -1,3 +1,4 @@
+import Foundation
 
 public struct LRCLIBResponse: Codable {
     let id: Int

Sources/LyricsService/JSONModel/Spotify/SpotifyLyricsResponse.swift renamed to Sources/LyricsService/JSONModel/Spotify/SpotifyResponseSingleLyrics.swift

@@ -18,7 +18,6 @@ struct SpotifyResponseSingleLyrics: Codable {
         let language: String
         let isRtlLanguage: Bool
         let capStatus: String
-        let isSnippet: Bool
 
         private enum CodingKeys: String, CodingKey {
             case syncType
@@ -31,7 +30,6 @@ struct SpotifyResponseSingleLyrics: Codable {
             case language
             case isRtlLanguage
             case capStatus
-            case isSnippet
         }
     }
 

Sources/LyricsService/Provider/Service.swift

@@ -16,7 +16,7 @@ extension LyricsProviders {
         case qq
         case kugou
         case lrclib
-        case spotify(accessToken: String)
+        case spotify(searchAccessToken: String, lyricsAccessToken: String)
 
         public var displayName: String {
             switch self {
@@ -46,7 +46,7 @@ extension LyricsProviders.Service {
         case .netease:  return LyricsProviders.NetEase()
         case .qq:       return LyricsProviders.QQMusic()
         case .kugou:    return LyricsProviders.Kugou()
-        case .spotify(let accessToken): return LyricsProviders.Spotify(accessToken: accessToken)
+        case .spotify(let searchAccessToken, let lyricsAccessToken): return LyricsProviders.Spotify(searchAccessToken: searchAccessToken, lyricsAccessToken: lyricsAccessToken)
         case .lrclib:   return LyricsProviders.LRCLIB()
 //        default:        return LyricsProviders.Unsupported()
         }

Sources/LyricsService/Provider/Services/Spotify.swift

@@ -8,19 +8,14 @@ extension LyricsProviders {
     final class Spotify: _LyricsProvider {
         typealias LyricsToken = SpotifyResponseSearchResult.Track.Item
 
-        let accessToken: String
+        let searchAccessToken: String
 
-        init(accessToken: String) {
-            self.accessToken = accessToken
-        }
-
-        static let fakeSpotifyUserAgentconfig: URLSessionConfiguration = {
-            let fakeSpotifyUserAgentconfig = URLSessionConfiguration.default
-            fakeSpotifyUserAgentconfig.httpAdditionalHeaders = ["User-Agent": "Spotify/121000760 Win32/0 (PC laptop)"]
-            return fakeSpotifyUserAgentconfig
-        }()
+        let lyricsAccessToken: String
 
-        static let fakeSpotifyUserAgentSession: URLSession = .init(configuration: fakeSpotifyUserAgentconfig)
+        init(searchAccessToken: String, lyricsAccessToken: String) {
+            self.searchAccessToken = searchAccessToken
+            self.lyricsAccessToken = lyricsAccessToken
+        }
     }
 }
 
@@ -30,34 +25,45 @@ extension LyricsProviders.Spotify {
     func lyricsSearchPublisher(request: LyricsSearchRequest) -> AnyPublisher<LyricsToken, Never> {
         let url: URL
         switch request.searchTerm {
-        case let .keyword(string):
+        case .keyword(let string):
             url = URL(string: "https://api.spotify.com/v1/search?q=track:\(string)&type=track&limit=10")!
-        case let .info(title, artist):
+        case .info(let title, let artist):
             url = URL(string: "https://api.spotify.com/v1/search?q=track:\(title) artist:\(artist)&type=track&limit=10")!
         }
 
         var req = URLRequest(url: url)
         req.addValue("WebPlayer", forHTTPHeaderField: "app-platform")
-        req.addValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        req.addValue("Bearer \(searchAccessToken)", forHTTPHeaderField: "Authorization")
         return sharedURLSession.cx.dataTaskPublisher(for: req)
             .map(\.data)
             .decode(type: SpotifyResponseSearchResult.self, decoder: JSONDecoder().cx)
             .map(\.tracks.items)
             .replaceError(with: [])
             .flatMap(Publishers.Sequence.init)
-            .map { $0 as LyricsToken }
+            .map {
+                $0 as LyricsToken
+            }
             .eraseToAnyPublisher()
     }
 
     func lyricsFetchPublisher(token: LyricsToken) -> AnyPublisher<Lyrics, Never> {
-        let url = URL(string: "https://spclient.wg.spotify.com/color-lyrics/v2/track/\(token.id)?format=json&vocalRemoval=false")!
+        let url = URL(string: "https://spclient.wg.spotify.com/color-lyrics/v2/track/\(token.id)?format=json&vocalRemoval=false&market=from_token")!
         var request = URLRequest(url: url)
         request.addValue("WebPlayer", forHTTPHeaderField: "app-platform")
-        request.addValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.addValue("Bearer \(lyricsAccessToken)", forHTTPHeaderField: "Authorization")
 
-        return Self.fakeSpotifyUserAgentSession.cx.dataTaskPublisher(for: request)
+        return sharedURLSession.cx.dataTaskPublisher(for: request)
             .map(\.data)
+            .handleEvents(receiveOutput: { data in
+                if let jsonString = String(data: data, encoding: .utf8) {
+                    print("Received JSON: \(jsonString)")
+                }
+            })
             .decode(type: SpotifyResponseSingleLyrics.self, decoder: JSONDecoder().cx)
+            .catch { error -> AnyPublisher<SpotifyResponseSingleLyrics, Error> in
+                print("Decode error: \(error)")
+                return Fail(error: error).eraseToAnyPublisher()
+            }
             .map {
                 let lyrics = Lyrics(lines: $0.lyrics.lines.map {
                     LyricsLine(content: $0.words, position: (Double($0.startTimeMs) ?? 0) / 1000)

Sources/LyricsServiceUI/Controller/Keychain.swift

@@ -0,0 +1,43 @@
+import Foundation
+import KeychainAccess
+
+@propertyWrapper
+struct Keychain<T: Codable> {
+    private let keychain: KeychainAccess.Keychain
+
+    var wrappedValue: T {
+        set {
+            do {
+                keychain[data: key] = try JSONEncoder().encode(newValue)
+                _cacheWrappedValue = newValue
+            } catch {
+                print(error)
+            }
+        }
+        mutating get {
+            if let _cacheWrappedValue {
+                return _cacheWrappedValue
+            } else {
+                if let data = keychain[data: key],
+                   let value = try? JSONDecoder().decode(T.self, from: data) {
+                    _cacheWrappedValue = value
+                    return value
+                } else {
+                    return defaultValue
+                }
+            }
+        }
+    }
+
+    private var _cacheWrappedValue: T?
+
+    private let defaultValue: T
+
+    private let key: String
+
+    init(key: String, service: String, defaultValue: T) {
+        self.keychain = .init(service: service).synchronizable(true)
+        self.key = key
+        self.defaultValue = defaultValue
+    }
+}

Sources/LyricsServiceUI/Controller/SpotifyAccessToken.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+struct SpotifyAccessToken: Codable {
+    let accessToken: String
+    let accessTokenExpirationTimestampMs: TimeInterval
+    let isAnonymous: Bool
+
+    var expirationDate: Date {
+        return Date(timeIntervalSince1970: accessTokenExpirationTimestampMs / 1000)
+    }
+
+    static func searchAccessToken(forCookie cookie: String) async throws -> Self {
+        try await accessToken(forCookie: cookie, reason: "init", productType: "mobile-web-player")
+    }
+
+    static func lyricsAccessToken(forCookie cookie: String) async throws -> Self {
+        try await accessToken(forCookie: cookie, reason: "transport", productType: "web-player")
+    }
+
+    private static func accessToken(forCookie cookie: String, reason: String, productType: String) async throws -> Self {
+        struct ServerTime: Codable {
+            var serverTime: Int
+        }
+        struct SecretKeyEntry: Codable {
+            let version: Int
+            let secret: String
+        }
+        enum Error: Swift.Error {
+            case totpGenerationFailed
+        }
+        let secretKeyURL = URL(string: "https://raw.githubusercontent.com/Thereallo1026/spotify-secrets/refs/heads/main/secrets/secrets.json")!
+        let serverTimeRequest = URLRequest(url: .init(string: "https://open.spotify.com/api/server-time")!)
+        let serverTimeData = try await URLSession.shared.data(for: serverTimeRequest).0
+        let serverTime = try JSONDecoder().decode(ServerTime.self, from: serverTimeData).serverTime
+        let (data, _) = try await URLSession.shared.data(from: secretKeyURL)
+        let secretEntries = try JSONDecoder().decode([SecretKeyEntry].self, from: data)
+        guard let lastEntry = secretEntries.last else {
+            throw Error.totpGenerationFailed
+        }
+        guard let totp = TOTPGenerator.generate(secretCipher: .init(lastEntry.secret.utf8), serverTimeSeconds: serverTime) else {
+            throw Error.totpGenerationFailed
+        }
+        let tokenURL = URL(string: "https://open.spotify.com/api/token")!
+        let params: [String: String] = [
+            "reason": reason,
+            "productType": productType,
+            "totp": totp,
+            "totpVer": lastEntry.version.description,
+            "ts": String(Int(Date().timeIntervalSince1970)),
+        ]
+        var components = URLComponents(url: tokenURL, resolvingAgainstBaseURL: false)!
+        components.queryItems = params.map { URLQueryItem(name: $0.key, value: $0.value) }
+
+        var request = URLRequest(url: components.url!)
+        request.httpMethod = "GET"
+        request.setValue("sp_dc=\(cookie)", forHTTPHeaderField: "Cookie")
+        request.setValue("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36", forHTTPHeaderField: "User-Agent")
+        let accessTokenData = try await URLSession.shared.data(for: request).0
+        try print(JSONSerialization.jsonObject(with: accessTokenData))
+        return try JSONDecoder().decode(SpotifyAccessToken.self, from: accessTokenData)
+    }
+}