@wwdrew/expo-spotify-sdk 2.1.0 → 2.2.1

package/ios/SpotifyAppRemoteConnection.swift

@@ -0,0 +1,221 @@
+import Foundation
+import SpotifyiOS
+import UIKit
+
+// MARK: — Connection models
+
+enum AppRemoteConnectionKickoff: Equatable {
+  case directConnect
+  case authorizeAndPlay(uri: String)
+}
+
+struct AppRemoteConnectionAttempt {
+  let remote: SPTAppRemote
+  let kickoff: AppRemoteConnectionKickoff
+}
+
+// MARK: — Connection lifecycle
+
+extension SpotifyAppRemoteCoordinator {
+  func connect(accessToken: String) async throws {
+    if appRemote?.isConnected == true { return }
+    try await beginConnection(accessToken: accessToken, kickoff: .directConnect)
+  }
+
+  /// Wakes the Spotify app (via `authorizeAndPlayURI`), starts playback, and
+  /// then completes the App Remote connection once Spotify redirects back.
+  ///
+  /// Unlike `connect()`, this works even when the Spotify app has been
+  /// suspended: `authorizeAndPlayURI` performs an app-switch to Spotify, which
+  /// revives it. Spotify then redirects back to the host app with an access
+  /// token; `handleAuthorizeRedirect(_:)` consumes that redirect and calls
+  /// `connect()` on the same `SPTAppRemote` instance.
+  ///
+  /// The `connectContinuation` is reused for the whole flow, so `didConnect()`
+  /// / `didFailToConnect(error:)` resolve it exactly as for `connect()`.
+  func authorizeAndPlay(uri: String, accessToken: String) async throws {
+    if appRemote?.isConnected == true {
+      if uri.isEmpty {
+        try await playerResume()
+      } else {
+        try await playerPlay(uri: uri)
+      }
+      return
+    }
+    try await beginConnection(
+      accessToken: accessToken,
+      kickoff: .authorizeAndPlay(uri: uri),
+    )
+  }
+
+  /// Consumes a redirect URL produced by an `authorizeAndPlay()` app-switch.
+  /// Returns `true` if an authorize flow was pending and the URL was handled
+  /// (so the AppDelegate should not also forward it to the auth coordinator).
+  nonisolated func handleAuthorizeRedirect(_ url: URL) -> Bool {
+    guard case .authorizeAndPlay = connectionAttempt?.kickoff,
+          let remote = connectionAttempt?.remote
+    else {
+      return false
+    }
+
+    return SpotifyMainThread.run {
+      let params = remote.authorizationParameters(from: url)
+      if let token = params?[SPTAppRemoteAccessTokenKey] {
+        remote.connectionParameters.accessToken = token
+        clearConnectionAttempt()
+        remote.connect()
+        return true
+      }
+      if let errorDescription = params?[SPTAppRemoteErrorDescriptionKey] {
+        clearConnectionAttempt()
+        Task {
+          await self.didFailToConnect(error: NSError(
+            domain: "ExpoSpotifySDK",
+            code: -2,
+            userInfo: [NSLocalizedDescriptionKey: errorDescription]
+          ))
+        }
+        return true
+      }
+      return false
+    }
+  }
+
+  func disconnect() {
+    if let cont = connectContinuation {
+      connectContinuation = nil
+      cont.resume(throwing: AppRemoteError.connectionFailed("Disconnected before connection completed"))
+    }
+    teardownPlayerSubscription()
+    teardownCapabilitiesSubscription()
+    appRemote?.disconnect()
+    appRemote = nil
+    clearConnectionAttempt()
+    transitionState("disconnected")
+  }
+
+  nonisolated func isConnected() -> Bool {
+    connectionStateString == "connected"
+  }
+
+  func getConnectionState() -> String {
+    connectionStateString
+  }
+
+  func didConnect() {
+    clearConnectionAttempt()
+    transitionState("connected")
+    setupPlayerSubscription()
+    setupCapabilitiesSubscription()
+    let cont = connectContinuation
+    connectContinuation = nil
+    cont?.resume()
+  }
+
+  func didFailToConnect(error: Error?) {
+    appRemote = nil
+    clearConnectionAttempt()
+    let msg = error.map { describeNSError($0 as NSError) } ?? "Unknown connection failure"
+    let remoteError = AppRemoteError.connectionFailed(msg)
+    transitionState("disconnected")
+    onConnectionError?(remoteError.code, remoteError.message)
+    let cont = connectContinuation
+    connectContinuation = nil
+    cont?.resume(throwing: remoteError)
+  }
+
+  func didDisconnect(error: Error?) {
+    appRemote = nil
+    transitionState("disconnected")
+    if let error = error {
+      let msg = describeNSError(error as NSError)
+      onConnectionError?(AppRemoteError.connectionLost(msg).code, msg)
+    }
+  }
+
+  // MARK: — Private connection helpers
+
+  private func beginConnection(
+    accessToken: String,
+    kickoff: AppRemoteConnectionKickoff,
+  ) async throws {
+    guard connectContinuation == nil else {
+      throw AppRemoteError.connectionFailed("A connection attempt is already in progress")
+    }
+
+    transitionState("connecting")
+
+    let remote = makeAppRemote(accessToken: accessToken)
+    appRemote = remote
+    connectionAttempt = AppRemoteConnectionAttempt(remote: remote, kickoff: kickoff)
+
+    try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+      connectContinuation = cont
+      Task { @MainActor in
+        switch kickoff {
+        case .directConnect:
+          remote.connect()
+        case .authorizeAndPlay(let uri):
+          let success = await remote.authorizeAndPlayURI(uri)
+          if !success {
+            await self.didFailToConnect(error: Self.authorizeOpenFailedError())
+          }
+        }
+      }
+    }
+  }
+
+  private func makeAppRemote(accessToken: String) -> SPTAppRemote {
+    let params = SPTAppRemoteConnectionParams(
+      accessToken: accessToken,
+      defaultImageSize: CGSize.zero,
+      imageFormat: .any
+    )
+    let remote = SPTAppRemote(
+      configuration: sptConfiguration,
+      connectionParameters: params,
+      logLevel: .error
+    )
+    remote.delegate = connectionBridge
+    return remote
+  }
+
+  nonisolated private func clearConnectionAttempt() {
+    connectionAttempt = nil
+  }
+
+  private static func authorizeOpenFailedError() -> NSError {
+    NSError(
+      domain: "ExpoSpotifySDK",
+      code: -1,
+      userInfo: [
+        NSLocalizedDescriptionKey:
+          "authorizeAndPlay: could not open the Spotify app (is it installed?)",
+      ]
+    )
+  }
+}
+
+// MARK: — Connection delegate bridge
+
+/// `SPTAppRemoteDelegate` requires `NSObject` conformance, which an `actor`
+/// cannot satisfy directly. This bridge is a tiny `NSObject` that hops each
+/// delegate callback onto the actor's executor via a `Task`.
+final class SpotifyAppRemoteDelegateBridge: NSObject, SPTAppRemoteDelegate {
+  weak var coordinator: SpotifyAppRemoteCoordinator?
+
+  func appRemoteDidEstablishConnection(_ appRemote: SPTAppRemote) {
+    NSLog("[ExpoSpotifySDK] AppRemote: connection established")
+    Task { await coordinator?.didConnect() }
+  }
+
+  func appRemote(_ appRemote: SPTAppRemote, didFailConnectionAttemptWithError error: (any Error)?) {
+    NSLog("[ExpoSpotifySDK] AppRemote: connection failed — %@", String(describing: error))
+    Task { await coordinator?.didFailToConnect(error: error) }
+  }
+
+  func appRemote(_ appRemote: SPTAppRemote, didDisconnectWithError error: (any Error)?) {
+    NSLog("[ExpoSpotifySDK] AppRemote: disconnected — %@", String(describing: error))
+    Task { await coordinator?.didDisconnect(error: error) }
+  }
+}

