@wwdrew/expo-spotify-sdk 2.2.0 → 2.2.2

package/README.md

@@ -103,7 +103,7 @@ For bare React Native (no Expo CLI), see [Installation in bare React Native](#in
 
 | Platform | Distribution |
 | --- | --- |
-| **iOS** | `SpotifyiOS` resolved from Spotify's GitHub via SPM at `pod install` ([ADR-0008](./docs/adr/0008-ios-spotify-sdk-via-spm.md)). Uses React Native's `spm_dependency` (RN 0.75+). Supported Expo SDK lanes: [Platform support](#platform-support). |
+| **iOS** | `SpotifyiOS` downloaded via CocoaPods HTTP binary pod at `pod install` ([ADR-0009](./docs/adr/0009-ios-spotify-sdk-via-cocoapods-binary-pod.md)). Config plugin injects the Podfile `pod` line on `expo prebuild`. Supported Expo SDK lanes: [Platform support](#platform-support). |
 | **Android** | App Remote AAR downloaded from Spotify's GitHub at Gradle build. Auth SDK from Maven Central. |
 
 | You are… | Action |
@@ -127,10 +127,11 @@ yarn add @wwdrew/expo-spotify-sdk expo-modules-core
 
 ### 2. iOS
 
-Add the pod to your `Podfile`:
+Add pods to your `Podfile`:
 
 ```ruby
 pod 'ExpoSpotifySDK', :path => '../node_modules/@wwdrew/expo-spotify-sdk'
+pod 'SpotifyiOS', :podspec => File.join(__dir__, '../node_modules/@wwdrew/expo-spotify-sdk/spotify-ios/SpotifyiOS.podspec')
 ```
 
 Then install pods:

package/android/spotify-native-sdk.gradle

@@ -71,9 +71,7 @@ tasks.register("downloadSpotifyAppRemoteAar") {
       ant.get(
         src: downloadUrl,
         dest: tmp,
-        verbose: true,
-        connecttimeout: 30000,
-        readtimeout: 60000
+        verbose: true
       )
       def actual = sha256File(tmp)
       if (actual != appRemoteSha256) {

package/android/src/main/java/expo/modules/spotifysdk/ExpoSpotifySDKModule.kt

@@ -8,7 +8,7 @@ import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 
-private const val SDK_VERSION = "2.2.0" // x-release-please-version
+private const val SDK_VERSION = "2.2.2" // x-release-please-version
 private const val EVENT_SESSION_CHANGE = "onSessionChange"
 private const val EVENT_CONNECTION_STATE_CHANGE = "onConnectionStateChange"
 private const val EVENT_CONNECTION_ERROR = "onConnectionError"

package/build/app-remote/index.d.ts

@@ -49,37 +49,12 @@ export declare const AppRemote: {
      */
     readonly connect: (accessToken: string) => Promise<void>;
     /**
-     * Wakes the Spotify app — launching it if it has been suspended in the
-     * background — starts playback, and then establishes the App Remote
-     * connection. This is the recommended way to (re)connect when Spotify may
-     * not currently be running.
+     * Wakes Spotify (launching if suspended), starts or resumes playback, and
+     * connects. Use when {@link connect} may fail because Spotify is not running.
+     * Always foregrounds Spotify and starts audio — see package api-reference.
      *
-     * Why this exists: {@link connect} only attaches to an *already-running*
-     * Spotify process. If Spotify has been suspended (e.g. iOS reclaims a
-     * backgrounded app that isn't playing audio, or the connection dropped
-     * ~30s after the user paused), `connect()` rejects with `CONNECTION_FAILED`
-     * and there is no way to revive Spotify from `connect()` alone.
-     * `authorizeAndPlay()` performs an app-switch to Spotify
-     * (iOS `authorizeAndPlayURI`; Android wakes the App Remote service and
-     * issues a play command), which both revives Spotify and keeps it alive by
-     * starting audio.
-     *
-     * Trade-offs:
-     * - It **always starts (or resumes) playback** — it cannot wake Spotify
-     *   silently.
-     * - It briefly **switches to the Spotify app** and back; the OS does not
-     *   allow waking another app without a foreground app-switch.
-     * - Requires Spotify Premium for on-demand playback of a specific `uri`.
-     *
-     * @param accessToken Access token from `Auth.authenticate()`. On Android this
-     *   is an iOS-parity parameter (see {@link connect}); on iOS the token
-     *   returned by the authorization redirect is used to complete the connection.
-     * @param uri Spotify URI to play. Pass an empty string (the default) to
-     *   resume the user's last track or play a contextual/random track.
-     *
-     * Resolves once Spotify is connected and the play command has been issued;
-     * rejects with an {@link AppRemoteError} if Spotify is not installed or the
-     * authorization is denied.
+     * @param accessToken Access token from `Auth.authenticate()`.
+     * @param uri Spotify URI to play, or empty (default) to resume last/contextual track.
      */
     readonly authorizeAndPlay: (accessToken: string, uri?: string) => Promise<void>;
     /**

package/build/app-remote/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/app-remote/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGlE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAMzC,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,CAAC;AAE1E,oDAAoD;AACpD,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB;AAqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;IACpB;;;;;;;;;;;OAWG;oCACkB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;IAM3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;6CAC2B,MAAM,QAAO,MAAM,KAAQ,OAAO,CAAC,IAAI,CAAC;IAOtE;;;OAGG;+BACW,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;gCACY,OAAO;IAItB;;;OAGG;uCACmB,OAAO,CAAC,eAAe,CAAC;IAI9C;;;;;;;;;OASG;2BACS,CAAC,SAAS,uBAAuB,GAAG,iBAAiB,SACxD,CAAC,YACE,CAAC,SAAS,uBAAuB,GACvC,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,GAC3C,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,KACxC,iBAAiB;CAUZ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/app-remote/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG3D,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGlE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAMzC,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,CAAC;AAE1E,oDAAoD;AACpD,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB;AAqBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;IACpB;;;;;;;;;;;OAWG;oCACkB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;IAM3C;;;;;;;OAOG;6CAC2B,MAAM,QAAO,MAAM,KAAQ,OAAO,CAAC,IAAI,CAAC;IAOtE;;;OAGG;+BACW,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;gCACY,OAAO;IAItB;;;OAGG;uCACmB,OAAO,CAAC,eAAe,CAAC;IAI9C;;;;;;;;;OASG;2BACS,CAAC,SAAS,uBAAuB,GAAG,iBAAiB,SACxD,CAAC,YACE,CAAC,SAAS,uBAAuB,GACvC,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,GAC3C,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,KACxC,iBAAiB;CAUZ,CAAC"}

package/build/app-remote/index.js

@@ -56,37 +56,12 @@ export const AppRemote = {
         return ExpoSpotifySDKModule.appRemoteConnect(accessToken).catch(rethrowAsAppRemoteError);
     },
     /**
-     * Wakes the Spotify app — launching it if it has been suspended in the
-     * background — starts playback, and then establishes the App Remote
-     * connection. This is the recommended way to (re)connect when Spotify may
-     * not currently be running.
+     * Wakes Spotify (launching if suspended), starts or resumes playback, and
+     * connects. Use when {@link connect} may fail because Spotify is not running.
+     * Always foregrounds Spotify and starts audio — see package api-reference.
      *
-     * Why this exists: {@link connect} only attaches to an *already-running*
-     * Spotify process. If Spotify has been suspended (e.g. iOS reclaims a
-     * backgrounded app that isn't playing audio, or the connection dropped
-     * ~30s after the user paused), `connect()` rejects with `CONNECTION_FAILED`
-     * and there is no way to revive Spotify from `connect()` alone.
-     * `authorizeAndPlay()` performs an app-switch to Spotify
-     * (iOS `authorizeAndPlayURI`; Android wakes the App Remote service and
-     * issues a play command), which both revives Spotify and keeps it alive by
-     * starting audio.
-     *
-     * Trade-offs:
-     * - It **always starts (or resumes) playback** — it cannot wake Spotify
-     *   silently.
-     * - It briefly **switches to the Spotify app** and back; the OS does not
-     *   allow waking another app without a foreground app-switch.
-     * - Requires Spotify Premium for on-demand playback of a specific `uri`.
-     *
-     * @param accessToken Access token from `Auth.authenticate()`. On Android this
-     *   is an iOS-parity parameter (see {@link connect}); on iOS the token
-     *   returned by the authorization redirect is used to complete the connection.
-     * @param uri Spotify URI to play. Pass an empty string (the default) to
-     *   resume the user's last track or play a contextual/random track.
-     *
-     * Resolves once Spotify is connected and the play command has been issued;
-     * rejects with an {@link AppRemoteError} if Spotify is not installed or the
-     * authorization is denied.
+     * @param accessToken Access token from `Auth.authenticate()`.
+     * @param uri Spotify URI to play, or empty (default) to resume last/contextual track.
      */
     authorizeAndPlay(accessToken, uri = "") {
         return ExpoSpotifySDKModule.appRemoteAuthorizeAndPlay(accessToken, uri).catch(rethrowAsAppRemoteError);

package/build/app-remote/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/app-remote/index.ts"],"names":[],"mappings":"AAEA,OAAO,oBAAoB,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAA2B,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAoBzC,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAE9E,MAAM,uBAAuB,GAAG,wBAAwB,CAAC;IACvD,UAAU,EAAE,cAAc;IAC1B,WAAW,EAAE,SAAS;IACtB,UAAU,EAAE,IAAI,GAAG,CAAqB;QACtC,mBAAmB;QACnB,iBAAiB;QACjB,eAAe;QACf,SAAS;KACV,CAAC;CACH,CAAC,CAAC;AAEH,8EAA8E;AAC9E,sBAAsB;AACtB,8EAA8E;AAE9E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAmB;QACzB,OAAO,oBAAoB,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,KAAK,CAC7D,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,gBAAgB,CAAC,WAAmB,EAAE,MAAc,EAAE;QACpD,OAAO,oBAAoB,CAAC,yBAAyB,CACnD,WAAW,EACX,GAAG,CACJ,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,OAAO,oBAAoB,CAAC,mBAAmB,EAAE,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,WAAW;QACT,OAAO,oBAAoB,CAAC,oBAAoB,EAAE,CAAC;IACrD,CAAC;IAED;;;OAGG;IACH,kBAAkB;QAChB,OAAO,oBAAoB,CAAC,2BAA2B,EAAE,CAAC;IAC5D,CAAC;IAED;;;;;;;;;OASG;IACH,WAAW,CACT,KAAQ,EACR,QAEyC;QAEzC,MAAM,WAAW,GACf,KAAK,KAAK,uBAAuB;YAC/B,CAAC,CAAC,yBAAyB;YAC3B,CAAC,CAAC,mBAAmB,CAAC;QAC1B,OAAO,oBAAoB,CAAC,WAAW,CACrC,WAAW,EACX,QAAoC,CAChB,CAAC;IACzB,CAAC;CACO,CAAC","sourcesContent":["import type { EventSubscription } from \"expo-modules-core\";\n\nimport ExpoSpotifySDKModule from \"../ExpoSpotifySDKModule\";\nimport { AppRemoteError, type AppRemoteErrorCode } from \"./error\";\nimport { createNativeErrorRethrow } from \"../internal/native-errors\";\n\nexport type { AppRemoteErrorCode } from \"./error\";\nexport { AppRemoteError } from \"./error\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Current state of the IPC connection to the Spotify app. */\nexport type ConnectionState = \"disconnected\" | \"connecting\" | \"connected\";\n\n/** Payload of the `connectionStateChange` event. */\nexport interface ConnectionStateChangeEvent {\n  state: ConnectionState;\n}\n\n/** Payload of the `connectionError` event. */\nexport interface ConnectionErrorEvent {\n  code: AppRemoteErrorCode;\n  message: string;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst rethrowAsAppRemoteError = createNativeErrorRethrow({\n  ErrorClass: AppRemoteError,\n  unknownCode: \"UNKNOWN\",\n  validCodes: new Set<AppRemoteErrorCode>([\n    \"CONNECTION_FAILED\",\n    \"CONNECTION_LOST\",\n    \"NOT_CONNECTED\",\n    \"UNKNOWN\",\n  ]),\n});\n\n// ---------------------------------------------------------------------------\n// AppRemote namespace\n// ---------------------------------------------------------------------------\n\n/**\n * Spotify App Remote namespace. Manages the IPC connection to the running\n * Spotify app. All `Player`, `User`, `Content`, and `Images` calls require an\n * active connection established via `AppRemote.connect()`.\n *\n * @example\n * ```ts\n * import { AppRemote } from \"@wwdrew/expo-spotify-sdk\";\n *\n * // Connect using the access token from Auth.authenticate()\n * await AppRemote.connect(session.accessToken);\n *\n * const sub = AppRemote.addListener(\"connectionStateChange\", ({ state }) => {\n *   console.log(\"connection state:\", state);\n * });\n *\n * // later:\n * await AppRemote.disconnect();\n * sub.remove();\n * ```\n */\nexport const AppRemote = {\n  /**\n   * Opens a connection to the running Spotify app using the provided access\n   * token. Resolves when the connection is established; rejects with an\n   * {@link AppRemoteError} if the connection fails.\n   *\n   * **Android note:** The access token is accepted for API parity with iOS but\n   * the Android App Remote SDK does not accept it directly — it uses the\n   * session cached in the Spotify app from your earlier `Auth.authenticate()`\n   * call. Ensure `Auth.authenticate()` has succeeded before calling `connect()`.\n   *\n   * Calling `connect()` while already connected is a no-op.\n   */\n  connect(accessToken: string): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteConnect(accessToken).catch(\n      rethrowAsAppRemoteError,\n    );\n  },\n\n  /**\n   * Wakes the Spotify app — launching it if it has been suspended in the\n   * background — starts playback, and then establishes the App Remote\n   * connection. This is the recommended way to (re)connect when Spotify may\n   * not currently be running.\n   *\n   * Why this exists: {@link connect} only attaches to an *already-running*\n   * Spotify process. If Spotify has been suspended (e.g. iOS reclaims a\n   * backgrounded app that isn't playing audio, or the connection dropped\n   * ~30s after the user paused), `connect()` rejects with `CONNECTION_FAILED`\n   * and there is no way to revive Spotify from `connect()` alone.\n   * `authorizeAndPlay()` performs an app-switch to Spotify\n   * (iOS `authorizeAndPlayURI`; Android wakes the App Remote service and\n   * issues a play command), which both revives Spotify and keeps it alive by\n   * starting audio.\n   *\n   * Trade-offs:\n   * - It **always starts (or resumes) playback** — it cannot wake Spotify\n   *   silently.\n   * - It briefly **switches to the Spotify app** and back; the OS does not\n   *   allow waking another app without a foreground app-switch.\n   * - Requires Spotify Premium for on-demand playback of a specific `uri`.\n   *\n   * @param accessToken Access token from `Auth.authenticate()`. On Android this\n   *   is an iOS-parity parameter (see {@link connect}); on iOS the token\n   *   returned by the authorization redirect is used to complete the connection.\n   * @param uri Spotify URI to play. Pass an empty string (the default) to\n   *   resume the user's last track or play a contextual/random track.\n   *\n   * Resolves once Spotify is connected and the play command has been issued;\n   * rejects with an {@link AppRemoteError} if Spotify is not installed or the\n   * authorization is denied.\n   */\n  authorizeAndPlay(accessToken: string, uri: string = \"\"): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteAuthorizeAndPlay(\n      accessToken,\n      uri,\n    ).catch(rethrowAsAppRemoteError);\n  },\n\n  /**\n   * Disconnects from the Spotify app. Safe to call when already disconnected.\n   * Resolves once the disconnection is complete.\n   */\n  disconnect(): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteDisconnect();\n  },\n\n  /**\n   * Returns `true` if currently connected to the Spotify app.\n   * This is a synchronous snapshot — subscribe to `\"connectionStateChange\"`\n   * for reactive updates.\n   */\n  isConnected(): boolean {\n    return ExpoSpotifySDKModule.appRemoteIsConnected();\n  },\n\n  /**\n   * Returns the current {@link ConnectionState} synchronously.\n   * Subscribe to `\"connectionStateChange\"` for reactive updates.\n   */\n  getConnectionState(): Promise<ConnectionState> {\n    return ExpoSpotifySDKModule.appRemoteGetConnectionState();\n  },\n\n  /**\n   * Subscribes to connection lifecycle events.\n   *\n   * | Event | Payload | When |\n   * |---|---|---|\n   * | `\"connectionStateChange\"` | `{ state: ConnectionState }` | State transitions |\n   * | `\"connectionError\"` | `{ code, message }` | Connection failures and drops |\n   *\n   * Returns a `Subscription` — call `.remove()` to unsubscribe.\n   */\n  addListener<E extends \"connectionStateChange\" | \"connectionError\">(\n    event: E,\n    listener: E extends \"connectionStateChange\"\n      ? (event: ConnectionStateChangeEvent) => void\n      : (event: ConnectionErrorEvent) => void,\n  ): EventSubscription {\n    const nativeEvent =\n      event === \"connectionStateChange\"\n        ? \"onConnectionStateChange\"\n        : \"onConnectionError\";\n    return ExpoSpotifySDKModule.addListener(\n      nativeEvent,\n      listener as (event: unknown) => void,\n    ) as EventSubscription;\n  },\n} as const;\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/app-remote/index.ts"],"names":[],"mappings":"AAEA,OAAO,oBAAoB,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAA2B,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAoBzC,8EAA8E;AAC9E,mBAAmB;AACnB,8EAA8E;AAE9E,MAAM,uBAAuB,GAAG,wBAAwB,CAAC;IACvD,UAAU,EAAE,cAAc;IAC1B,WAAW,EAAE,SAAS;IACtB,UAAU,EAAE,IAAI,GAAG,CAAqB;QACtC,mBAAmB;QACnB,iBAAiB;QACjB,eAAe;QACf,SAAS;KACV,CAAC;CACH,CAAC,CAAC;AAEH,8EAA8E;AAC9E,sBAAsB;AACtB,8EAA8E;AAE9E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAmB;QACzB,OAAO,oBAAoB,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,KAAK,CAC7D,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,gBAAgB,CAAC,WAAmB,EAAE,MAAc,EAAE;QACpD,OAAO,oBAAoB,CAAC,yBAAyB,CACnD,WAAW,EACX,GAAG,CACJ,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,OAAO,oBAAoB,CAAC,mBAAmB,EAAE,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,WAAW;QACT,OAAO,oBAAoB,CAAC,oBAAoB,EAAE,CAAC;IACrD,CAAC;IAED;;;OAGG;IACH,kBAAkB;QAChB,OAAO,oBAAoB,CAAC,2BAA2B,EAAE,CAAC;IAC5D,CAAC;IAED;;;;;;;;;OASG;IACH,WAAW,CACT,KAAQ,EACR,QAEyC;QAEzC,MAAM,WAAW,GACf,KAAK,KAAK,uBAAuB;YAC/B,CAAC,CAAC,yBAAyB;YAC3B,CAAC,CAAC,mBAAmB,CAAC;QAC1B,OAAO,oBAAoB,CAAC,WAAW,CACrC,WAAW,EACX,QAAoC,CAChB,CAAC;IACzB,CAAC;CACO,CAAC","sourcesContent":["import type { EventSubscription } from \"expo-modules-core\";\n\nimport ExpoSpotifySDKModule from \"../ExpoSpotifySDKModule\";\nimport { AppRemoteError, type AppRemoteErrorCode } from \"./error\";\nimport { createNativeErrorRethrow } from \"../internal/native-errors\";\n\nexport type { AppRemoteErrorCode } from \"./error\";\nexport { AppRemoteError } from \"./error\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Current state of the IPC connection to the Spotify app. */\nexport type ConnectionState = \"disconnected\" | \"connecting\" | \"connected\";\n\n/** Payload of the `connectionStateChange` event. */\nexport interface ConnectionStateChangeEvent {\n  state: ConnectionState;\n}\n\n/** Payload of the `connectionError` event. */\nexport interface ConnectionErrorEvent {\n  code: AppRemoteErrorCode;\n  message: string;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nconst rethrowAsAppRemoteError = createNativeErrorRethrow({\n  ErrorClass: AppRemoteError,\n  unknownCode: \"UNKNOWN\",\n  validCodes: new Set<AppRemoteErrorCode>([\n    \"CONNECTION_FAILED\",\n    \"CONNECTION_LOST\",\n    \"NOT_CONNECTED\",\n    \"UNKNOWN\",\n  ]),\n});\n\n// ---------------------------------------------------------------------------\n// AppRemote namespace\n// ---------------------------------------------------------------------------\n\n/**\n * Spotify App Remote namespace. Manages the IPC connection to the running\n * Spotify app. All `Player`, `User`, `Content`, and `Images` calls require an\n * active connection established via `AppRemote.connect()`.\n *\n * @example\n * ```ts\n * import { AppRemote } from \"@wwdrew/expo-spotify-sdk\";\n *\n * // Connect using the access token from Auth.authenticate()\n * await AppRemote.connect(session.accessToken);\n *\n * const sub = AppRemote.addListener(\"connectionStateChange\", ({ state }) => {\n *   console.log(\"connection state:\", state);\n * });\n *\n * // later:\n * await AppRemote.disconnect();\n * sub.remove();\n * ```\n */\nexport const AppRemote = {\n  /**\n   * Opens a connection to the running Spotify app using the provided access\n   * token. Resolves when the connection is established; rejects with an\n   * {@link AppRemoteError} if the connection fails.\n   *\n   * **Android note:** The access token is accepted for API parity with iOS but\n   * the Android App Remote SDK does not accept it directly — it uses the\n   * session cached in the Spotify app from your earlier `Auth.authenticate()`\n   * call. Ensure `Auth.authenticate()` has succeeded before calling `connect()`.\n   *\n   * Calling `connect()` while already connected is a no-op.\n   */\n  connect(accessToken: string): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteConnect(accessToken).catch(\n      rethrowAsAppRemoteError,\n    );\n  },\n\n  /**\n   * Wakes Spotify (launching if suspended), starts or resumes playback, and\n   * connects. Use when {@link connect} may fail because Spotify is not running.\n   * Always foregrounds Spotify and starts audio — see package api-reference.\n   *\n   * @param accessToken Access token from `Auth.authenticate()`.\n   * @param uri Spotify URI to play, or empty (default) to resume last/contextual track.\n   */\n  authorizeAndPlay(accessToken: string, uri: string = \"\"): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteAuthorizeAndPlay(\n      accessToken,\n      uri,\n    ).catch(rethrowAsAppRemoteError);\n  },\n\n  /**\n   * Disconnects from the Spotify app. Safe to call when already disconnected.\n   * Resolves once the disconnection is complete.\n   */\n  disconnect(): Promise<void> {\n    return ExpoSpotifySDKModule.appRemoteDisconnect();\n  },\n\n  /**\n   * Returns `true` if currently connected to the Spotify app.\n   * This is a synchronous snapshot — subscribe to `\"connectionStateChange\"`\n   * for reactive updates.\n   */\n  isConnected(): boolean {\n    return ExpoSpotifySDKModule.appRemoteIsConnected();\n  },\n\n  /**\n   * Returns the current {@link ConnectionState} synchronously.\n   * Subscribe to `\"connectionStateChange\"` for reactive updates.\n   */\n  getConnectionState(): Promise<ConnectionState> {\n    return ExpoSpotifySDKModule.appRemoteGetConnectionState();\n  },\n\n  /**\n   * Subscribes to connection lifecycle events.\n   *\n   * | Event | Payload | When |\n   * |---|---|---|\n   * | `\"connectionStateChange\"` | `{ state: ConnectionState }` | State transitions |\n   * | `\"connectionError\"` | `{ code, message }` | Connection failures and drops |\n   *\n   * Returns a `Subscription` — call `.remove()` to unsubscribe.\n   */\n  addListener<E extends \"connectionStateChange\" | \"connectionError\">(\n    event: E,\n    listener: E extends \"connectionStateChange\"\n      ? (event: ConnectionStateChangeEvent) => void\n      : (event: ConnectionErrorEvent) => void,\n  ): EventSubscription {\n    const nativeEvent =\n      event === \"connectionStateChange\"\n        ? \"onConnectionStateChange\"\n        : \"onConnectionError\";\n    return ExpoSpotifySDKModule.addListener(\n      nativeEvent,\n      listener as (event: unknown) => void,\n    ) as EventSubscription;\n  },\n} as const;\n"]}

package/expo-module.config.json

@@ -2,7 +2,8 @@
   "platforms": ["ios", "android", "web"],
   "ios": {
     "modules": ["ExpoSpotifySDKModule"],
-    "appDelegateSubscribers": ["ExpoSpotifyAppDelegate"]
+    "appDelegateSubscribers": ["ExpoSpotifyAppDelegate"],
+    "podspecPath": "ios/ExpoSpotifySDK.podspec"
   },
   "android": {
     "modules": ["expo.modules.spotifysdk.ExpoSpotifySDKModule"]

package/ios/ExpoSpotifySDK.podspec

@@ -1,18 +1,6 @@
 require 'json'
 
-absolute_react_native_path = ''
-if !ENV['REACT_NATIVE_PATH'].nil?
-  absolute_react_native_path = File.expand_path(ENV['REACT_NATIVE_PATH'], Pod::Config.instance.project_root)
-else
-  absolute_react_native_path = File.dirname(`node --print "require.resolve('react-native/package.json')"`)
-end
-
-unless defined?(spm_dependency)
-  require File.join(absolute_react_native_path, "scripts/react_native_pods")
-end
-
 package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
-spotify_native = JSON.parse(File.read(File.join(__dir__, 'spotify-native-sdk-versions.json')))
 
 Pod::Spec.new do |s|
   s.name           = 'ExpoSpotifySDK'
@@ -28,6 +16,7 @@ Pod::Spec.new do |s|
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
+  s.dependency 'SpotifyiOS'
 
   s.pod_target_xcconfig = {
     'DEFINES_MODULE' => 'YES',
@@ -35,18 +24,4 @@ Pod::Spec.new do |s|
   }
 
   s.source_files = "**/*.{h,m,swift}"
-
-  ios_sdk = spotify_native['ios']
-  if ios_sdk.nil? ||
-      ios_sdk['spmRepositoryUrl'].to_s.empty? ||
-      ios_sdk['spmVersion'].to_s.empty? ||
-      ios_sdk['spmProduct'].to_s.empty?
-    raise "ios/spotify-native-sdk-versions.json is missing required iOS fields: spmRepositoryUrl, spmVersion, spmProduct"
-  end
-
-  spm_dependency(s,
-    url: ios_sdk['spmRepositoryUrl'],
-    requirement: { kind: 'exactVersion', version: ios_sdk['spmVersion'] },
-    products: [ios_sdk['spmProduct']]
-  )
 end

package/ios/ExpoSpotifySDKModule.swift

@@ -1,7 +1,7 @@
 import ExpoModulesCore
 import SpotifyiOS
 
-private let SDK_VERSION = "2.2.0" // x-release-please-version
+private let SDK_VERSION = "2.2.2" // x-release-please-version
 private let EVENT_SESSION_CHANGE = "onSessionChange"
 private let EVENT_CONNECTION_STATE_CHANGE = "onConnectionStateChange"
 private let EVENT_CONNECTION_ERROR = "onConnectionError"

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,20 +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>?
 
-  /// The `SPTAppRemote` awaiting an `authorizeAndPlay()` redirect, exposed
-  /// synchronously to the URL-redirect path. Mirrors the auth coordinator's
-  /// `nonisolated(unsafe)` `sessionManager`: it is only written from the
-  /// actor's executor (or the main-thread redirect handler) and read on the
-  /// main thread, so occasional cross-actor access is acceptable. `nil`
-  /// whenever no authorize-and-play flow is in flight.
-  nonisolated(unsafe) private var pendingAuthorizeRemote: SPTAppRemote?
+  /// 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"
 
@@ -76,195 +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() }
-    }
-  }
-
-  /// 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 {
-      // Already connected — honour the request by (re)starting playback.
-      if uri.isEmpty {
-        try await playerResume()
-      } else {
-        try await playerPlay(uri: uri)
-      }
-      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
-    pendingAuthorizeRemote = remote
-
-    try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
-      self.connectContinuation = cont
-      Task { @MainActor in
-        // `authorizeAndPlayURI` app-switches to Spotify to wake it. `success`
-        // is false when the Spotify app could not be opened (e.g. not
-        // installed) — no redirect will arrive, so fail the continuation now.
-        // On success we await the redirect, handled by
-        // `handleAuthorizeRedirect(_:)`, which completes the connection.
-        let success = await remote.authorizeAndPlayURI(uri)
-        if !success {
-          await self.didFailToConnect(error: NSError(
-            domain: "ExpoSpotifySDK",
-            code: -1,
-            userInfo: [NSLocalizedDescriptionKey: "authorizeAndPlay: could not open the Spotify app (is it installed?)"]
-          ))
-        }
-      }
-    }
-  }
-
-  /// 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).
-  ///
-  /// Synchronous + `nonisolated` because the AppDelegate `open url` hook
-  /// expects an immediate `Bool`, matching `SpotifyAuthCoordinator.handleOpenURL`.
-  nonisolated func handleAuthorizeRedirect(_ url: URL) -> Bool {
-    guard let remote = pendingAuthorizeRemote else { return false }
-    let consume: () -> Bool = { [self] in
-      MainActor.assumeIsolated {
-        let params = remote.authorizationParameters(from: url)
-        if let token = params?[SPTAppRemoteAccessTokenKey] {
-          remote.connectionParameters.accessToken = token
-          pendingAuthorizeRemote = nil
-          remote.connect()
-          return true
-        } else if let errorDescription = params?[SPTAppRemoteErrorDescriptionKey] {
-          pendingAuthorizeRemote = nil
-          Task {
-            await self.didFailToConnect(error: NSError(
-              domain: "ExpoSpotifySDK",
-              code: -2,
-              userInfo: [NSLocalizedDescriptionKey: errorDescription]
-            ))
-          }
-          return true
-        }
-        return false
-      }
-    }
-    if Thread.isMainThread {
-      return consume()
-    }
-    return DispatchQueue.main.sync(execute: consume)
-  }
-
-  func disconnect() {
-    if let cont = connectContinuation {
-      connectContinuation = nil
-      cont.resume(throwing: AppRemoteError.connectionFailed("Disconnected before connection completed"))
-    }
-    teardownPlayerSubscription()
-    teardownCapabilitiesSubscription()
-    appRemote?.disconnect()
-    appRemote = nil
-    pendingAuthorizeRemote = nil
-    transitionState("disconnected")
-  }
-
-  nonisolated func isConnected() -> Bool {
-    connectionStateString == "connected"
-  }
-
-  func getConnectionState() -> String {
-    connectionStateString
-  }
-
-  // MARK: — Connection delegate callbacks
-
-  func didConnect() {
-    pendingAuthorizeRemote = nil
-    transitionState("connected")
-    setupPlayerSubscription()
-    setupCapabilitiesSubscription()
-    let cont = connectContinuation
-    connectContinuation = nil
-    cont?.resume()
-  }
-
-  func didFailToConnect(error: Error?) {
-    appRemote = nil
-    pendingAuthorizeRemote = 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 })
@@ -277,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 })
@@ -598,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)\"") }
@@ -614,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

