@wwdrew/expo-spotify-sdk 0.4.3 → 0.6.0

package/ios/SPTScopeSerializer.swift

@@ -1,44 +1,45 @@
+import Foundation
 import SpotifyiOS
 
-class SPTScopeSerializer {
-    static let scopeMap: [String: SPTScope] = [
-        "playlist-read-private": .playlistReadPrivate,
-        "playlist-read-collaborative": .playlistReadCollaborative,
-        "playlist-modify-public": .playlistModifyPublic,
-        "playlist-modify-private": .playlistModifyPrivate,
-        "user-follow-read": .userFollowRead,
-        "user-follow-modify": .userFollowModify,
-        "user-library-read": .userLibraryRead,
-        "user-library-modify": .userLibraryModify,
-        "user-read-email": .userReadEmail,
-        "user-read-private": .userReadPrivate,
-        "user-top-read": .userTopRead,
-        "ugc-image-upload": .ugcImageUpload,
-        "streaming": .streaming,
-        "app-remote-control": .appRemoteControl,
-        "user-read-playback-state": .userReadPlaybackState,
-        "user-modify-playback-state": .userModifyPlaybackState,
-        "user-read-currently-playing": .userReadCurrentlyPlaying,
-        "user-read-recently-played": .userReadRecentlyPlayed,
-    ]
-    
-    static func serializeScopes(_ scopes: SPTScope) -> [String] {
-        var serializedScopes = [String]()
-        for (scopeString, scopeValue) in scopeMap {
-            if scopes.contains(scopeValue) {
-                serializedScopes.append(scopeString)
-            }
-        }
-        return serializedScopes
+enum SPTScopeSerializer {
+  /// Single source of truth for the string ↔ SPTScope mapping. Order is
+  /// preserved on round-trip via `serialize` (sorted alphabetically) so output
+  /// is deterministic.
+  static let scopeMap: [(String, SPTScope)] = [
+    ("app-remote-control", .appRemoteControl),
+    ("playlist-modify-private", .playlistModifyPrivate),
+    ("playlist-modify-public", .playlistModifyPublic),
+    ("playlist-read-collaborative", .playlistReadCollaborative),
+    ("playlist-read-private", .playlistReadPrivate),
+    ("streaming", .streaming),
+    ("ugc-image-upload", .ugcImageUpload),
+    ("user-follow-modify", .userFollowModify),
+    ("user-follow-read", .userFollowRead),
+    ("user-library-modify", .userLibraryModify),
+    ("user-library-read", .userLibraryRead),
+    ("user-modify-playback-state", .userModifyPlaybackState),
+    ("user-read-currently-playing", .userReadCurrentlyPlaying),
+    ("user-read-email", .userReadEmail),
+    ("user-read-playback-state", .userReadPlaybackState),
+    ("user-read-private", .userReadPrivate),
+    ("user-read-recently-played", .userReadRecentlyPlayed),
+    ("user-top-read", .userTopRead),
+  ]
+
+  static func serialize(_ scopes: SPTScope) -> [String] {
+    scopeMap.compactMap { (string, value) in
+      scopes.contains(value) ? string : nil
     }
-    
-    static func deserializeScopes(_ scopes: [String]) -> SPTScope {
-        var deserializedScopes: SPTScope = []
-        for scopeString in scopes {
-            if let scopeValue = scopeMap[scopeString] {
-                deserializedScopes.insert(scopeValue)
-            }
-        }
-        return deserializedScopes
+  }
+
+  static func deserialize(_ scopes: [String]) -> SPTScope {
+    var result: SPTScope = []
+    let lookup = Dictionary(uniqueKeysWithValues: scopeMap)
+    for string in scopes {
+      if let value = lookup[string] {
+        result.insert(value)
+      }
     }
+    return result
+  }
 }

package/ios/SpotifyAuthCoordinator.swift

@@ -0,0 +1,133 @@
+import Foundation
+import SpotifyiOS
+
+/// Public, structured errors thrown by the coordinator. Each case carries the
+/// JS-facing error code in `code`, mirroring the Android `CodedException`
+/// taxonomy.
+enum SpotifyError: Error {
+  case invalidConfiguration(String)
+  case authInProgress
+  case userCancelled
+  case spotifyNotInstalled
+  case underlying(Error)
+
+  var code: String {
+    switch self {
+    case .invalidConfiguration: return "INVALID_CONFIG"
+    case .authInProgress:       return "AUTH_IN_PROGRESS"
+    case .userCancelled:        return "USER_CANCELLED"
+    case .spotifyNotInstalled:  return "SPOTIFY_NOT_INSTALLED"
+    case .underlying:           return "UNKNOWN"
+    }
+  }
+
+  var message: String {
+    switch self {
+    case .invalidConfiguration(let m): return m
+    case .authInProgress:              return "Another authentication request is already in progress"
+    case .userCancelled:               return "Authentication was cancelled by the user"
+    case .spotifyNotInstalled:         return "The Spotify app is not installed on this device"
+    case .underlying(let err):         return err.localizedDescription
+    }
+  }
+}
+
+/// `actor` ensures `pending` is mutated only on the actor's serial executor;
+/// no manual locks needed.
+actor SpotifyAuthCoordinator {
+  static let shared: SpotifyAuthCoordinator? = SpotifyAuthCoordinator.create()
+
+  private let sptConfiguration: SPTConfiguration
+  private let sessionManager: SPTSessionManager
+  private let bridge: SpotifySessionDelegateBridge
+  private var pending: CheckedContinuation<SPTSession, Error>?
+
+  private init(sptConfiguration: SPTConfiguration, sessionManager: SPTSessionManager, bridge: SpotifySessionDelegateBridge) {
+    self.sptConfiguration = sptConfiguration
+    self.sessionManager = sessionManager
+    self.bridge = bridge
+    bridge.coordinator = self
+  }
+
+  private static func create() -> SpotifyAuthCoordinator? {
+    guard
+      let configuration = ExpoSpotifyConfiguration.fromInfoPlist(),
+      let sptConfig = configuration.sptConfiguration
+    else {
+      NSLog("[ExpoSpotifySDK] Missing or invalid `ExpoSpotifySDK` Info.plist entry")
+      return nil
+    }
+    let bridge = SpotifySessionDelegateBridge()
+    let manager = SPTSessionManager(configuration: sptConfig, delegate: bridge)
+    return SpotifyAuthCoordinator(sptConfiguration: sptConfig, sessionManager: manager, bridge: bridge)
+  }
+
+  /// Synchronous getter used by the module's `Function("isAvailable")`. Safe
+  /// to call from any thread because the underlying SDK property is read-only
+  /// state derived from the installed-apps query.
+  nonisolated func isSpotifyAppInstalled() -> Bool {
+    sessionManager.isSpotifyAppInstalled
+  }
+
+  /// 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 {
+    sessionManager.application(UIApplication.shared, open: url, options: options)
+  }
+
+  func authenticate(
+    scopes: SPTScope,
+    tokenSwapURL: URL?,
+    tokenRefreshURL: URL?
+  ) async throws -> SPTSession {
+    guard pending == nil else { throw SpotifyError.authInProgress }
+
+    // SPTConfiguration is a reference type shared with the session manager, so
+    // mutating it here takes effect for the upcoming initiateSession call.
+    sptConfiguration.tokenSwapURL = tokenSwapURL
+    sptConfiguration.tokenRefreshURL = tokenRefreshURL
+
+    return try await withCheckedThrowingContinuation { (cont: CheckedContinuation<SPTSession, Error>) in
+      self.pending = cont
+      Task { @MainActor in
+        self.sessionManager.initiateSession(with: scopes, options: .default, campaign: nil)
+      }
+    }
+  }
+
+  func deliver(_ result: Result<SPTSession, Error>) {
+    let cont = pending
+    pending = nil
+    cont?.resume(with: result)
+  }
+}
+
+/// `SPTSessionManagerDelegate` requires NSObject conformance, which an actor
+/// can't satisfy directly. The bridge is a tiny NSObject that hops the call
+/// onto the actor's executor.
+final class SpotifySessionDelegateBridge: NSObject, SPTSessionManagerDelegate {
+  weak var coordinator: SpotifyAuthCoordinator?
+
+  func sessionManager(manager _: SPTSessionManager, didInitiate session: SPTSession) {
+    Task { await coordinator?.deliver(.success(session)) }
+  }
+
+  func sessionManager(manager _: SPTSessionManager, didFailWith error: Error) {
+    let mapped: Error = mapSDKError(error)
+    Task { await coordinator?.deliver(.failure(mapped)) }
+  }
+
+  func sessionManager(manager _: SPTSessionManager, didRenew session: SPTSession) {
+    Task { await coordinator?.deliver(.success(session)) }
+  }
+
+  /// Translate a few well-known SDK error shapes into our taxonomy.
+  private func mapSDKError(_ error: Error) -> Error {
+    let nsError = error as NSError
+    let description = nsError.localizedDescription.lowercased()
+    if description.contains("cancel") {
+      return SpotifyError.userCancelled
+    }
+    return SpotifyError.underlying(error)
+  }
+}

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

@@ -5,35 +5,31 @@
 	<key>AvailableLibraries</key>
 	<array>
 		<dict>
-			<key>BinaryPath</key>
-			<string>SpotifyiOS.framework/SpotifyiOS</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</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>
 		<dict>
-			<key>BinaryPath</key>
-			<string>SpotifyiOS.framework/SpotifyiOS</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<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>

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemote.h

@@ -12,18 +12,18 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-extern NSString * const SPTAppRemoteAccessTokenKey;
-extern NSString * const SPTAppRemoteErrorKey;
-extern NSString * const SPTAppRemoteErrorDescriptionKey;
+extern NSString *const SPTAppRemoteAccessTokenKey;
+extern NSString *const SPTAppRemoteErrorKey;
+extern NSString *const SPTAppRemoteErrorDescriptionKey;
 
 /// The severity of log messages that the App Remote should log to console.
 typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
     /// Do not log at all.
-    SPTAppRemoteLogLevelNone  = 0,
+    SPTAppRemoteLogLevelNone = 0,
     /// Log debug, info and error messages.
     SPTAppRemoteLogLevelDebug = 1,
     /// Log info and error messages.
-    SPTAppRemoteLogLevelInfo  = 2,
+    SPTAppRemoteLogLevelInfo = 2,
     /// Log only error messages.
     SPTAppRemoteLogLevelError = 3,
 };
@@ -63,7 +63,8 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
 @end
 
 /**
- *  The `SPTAppRemote` is the main entry point for interacting with the Spotify app using the Spotify App Remote for iOS.
+ *  The `SPTAppRemote` is the main entry point for interacting with the Spotify app using the Spotify App Remote for
+ * iOS.
  */
 @interface SPTAppRemote : NSObject
 
@@ -83,7 +84,8 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
  *  Designated Initializer for a new App Remote instance
  *
  *  @param configuration The `SPTConfiguration` to use for client-id's and redirect URLs
- *  @param connectionParameters `SPTAppRemoteConnectionParams` for custom image sizes and types, and to hold the accessToken
+ *  @param connectionParameters `SPTAppRemoteConnectionParams` for custom image sizes and types, and to hold the
+ * accessToken
  *  @param logLevel The lowest severity to log to console.
  *
  *  @return A fresh new App Remote, ready to connect.
@@ -93,15 +95,6 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
                              logLevel:(SPTAppRemoteLogLevel)logLevel NS_DESIGNATED_INITIALIZER;
 #pragma mark Class Methods
 
-/**
- * Checks if the Spotify app is active on the user's device. You can use this to determine if maybe you should prompt
- * the user to connect to Spotify (because you know they are already using Spotify if it is active). The Spotify app
- * will be considered active if music is playing or the app is active in the background.
- *
- * @param completion Completion block for determining the result of the check. YES if Spotify is active, othewise NO.
- */
-+ (void)checkIfSpotifyAppIsActive:(void (^)(BOOL active))completion;
-
 /**
  * Determine the current version of the Spotify App Remote
  *
@@ -110,9 +103,11 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
 + (NSString *)appRemoteVersion;
 
 /**
- * The Spotify app iTunes item identifier for use with `SKStoreProductViewController` for installing Spotify from the App Store.
+ * The Spotify app iTunes item identifier for use with `SKStoreProductViewController` for installing Spotify from the
+ * App Store.
  *
- * @return An `NSNumber` representing the Spotify iTunes item identifier to be used for the `SKStoreProductParameterITunesItemIdentifier` key
+ * @return An `NSNumber` representing the Spotify iTunes item identifier to be used for the
+ * `SKStoreProductParameterITunesItemIdentifier` key
  */
 + (NSNumber *)spotifyItunesItemIdentifier;
 
@@ -149,7 +144,8 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
  *
  * @discussion If the Spotify app is not running you will need to use authorizeAndPlayURI: to wake it up.
  *
- * @discussion If `authorizeAndPlayURI` was used without a given session identifier, `connect` should be used instead of this method.
+ * @discussion If `authorizeAndPlayURI` was used without a given session identifier, `connect` should be used instead of
+ * this method.
  *
  * @param sessionIdentifier The unique session identifier which was used when calling
  * `authorizeAndPlayURI:asRadio:additionalScopes:sessionIdentifier:`
@@ -166,62 +162,68 @@ typedef NS_ENUM(NSUInteger, SPTAppRemoteLogLevel) {
  * The passed URI will start playing unless Spotify is already playing.
  *
  * @param URI The URI to play. Use a blank string to attempt to play the user's last song
- * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise
+ * `NO`.
  *
  * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
  * the Spotify app is installed and can attempt to handle the authorization request.
  */
-- (void)authorizeAndPlayURI:(NSString *)URI completionHandler:(void (^ __nullable)(BOOL success))completionHandler;
+- (void)authorizeAndPlayURI:(NSString *)URI completionHandler:(void (^__nullable)(BOOL success))completionHandler;
 
 /**
  * Open Spotify app to obtain access token and start playback.
  *
  * @param playURI The URI to play. Use a blank string to attempt to play the user's last song
  * @param asRadio `YES` to start radio for the given URI.
- * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise
+ * `NO`.
  *
  * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
  * the Spotify app is installed and can attempt to handle the authorization request.
  */
 - (void)authorizeAndPlayURI:(NSString *)playURI
                     asRadio:(BOOL)asRadio
-          completionHandler:(void (^ __nullable)(BOOL success))completionHandler;
+          completionHandler:(void (^__nullable)(BOOL success))completionHandler;
 
 /**
-* Open Spotify app to obtain access token and start playback.
-*
-* @param playURI The URI to play. Use a blank string to attempt to play the user's last song
-* @param asRadio `YES` to start radio for the given URI.
-* @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need `app-remote-control`
-* @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
-*
-* Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
-* the Spotify app is installed and can attempt to handle the authorization request.
-*/
+ * Open Spotify app to obtain access token and start playback.
+ *
+ * @param playURI The URI to play. Use a blank string to attempt to play the user's last song
+ * @param asRadio `YES` to start radio for the given URI.
+ * @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need
+ * `app-remote-control`
+ * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise
+ * `NO`.
+ *
+ * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
+ * the Spotify app is installed and can attempt to handle the authorization request.
+ */
 - (void)authorizeAndPlayURI:(NSString *)playURI
                     asRadio:(BOOL)asRadio
            additionalScopes:(nullable NSArray<NSString *> *)additionalScopes
-          completionHandler:(void (^ __nullable)(BOOL success))completionHandler;
+          completionHandler:(void (^__nullable)(BOOL success))completionHandler;
 
 /**
  * Open Spotify app to obtain access token and start playback.
  *
  * @param playURI The URI to play. Use a blank string to attempt to play the user's last song
  * @param asRadio `YES` to start radio for the given URI.
- * @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need `app-remote-control`
- * @param sessionIdentifier An optional unique identifier for this specific session, which is used for analytics purposes. Every new attempt to
- * connect to the Spotify app should have a new identifier, but the identifier used here should then be reused for the accompanied call to
- * `connectWithSessionIdentifier:`.
- * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise `NO`.
+ * @param additionalScopes An array of scopes in addition to `app-remote-control`. Can be nil if you only need
+ * `app-remote-control`
+ * @param sessionIdentifier An optional unique identifier for this specific session, which is used for analytics
+ * purposes. Every new attempt to connect to the Spotify app should have a new identifier, but the identifier used here
+ * should then be reused for the accompanied call to `connectWithSessionIdentifier:`.
+ * @param completionHandler `YES` if the Spotify app is installed and an authorization attempt can be made, otherwise
+ * `NO`.
  *
  * Note: The return `BOOL` here is not a measure of whether or not authentication succeeded, only a check if
  * the Spotify app is installed and can attempt to handle the authorization request.
-*/
+ */
 - (void)authorizeAndPlayURI:(NSString *)playURI
                     asRadio:(BOOL)asRadio
            additionalScopes:(nullable NSArray<NSString *> *)additionalScopes
           sessionIdentifier:(nullable NSUUID *)sessionIdentifier
-          completionHandler:(void (^ __nullable)(BOOL success))completionHandler;
+          completionHandler:(void (^__nullable)(BOOL success))completionHandler;
 /**
  * Parse out an access token or error description from a url passed to application:openURL:options:
  *

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteCommon.h

@@ -1,3 +1,5 @@
+#import <Foundation/Foundation.h>
+
 /**
  * Common header definitions
  */
@@ -5,23 +7,23 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// The error domain for user facing errors that occur in the App Remote.
-extern NSString * const SPTAppRemoteErrorDomain;
+extern NSString *const SPTAppRemoteErrorDomain;
 
 /// The error codes in the `SPTAppRemoteErrorDomain` domain.
 typedef NS_ENUM(NSInteger, SPTAppRemoteErrorCode) {
     /// An unknown error.
-    SPTAppRemoteUnknownError                 =    -1,
+    SPTAppRemoteUnknownError = -1,
 
     /// The background wakeup of the Spotify app failed.
-    SPTAppRemoteBackgroundWakeupFailedError  = -1000,
+    SPTAppRemoteBackgroundWakeupFailedError = -1000,
     /// The connection attempt to the Spotify app failed.
     SPTAppRemoteConnectionAttemptFailedError = -1001,
     /// The conncetion to the Spotify app was terminated.
-    SPTAppRemoteConnectionTerminatedError    = -1002,
+    SPTAppRemoteConnectionTerminatedError = -1002,
     /// The arguments supplied are invalid.
-    SPTAppRemoteInvalidArgumentsError        = -2000,
+    SPTAppRemoteInvalidArgumentsError = -2000,
     /// The request has failed for some reason.
-    SPTAppRemoteRequestFailedError           = -2001,
+    SPTAppRemoteRequestFailedError = -2001,
 };
 
 /**
@@ -30,7 +32,6 @@ typedef NS_ENUM(NSInteger, SPTAppRemoteErrorCode) {
  *  @param result The result of the operation, or `nil` if the operation failed.
  *  @param error  An error object, or `nil` if the operation was a success.
  */
-typedef void (^SPTAppRemoteCallback)(id _Nullable result, NSError * _Nullable error);
+typedef void (^SPTAppRemoteCallback)(id _Nullable result, NSError *_Nullable error);
 
 NS_ASSUME_NONNULL_END
-

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteConnectivityAPI.h

@@ -1,5 +1,4 @@
 #import <Foundation/Foundation.h>
-
 #import "SPTAppRemoteCommon.h"
 
 @protocol SPTAppRemoteConnectivityAPI;
@@ -8,7 +7,8 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * The `SPTAppRemoteConnectivityAPIDelegate` gets notified whenever the connectivity API receives new data from subscription events.
+ * The `SPTAppRemoteConnectivityAPIDelegate` gets notified whenever the connectivity API receives new data from
+ * subscription events.
  */
 @protocol SPTAppRemoteConnectivityAPIDelegate <NSObject>
 
@@ -18,7 +18,8 @@ NS_ASSUME_NONNULL_BEGIN
  * @param connectivityAPI The API that received updates.
  * @param connectivityState The new connectivity state received.
  */
-- (void)connectivityAPI:(id<SPTAppRemoteConnectivityAPI>)connectivityAPI didReceiveNewConnectivityState:(id<SPTAppRemoteConnectivityState>)connectivityState;
+- (void)connectivityAPI:(id<SPTAppRemoteConnectivityAPI>)connectivityAPI
+    didReceiveNewConnectivityState:(id<SPTAppRemoteConnectivityState>)connectivityState;
 
 @end
 

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteContentAPI.h

@@ -4,12 +4,12 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// A type representing different lists of content.
-typedef NSString * const SPTAppRemoteContentType;
+typedef NSString *const SPTAppRemoteContentType;
 
-extern NSString * const SPTAppRemoteContentTypeDefault;
-extern NSString * const SPTAppRemoteContentTypeNavigation;
-extern NSString * const SPTAppRemoteContentTypeFitness;
-extern NSString * const SPTAppRemoteContentTypeGaming;
+extern NSString *const SPTAppRemoteContentTypeDefault;
+extern NSString *const SPTAppRemoteContentTypeNavigation;
+extern NSString *const SPTAppRemoteContentTypeFitness;
+extern NSString *const SPTAppRemoteContentTypeGaming;
 
 @protocol SPTAppRemoteContentItem;
 
@@ -31,7 +31,9 @@ extern NSString * const SPTAppRemoteContentTypeGaming;
  * @param callback The callback to be called once the request is completed.
  */
 - (void)fetchRootContentItemsForType:(SPTAppRemoteContentType)contentType
-                            callback:(nullable SPTAppRemoteCallback)callback DEPRECATED_MSG_ATTRIBUTE("Deprecated. Use fetchRecommendedContentItemsForType:flattenContainers:callback: instead.");
+                            callback:(nullable SPTAppRemoteCallback)callback
+    DEPRECATED_MSG_ATTRIBUTE(
+        "Deprecated. Use fetchRecommendedContentItemsForType:flattenContainers:callback: instead.");
 
 /**
  * Fetches the children items for the provided content item.

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteContentItem.h

@@ -4,8 +4,8 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * The `SPTAppRemoteContentItem` protocol represents a track or a collection of tracks. Use the `isContainer` instance method
- * to determine if the content item is a collection of tracks for which to grab children from.
+ * The `SPTAppRemoteContentItem` protocol represents a track or a collection of tracks. Use the `isContainer` instance
+ * method to determine if the content item is a collection of tracks for which to grab children from.
  */
 @protocol SPTAppRemoteContentItem <NSObject, SPTAppRemoteImageRepresentable>
 
@@ -33,7 +33,7 @@ NS_ASSUME_NONNULL_BEGIN
 /// Returns `YES` if the item is expected to contain children, otherwise `NO`.
 @property (nonatomic, assign, readonly, getter=isContainer) BOOL container;
 
-/// Returns `YES` if the item is pinned in Your Library, otherwise `NO`. 
+/// Returns `YES` if the item is pinned in Your Library, otherwise `NO`.
 @property (nonatomic, assign, readonly, getter=isPinned) BOOL pinnned;
 
 /**

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemoteImageAPI.h

@@ -1,5 +1,3 @@
-#import <UIKit/UIKit.h>
-
 #import "SPTAppRemoteCommon.h"
 #import "SPTAppRemoteImageRepresentable.h"
 
@@ -18,7 +16,9 @@ NS_ASSUME_NONNULL_BEGIN
  * @param callback On success `result` will be an instance of `UIImage`
  *                 On error `result` will be nil and error set
  */
-- (void)fetchImageForItem:(id<SPTAppRemoteImageRepresentable>)imageRepresentable withSize:(CGSize)imageSize callback:(nullable SPTAppRemoteCallback)callback;
+- (void)fetchImageForItem:(id<SPTAppRemoteImageRepresentable>)imageRepresentable
+                 withSize:(CGSize)imageSize
+                 callback:(nullable SPTAppRemoteCallback)callback;
 
 @end
 

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTAppRemotePlayerAPI.h

@@ -1,14 +1,15 @@
 #import <Foundation/Foundation.h>
-
 #import "SPTAppRemoteCommon.h"
 #import "SPTAppRemotePlaybackOptions.h"
 
-@protocol SPTAppRemotePlayerState, SPTAppRemoteContentItem, SPTAppRemotePodcastPlaybackSpeed;
+@protocol SPTAppRemotePlayerState
+, SPTAppRemoteContentItem, SPTAppRemotePodcastPlaybackSpeed;
 
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * The `SPTAppRemotePlayerStateDelegate` is used to get notifications from the Spotify app when the player state is changed.
+ * The `SPTAppRemotePlayerStateDelegate` is used to get notifications from the Spotify app when the player state is
+ * changed.
  */
 @protocol SPTAppRemotePlayerStateDelegate <NSObject>
 
@@ -84,7 +85,9 @@ NS_ASSUME_NONNULL_BEGIN
  * @param callback         On success `result` will be `YES`.
  *                         On error `result` will be `nil` and error set
  */
-- (void)playItem:(id<SPTAppRemoteContentItem>)contentItem skipToTrackIndex:(NSInteger) index callback:(nullable SPTAppRemoteCallback)callback;
+- (void)playItem:(id<SPTAppRemoteContentItem>)contentItem
+    skipToTrackIndex:(NSInteger)index
+            callback:(nullable SPTAppRemoteCallback)callback;
 
 /**
  * Asks the Spotify player to resume playback.
@@ -175,7 +178,8 @@ NS_ASSUME_NONNULL_BEGIN
  *  @param callback On success `result` will be `YES`.
  *                  On error `result` will be `nil` and `error` will be set.
  */
-- (void)setRepeatMode:(SPTAppRemotePlaybackOptionsRepeatMode)repeatMode callback:(nullable SPTAppRemoteCallback)callback;
+- (void)setRepeatMode:(SPTAppRemotePlaybackOptionsRepeatMode)repeatMode
+             callback:(nullable SPTAppRemoteCallback)callback;
 
 #pragma mark Player State
 
@@ -213,7 +217,7 @@ NS_ASSUME_NONNULL_BEGIN
  * @param callback On success `result` will be `YES`
  *                 On error `result` will be `nil` and error set
  */
-- (void)enqueueTrackUri:(NSString*)trackUri callback:(nullable SPTAppRemoteCallback)callback;
+- (void)enqueueTrackUri:(NSString *)trackUri callback:(nullable SPTAppRemoteCallback)callback;
 
 /**
  * Asks the Spotify player for available podcast playback speeds
@@ -247,7 +251,8 @@ NS_ASSUME_NONNULL_BEGIN
  * @param callback  On success `result` will be `YES`.
  *                  On error `result` will be `nil` and `error` set
  */
-- (void)setPodcastPlaybackSpeed:(nonnull id<SPTAppRemotePodcastPlaybackSpeed>)speed callback:(nullable SPTAppRemoteCallback)callback;
+- (void)setPodcastPlaybackSpeed:(nonnull id<SPTAppRemotePodcastPlaybackSpeed>)speed
+                       callback:(nullable SPTAppRemoteCallback)callback;
 
 /**
  * Asks the Spotify player for the current crossfade state.