package/ios/SpotifyAppRemoteCoordinator.swift

@@ -18,12 +18,16 @@ import UIKit
 actor SpotifyAppRemoteCoordinator {
   static let shared: SpotifyAppRemoteCoordinator? = SpotifyAppRemoteCoordinator.create()
 
-  private let sptConfiguration: SPTConfiguration
-  private let connectionBridge: SpotifyAppRemoteDelegateBridge
+  let sptConfiguration: SPTConfiguration
+  let connectionBridge: SpotifyAppRemoteDelegateBridge
   private let playerStateBridge: SpotifyPlayerStateDelegateBridge
   private let userCapabilitiesBridge: SpotifyUserCapabilitiesDelegateBridge
-  private var appRemote: SPTAppRemote?
-  private var connectContinuation: CheckedContinuation<Void, Error>?
+  var appRemote: SPTAppRemote?
+  var connectContinuation: CheckedContinuation<Void, Error>?
+
+  /// In-flight connection attempt, readable from the synchronous redirect path.
+  /// `nil` whenever no connection attempt is active.
+  nonisolated(unsafe) var connectionAttempt: AppRemoteConnectionAttempt?
 
   nonisolated(unsafe) private(set) var connectionStateString: String = "disconnected"
 
@@ -68,95 +72,15 @@ actor SpotifyAppRemoteCoordinator {
     return SpotifyAppRemoteCoordinator(sptConfiguration: sptConfig)
   }
 
-  // MARK: — Connection lifecycle
-
-  func connect(accessToken: String) async throws {
-    if appRemote?.isConnected == true { return }
-    guard connectContinuation == nil else {
-      throw AppRemoteError.connectionFailed("A connection attempt is already in progress")
-    }
-
-    transitionState("connecting")
-
-    let params = SPTAppRemoteConnectionParams(
-      accessToken: accessToken,
-      defaultImageSize: CGSize.zero,
-      imageFormat: .any
-    )
-    let remote = SPTAppRemote(
-      configuration: sptConfiguration,
-      connectionParameters: params,
-      logLevel: .error
-    )
-    remote.delegate = connectionBridge
-    appRemote = remote
-
-    try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
-      self.connectContinuation = cont
-      Task { @MainActor in remote.connect() }
-    }
-  }
-
-  func disconnect() {
-    if let cont = connectContinuation {
-      connectContinuation = nil
-      cont.resume(throwing: AppRemoteError.connectionFailed("Disconnected before connection completed"))
-    }
-    teardownPlayerSubscription()
-    teardownCapabilitiesSubscription()
-    appRemote?.disconnect()
-    appRemote = nil
-    transitionState("disconnected")
-  }
-
-  nonisolated func isConnected() -> Bool {
-    connectionStateString == "connected"
-  }
-
-  func getConnectionState() -> String {
-    connectionStateString
-  }
-
-  // MARK: — Connection delegate callbacks
-
-  func didConnect() {
-    transitionState("connected")
-    setupPlayerSubscription()
-    setupCapabilitiesSubscription()
-    let cont = connectContinuation
-    connectContinuation = nil
-    cont?.resume()
-  }
-
-  func didFailToConnect(error: Error?) {
-    appRemote = nil
-    let msg = error.map { describeNSError($0 as NSError) } ?? "Unknown connection failure"
-    let remoteError = AppRemoteError.connectionFailed(msg)
-    transitionState("disconnected")
-    onConnectionError?(remoteError.code, remoteError.message)
-    let cont = connectContinuation
-    connectContinuation = nil
-    cont?.resume(throwing: remoteError)
-  }
-
-  func didDisconnect(error: Error?) {
-    appRemote = nil
-    transitionState("disconnected")
-    if let error = error {
-      let msg = describeNSError(error as NSError)
-      onConnectionError?(AppRemoteError.connectionLost(msg).code, msg)
-    }
-  }
-
   // MARK: — Player subscription
 