@@ -1,8 +1,8 @@
 {
   "ios": {
-    "spmRepositoryUrl": "https://github.com/spotify/ios-sdk.git",
-    "spmVersion": "5.0.1",
-    "spmProduct": "SpotifyiOS"
+    "version": "5.0.1",
+    "tarballSha256": "acafc07d35ce3f0bce93cac0031cd1cca1ba7ba6647a3e07e123f2e954ec298b",
+    "binarySha256": "988704167a3839136c7a4fd83742fca1422dfad48de41354ed07aa8e47611e32"
   },
   "android": {
     "appRemoteVersion": "0.8.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwdrew/expo-spotify-sdk",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "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",
@@ -20,7 +20,7 @@
     "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",
+    "prepublishOnly": "yarn clean && yarn build && yarn build:plugin && bash scripts/verify-npm-pack.sh",
     "typecheck": "tsc --noEmit",
     "open:ios": "open -a \"Xcode\" example/ios",
     "open:android": "open -a \"Android Studio\" example/android"
@@ -43,6 +43,7 @@
     "android/src",
     "android/libs/SETUP.md",
     "ios/spotify-native-sdk-versions.json",
+    "spotify-ios/SpotifyiOS.podspec",
     "ios/*.swift",
     "ios/*.podspec",
     "app.plugin.js",

package/plugin/build/ios/withSpotifyIosPod.d.ts

@@ -0,0 +1,9 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+export declare const PODFILE_SPOTIFY_IOS_TAG = "expo-spotify-sdk-spotify-ios-pod";
+/**
+ * Standard CocoaPods binary pod — SpotifyiOS.podspec uses `source: { http: ... }`
+ * so CocoaPods downloads and runs `prepare_command` (unlike `:path` pods).
+ */
+export declare const PODFILE_SPOTIFY_IOS_POD = "  pod 'SpotifyiOS', :podspec => File.join(__dir__, '../node_modules/@wwdrew/expo-spotify-sdk/spotify-ios/SpotifyiOS.podspec')";
+export declare function applySpotifyIosPod(podfileContents: string): string;
+export declare const withSpotifyIosPod: ConfigPlugin;

package/plugin/build/ios/withSpotifyIosPod.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSpotifyIosPod = exports.PODFILE_SPOTIFY_IOS_POD = exports.PODFILE_SPOTIFY_IOS_TAG = void 0;
+exports.applySpotifyIosPod = applySpotifyIosPod;
+const config_plugins_1 = require("@expo/config-plugins");
+const generateCode_1 = require("@expo/config-plugins/build/utils/generateCode");
+exports.PODFILE_SPOTIFY_IOS_TAG = "expo-spotify-sdk-spotify-ios-pod";
+/**
+ * Standard CocoaPods binary pod — SpotifyiOS.podspec uses `source: { http: ... }`
+ * so CocoaPods downloads and runs `prepare_command` (unlike `:path` pods).
+ */
+exports.PODFILE_SPOTIFY_IOS_POD = `  pod 'SpotifyiOS', :podspec => File.join(__dir__, '../node_modules/@wwdrew/expo-spotify-sdk/spotify-ios/SpotifyiOS.podspec')`;
+function applySpotifyIosPod(podfileContents) {
+    const merged = (0, generateCode_1.mergeContents)({
+        tag: exports.PODFILE_SPOTIFY_IOS_TAG,
+        src: podfileContents,
+        newSrc: exports.PODFILE_SPOTIFY_IOS_POD,
+        anchor: /use_expo_modules!/,
+        offset: 1,
+        comment: "#",
+    });
+    return merged.didMerge || merged.didClear
+        ? merged.contents
+        : podfileContents;
+}
+const withSpotifyIosPod = (config) => {
+    return (0, config_plugins_1.withPodfile)(config, (config) => {
+        config.modResults.contents = applySpotifyIosPod(config.modResults.contents);
+        return config;
+    });
+};
+exports.withSpotifyIosPod = withSpotifyIosPod;

package/plugin/build/withSpotifySdkConfig.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSpotifySdkConfig = void 0;
 const withSpotifyAndroidAppBuildGradle_1 = require("./android/withSpotifyAndroidAppBuildGradle");
 const withSpotifyConfigValues_1 = require("./ios/withSpotifyConfigValues");
+const withSpotifyIosPod_1 = require("./ios/withSpotifyIosPod");
 const withSpotifyQueryScheme_1 = require("./ios/withSpotifyQueryScheme");
 const withSpotifyURLScheme_1 = require("./ios/withSpotifyURLScheme");
 const withSpotifySdkConfig = (config, spotifyConfig) => {
@@ -18,6 +19,7 @@ const withSpotifySdkConfig = (config, spotifyConfig) => {
     // Android specific
     config = (0, withSpotifyAndroidAppBuildGradle_1.withSpotifyAndroidAppBuildGradle)(config, spotifyConfig);
     // iOS specific
+    config = (0, withSpotifyIosPod_1.withSpotifyIosPod)(config);
     config = (0, withSpotifyConfigValues_1.withSpotifyConfigValues)(config, spotifyConfig);
     config = (0, withSpotifyQueryScheme_1.withSpotifyQueryScheme)(config, spotifyConfig);
     config = (0, withSpotifyURLScheme_1.withSpotifyURLScheme)(config, spotifyConfig);

package/spotify-ios/SpotifyiOS.podspec

@@ -0,0 +1,37 @@
+require 'json'
+
+pins = JSON.parse(File.read(File.join(__dir__, '..', 'ios', 'spotify-native-sdk-versions.json')))['ios']
+version = pins['version']
+tag = "v#{version}"
+
+Pod::Spec.new do |s|
+  s.name             = 'SpotifyiOS'
+  s.version          = version
+  s.summary          = 'Spotify iOS SDK (binary pod for @wwdrew/expo-spotify-sdk)'
+  s.homepage         = 'https://github.com/spotify/ios-sdk'
+  s.license          = { :type => 'Proprietary' }
+  s.author           = 'Spotify'
+  s.platform         = :ios, '16.4'
+  s.static_framework = true
+
+  s.source = {
+    :http => "https://github.com/spotify/ios-sdk/archive/refs/tags/#{tag}.tar.gz",
+  }
+
+  s.prepare_command = <<-CMD
+    set -e
+    if [ ! -d SpotifyiOS.xcframework ]; then
+      framework="$(find . -name 'SpotifyiOS.xcframework' -type d | head -1)"
+      test -n "$framework"
+      mv "$framework" .
+    fi
+    if [ ! -d Licenses ]; then
+      licenses="$(find . -path '*/Licenses' -type d | head -1)"
+      if [ -n "$licenses" ]; then mv "$licenses" .; fi
+    fi
+    find . -mindepth 1 -maxdepth 1 ! -name 'SpotifyiOS.xcframework' ! -name 'Licenses' -exec rm -rf {} +
+  CMD
+
+  s.vendored_frameworks = 'SpotifyiOS.xcframework'
+  s.preserve_paths = 'Licenses'
+end