-  private func setupPlayerSubscription() {
+  func setupPlayerSubscription() {
     guard let playerAPI = appRemote?.playerAPI else { return }
     playerAPI.delegate = playerStateBridge
     playerAPI.subscribe(toPlayerState: { _, _ in })
   }
 
-  private func teardownPlayerSubscription() {
+  func teardownPlayerSubscription() {
     guard let playerAPI = appRemote?.playerAPI else { return }
     playerAPI.delegate = nil
     playerAPI.unsubscribe(toPlayerState: { _, _ in })
@@ -169,13 +93,13 @@ actor SpotifyAppRemoteCoordinator {
 
   // MARK: — User subscription
 
-  private func setupCapabilitiesSubscription() {
+  func setupCapabilitiesSubscription() {
     guard let userAPI = appRemote?.userAPI else { return }
     userAPI.delegate = userCapabilitiesBridge
     userAPI.subscribe(toCapabilityChanges: { _, _ in })
   }
 
-  private func teardownCapabilitiesSubscription() {
+  func teardownCapabilitiesSubscription() {
     guard let userAPI = appRemote?.userAPI else { return }
     userAPI.delegate = nil
     userAPI.unsubscribe(toCapabilityChanges: { _, _ in })
@@ -490,12 +414,12 @@ actor SpotifyAppRemoteCoordinator {
     }
   }
 
-  private func transitionState(_ state: String) {
+  func transitionState(_ state: String) {
     connectionStateString = state
     onConnectionStateChange?(state)
   }
 
-  private func describeNSError(_ error: NSError) -> String {
+  func describeNSError(_ error: NSError) -> String {
     var parts: [String] = ["\(error.domain) code \(error.code)"]
     let desc = error.localizedDescription
     if !desc.isEmpty { parts.append("\"\(desc)\"") }
@@ -506,30 +430,6 @@ actor SpotifyAppRemoteCoordinator {
   }
 }
 
-// MARK: — Connection delegate bridge
-
-/// `SPTAppRemoteDelegate` requires `NSObject` conformance, which an `actor`
-/// cannot satisfy directly. This bridge is a tiny `NSObject` that hops each
-/// delegate callback onto the actor's executor via a `Task`.
-final class SpotifyAppRemoteDelegateBridge: NSObject, SPTAppRemoteDelegate {
-  weak var coordinator: SpotifyAppRemoteCoordinator?
-
-  func appRemoteDidEstablishConnection(_ appRemote: SPTAppRemote) {
-    NSLog("[ExpoSpotifySDK] AppRemote: connection established")
-    Task { await coordinator?.didConnect() }
-  }
-
-  func appRemote(_ appRemote: SPTAppRemote, didFailConnectionAttemptWithError error: (any Error)?) {
-    NSLog("[ExpoSpotifySDK] AppRemote: connection failed — %@", String(describing: error))
-    Task { await coordinator?.didFailToConnect(error: error) }
-  }
-
-  func appRemote(_ appRemote: SPTAppRemote, didDisconnectWithError error: (any Error)?) {
-    NSLog("[ExpoSpotifySDK] AppRemote: disconnected — %@", String(describing: error))
-    Task { await coordinator?.didDisconnect(error: error) }
-  }
-}
-
 // MARK: — Player state delegate bridge
 
 /// `SPTAppRemotePlayerStateDelegate` requires `NSObject` conformance. This

package/ios/SpotifyAuthCoordinator.swift

@@ -1,6 +1,7 @@
 import ExpoModulesCore
 import Foundation
 import SpotifyiOS
+import UIKit
 
 /// Public, structured errors thrown by the coordinator. Each case carries the
 /// JS-facing error code in `code`, mirroring the Android `CodedException`
@@ -105,15 +106,9 @@ actor SpotifyAuthCoordinator {
   /// Synchronous URL-handler dispatcher used by the AppDelegate / SceneDelegate
   /// subscribers to forward redirects to the SPTSessionManager.
   nonisolated func handleOpenURL(_ url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
-    let openSession: () -> Bool = { [self] in
-      MainActor.assumeIsolated {
-        sessionManager.application(UIApplication.shared, open: url, options: options)
-      }
-    }
-    if Thread.isMainThread {
-      return openSession()
+    SpotifyMainThread.run {
+      sessionManager.application(UIApplication.shared, open: url, options: options)
     }
-    return DispatchQueue.main.sync(execute: openSession)
   }
 
   func authenticate(

package/ios/SpotifyMainThread.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+/// Runs a block on the main thread, matching AppDelegate / SceneDelegate redirect
+/// hooks that require a synchronous result from the main actor.
+enum SpotifyMainThread {
+  static func run<T>(_ block: @MainActor () -> T) -> T {
+    if Thread.isMainThread {
+      return MainActor.assumeIsolated(block)
+    }
+    return DispatchQueue.main.sync {
+      MainActor.assumeIsolated(block)
+    }
+  }
+}

package/ios/spotify-native-sdk-versions.json

@@ -0,0 +1,12 @@
+{
+  "ios": {
+    "spmRepositoryUrl": "https://github.com/spotify/ios-sdk.git",
+    "spmVersion": "5.0.1",
+    "spmProduct": "SpotifyiOS"
+  },
+  "android": {
+    "appRemoteVersion": "0.8.0",
+    "appRemoteReleaseTag": "v0.8.0-appremote_v2.1.0-auth",
+    "appRemoteSha256": "b5a6dd880eaf01f63a871cba9ef7af77c341f8a94ffc8fdf2e9021f9a9d4c198"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwdrew/expo-spotify-sdk",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "Expo module wrapping the native Spotify iOS (v5) and Android (v4) SDKs for OAuth authentication and App Remote playback control",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -17,7 +17,7 @@
   "scripts": {
     "build": "tsc",
     "build:plugin": "tsc -p plugin/tsconfig.json",
-    "clean": "rm -rf build plugin/build",
+    "clean": "rm -rf build plugin/build android/build",
     "lint": "eslint src",
     "test": "jest --config jest.config.js",
     "prepublishOnly": "yarn clean && yarn build && yarn build:plugin",
@@ -37,8 +37,14 @@
     "plugin/index.d.ts",
     "plugin/build",
     "build",
-    "android",
-    "ios",
+    "android/build.gradle",
+    "android/spotify-native-sdk.gradle",
+    "android/consumer-rules.pro",
+    "android/src",
+    "android/libs/SETUP.md",
+    "ios/spotify-native-sdk-versions.json",
+    "ios/*.swift",
+    "ios/*.podspec",
     "app.plugin.js",
     "expo-module.config.json"
   ],

package/ios/SpotifySDK/Licenses/MPMessagePack-LICENSE.md

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Gabriel Handford
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/ios/SpotifySDK/SpotifyiOS.xcframework/Info.plist

@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>AvailableLibraries</key>
-	<array>
-		<dict>
-			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
-			<key>LibraryPath</key>
-			<string>SpotifyiOS.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>ios</string>
-		</dict>
-		<dict>
-			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
-			<key>LibraryPath</key>
-			<string>SpotifyiOS.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-				<string>x86_64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
-		</dict>
-	</array>
-	<key>CFBundlePackageType</key>
-	<string>XFWK</string>
-	<key>XCFrameworkFormatVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>