@wwdrew/expo-spotify-sdk 0.1.0

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTLogin.h

@@ -0,0 +1,10 @@
+#ifndef _SPOTIFYLOGIN_
+#define _SPOTIFYLOGIN_
+
+#import "SPTConfiguration.h"
+#import "SPTError.h"
+#import "SPTScope.h"
+#import "SPTSession.h"
+#import "SPTSessionManager.h"
+
+#endif /* _SPOTIFYLOGIN_ */

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTMacros.h

@@ -0,0 +1,89 @@
+#ifndef SPT_MACROS
+#define SPT_MACROS
+
+#ifdef __cplusplus
+#define SPT_EXPORT extern "C" __attribute__((visibility("default")))
+#else
+#define SPT_EXPORT extern __attribute__((visibility("default")))
+#endif // __cplusplus
+
+#define SPT_DEPRECATED(MESSAGE) __attribute__((deprecated(MESSAGE)))
+#define SPT_UNAVAILABLE __attribute__((unavailable))
+#define SPT_UNUSED __attribute__((unused))
+#define SPT_UNREACHABLE() __builtin_unreachable()
+
+#define SPT_INLINE __attribute__((always_inline)) inline
+#define SPT_CONST __attribute__((const))
+#define SPT_PURE __attribute__((pure))
+
+#define SPT_NONNULL __attribute__((nonnull))
+#define SPT_RETURNS_NONNULL __attribute__((returns_nonnull))
+
+#define SPT_EXPECT(EXPR, VAL) __builtin_expect(!!(EXPR), VAL)
+#define SPT_LIKELY(EXPR) SPT_EXPECT(EXPR, 1)
+#define SPT_UNLIKELY(EXPR) SPT_EXPECT(EXPR, 0)
+
+#define SPT_MAX_POW2(TYPE_MAX) ((TYPE_MAX >> 1) ^ TYPE_MAX)
+
+#define SPT_EXPR_OR_ZERO(EXPR) __builtin_choose_expr(SPT_TYPE_IS_VOID(EXPR), 0, (EXPR))
+#define SPT_TYPE_IS_VOID(EXPR) __builtin_types_compatible_p(typeof(EXPR), void)
+
+/**
+ Check if the receiver responds to a selector, then send the message,
+ along with the provided parameters.
+
+ The purpose of this macro, other than to make code less cluttered, is to make
+ it impossible to accidentally check for a selector but send a different message.
+
+ @param RECEIVER The object to which the message will be sent.
+ @param RESULT[out] A pointer to which the return value will be assigned.
+ @param ... 0-4 arguments.
+ \code{.m}
+    BOOL result = NO;
+    SPT_OPTIONAL_MESSAGE_SEND(self.delegate, &result, someThingie, self, didSomethingWith, someObject);
+    // Expands to the following:
+    do {
+        if ([self.delegate respondsToSelector:@selector(someThingie:didSomethingWith:)])
+            *(result) = [self.delegate someThingie:self didSomethingWith:someObject)];
+    } while (0);
+ \endcode
+*/
+#define SPT_OPTIONAL_MESSAGE_SEND(RECEIVER, RESULT, ...) do { \
+    if ([RECEIVER respondsToSelector:@selector(SPT_CONCAT_SELECTOR(__VA_ARGS__))]) \
+        *(RESULT) = [RECEIVER SPT_CONCAT_METHOD(__VA_ARGS__)]; \
+} while (0)
+
+/**
+ Like SPT_OPTIONAL_MESSAGE_SEND but ignores the return value.
+ @param RECEIVER The object to which the message will be sent.
+ @param ... 0-4 arguments.
+*/
+#define SPT_OPTIONAL_MESSAGE_SEND_(RECEIVER, ...) do { \
+    if ([RECEIVER respondsToSelector:@selector(SPT_CONCAT_SELECTOR(__VA_ARGS__))]) \
+        [RECEIVER SPT_CONCAT_METHOD(__VA_ARGS__)]; \
+} while (0)
+
+// Some boilerplate for SPT_OPTIONAL_MESSAGE_SEND[_]
+#define SPT_CONCAT_METHOD8(A, _1, B, _2, C, _3, D, _4) A:_1 B:_2 C:_3 D:_4
+#define SPT_CONCAT_METHOD6(A, _1, B, _2, C, _3) A:_1 B:_2 C:_3
+#define SPT_CONCAT_METHOD4(A, _1, B, _2) A:_1 B:_2
+#define SPT_CONCAT_METHOD2(A, _1) A:_1
+#define SPT_CONCAT_METHOD1(A) A
+
+#define SPT_CONCAT_SELECTOR8(A, _1, B, _2, C, _3, D, _4) A:B:C:D:
+#define SPT_CONCAT_SELECTOR6(A, _1, B, _2, C, _3) A:B:C:
+#define SPT_CONCAT_SELECTOR4(A, _1, B, _2) A:B:
+#define SPT_CONCAT_SELECTOR2(A, _1) A:
+#define SPT_CONCAT_SELECTOR1(A) A
+
+#define SPT_PICK_CONCAT_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, NAME, ...) NAME
+
+#define SPT_CONCAT_METHOD(...) SPT_PICK_CONCAT_MACRO(__VA_ARGS__, \
+    SPT_CONCAT_METHOD8, SPT_CONCAT_METHOD7, SPT_CONCAT_METHOD6, SPT_CONCAT_METHOD5, \
+    SPT_CONCAT_METHOD4, SPT_CONCAT_METHOD3, SPT_CONCAT_METHOD2, SPT_CONCAT_METHOD1)(__VA_ARGS__)
+
+#define SPT_CONCAT_SELECTOR(...) SPT_PICK_CONCAT_MACRO(__VA_ARGS__, \
+    SPT_CONCAT_SELECTOR8, SPT_CONCAT_SELECTOR7, SPT_CONCAT_SELECTOR6, SPT_CONCAT_SELECTOR5, \
+    SPT_CONCAT_SELECTOR4, SPT_CONCAT_SELECTOR3, SPT_CONCAT_SELECTOR2, SPT_CONCAT_SELECTOR1)(__VA_ARGS__)
+
+#endif // SPT_MACROS

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTScope.h

@@ -0,0 +1,71 @@
+// (Objective-C identifier, Swift name, string value, bit flag)
+#define SPT_SCOPE_LIST \
+SPT_SCOPE(SPTPlaylistReadPrivateScope, playlistReadPrivate, "playlist-read-private", (1 << 0)) \
+SPT_SCOPE(SPTPlaylistReadCollaborativeScope, playlistReadCollaborative, "playlist-read-collaborative", (1 << 1)) \
+SPT_SCOPE(SPTPlaylistModifyPublicScope, playlistModifyPublic, "playlist-modify-public", (1 << 2)) \
+SPT_SCOPE(SPTPlaylistModifyPrivateScope, playlistModifyPrivate, "playlist-modify-private", (1 << 3)) \
+SPT_SCOPE(SPTUserFollowReadScope, userFollowRead, "user-follow-read", (1 << 4)) \
+SPT_SCOPE(SPTUserFollowModifyScope, userFollowModify, "user-follow-modify", (1 << 5)) \
+SPT_SCOPE(SPTUserLibraryReadScope, userLibraryRead, "user-library-read", (1 << 6)) \
+SPT_SCOPE(SPTUserLibraryModifyScope, userLibraryModify, "user-library-modify", (1 << 7)) \
+SPT_SCOPE(SPTUserReadBirthDateScope, userReadBirthDate, "user-read-birthdate", (1 << 8)) \
+SPT_SCOPE(SPTUserReadEmailScope, userReadEmail, "user-read-email", (1 << 9)) \
+SPT_SCOPE(SPTUserReadPrivateScope, userReadPrivate, "user-read-private", (1 << 10)) \
+SPT_SCOPE(SPTUserTopReadScope, userTopRead, "user-top-read", (1 << 11)) \
+SPT_SCOPE(SPTUGCImageUploadScope, ugcImageUpload, "ugc-image-upload", (1 << 12)) \
+SPT_SCOPE(SPTStreamingScope, streaming, "streaming", (1 << 13)) \
+SPT_SCOPE(SPTAppRemoteControlScope, appRemoteControl, "app-remote-control", (1 << 14)) \
+SPT_SCOPE(SPTUserReadPlaybackStateScope, userReadPlaybackState, "user-read-playback-state", (1 << 15)) \
+SPT_SCOPE(SPTUserModifyPlaybackStateScope, userModifyPlaybackState, "user-modify-playback-state", (1 << 16)) \
+SPT_SCOPE(SPTUserReadCurrentlyPlayingScope, userReadCurrentlyPlaying, "user-read-currently-playing", (1 << 17)) \
+SPT_SCOPE(SPTUserReadRecentlyPlayedScope, userReadRecentlyPlayed, "user-read-recently-played", (1 << 18)) \
+SPT_SCOPE(SPTOpenIdScope, openid, "openid", (1 << 19))
+
+/**
+ `SPTScope` represents the OAuth scopes that declare how your app wants to access a user's account.
+ See https://developer.spotify.com/web-api/using-scopes/ for more information.
+*/
+typedef NS_OPTIONS(NSUInteger, SPTScope)
+{
+    /// Read access to user's private playlists.
+    SPTPlaylistReadPrivateScope NS_SWIFT_NAME(playlistReadPrivate) = (1 << 0),
+    /// Include collaborative playlists when requesting a user's playlists.
+    SPTPlaylistReadCollaborativeScope NS_SWIFT_NAME(playlistReadCollaborative) = (1 << 1),
+    /// Write access to a user's public playlists.
+    SPTPlaylistModifyPublicScope NS_SWIFT_NAME(playlistModifyPublic) = (1 << 2),
+    /// Write access to a user's private playlists.
+    SPTPlaylistModifyPrivateScope NS_SWIFT_NAME(playlistModifyPrivate) = (1 << 3),
+    /// Read access to the list of artists and other users that the user follows.
+    SPTUserFollowReadScope NS_SWIFT_NAME(userFollowRead) = (1 << 4),
+    /// Write/delete access to the list of artists and other users that the user follows.
+    SPTUserFollowModifyScope NS_SWIFT_NAME(userFollowModify) = (1 << 5),
+    /// Read access to a user's "Your Music" library.
+    SPTUserLibraryReadScope NS_SWIFT_NAME(userLibraryRead) = (1 << 6),
+    /// Write/delete access to a user's "Your Music" library.
+    SPTUserLibraryModifyScope NS_SWIFT_NAME(userLibraryModify) = (1 << 7),
+    /// Read access to the user's birthdate.
+    SPTUserReadBirthDateScope NS_SWIFT_NAME(userReadBirthDate) = (1 << 8),
+    /// Read access to user’s email address.
+    SPTUserReadEmailScope NS_SWIFT_NAME(userReadEmail) = (1 << 9),
+    /// Read access to user’s subscription details (type of user account).
+    SPTUserReadPrivateScope  NS_SWIFT_NAME(userReadPrivate) = (1 << 10),
+    /// Read access to a user's top artists and tracks.
+    SPTUserTopReadScope NS_SWIFT_NAME(userTopRead) = (1 << 11),
+    /// Upload user generated content images
+    SPTUGCImageUploadScope NS_SWIFT_NAME(ugcImageUpload) = (1 << 12),
+    /// Control playback of a Spotify track.
+    SPTStreamingScope NS_SWIFT_NAME(streaming) = (1 << 13),
+    /// Use App Remote to control playback in the Spotify app
+    SPTAppRemoteControlScope NS_SWIFT_NAME(appRemoteControl) = (1 << 14),
+    /// Read access to a user’s player state.
+    SPTUserReadPlaybackStateScope NS_SWIFT_NAME(userReadPlaybackState) = (1 << 15),
+    /// Write access to a user’s playback state
+    SPTUserModifyPlaybackStateScope NS_SWIFT_NAME(userModifyPlaybackState) = (1 << 16),
+    /// Read access to a user’s currently playing track
+    SPTUserReadCurrentlyPlayingScope NS_SWIFT_NAME(userReadCurrentlyPlaying) = (1 << 17),
+    /// Read access to a user’s currently playing track
+    SPTUserReadRecentlyPlayedScope NS_SWIFT_NAME(userReadRecentlyPlayed) = (1 << 18),
+    /// Indicate that the application intends to use OIDC to verify the user's identity
+    SPTOpenIdScope NS_SWIFT_NAME(openid) = (1 << 19),
+};
+

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTSession.h

@@ -0,0 +1,32 @@
+#import "SPTScope.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+/// The `SPTSession` represents an authenticated Spotify user session.
+@interface SPTSession : NSObject <NSSecureCoding>
+
+/// The access token of the authenticated user.
+@property (nonatomic, readonly, copy) NSString *accessToken;
+
+/// The refresh token.
+@property (nonatomic, readonly, copy) NSString *refreshToken;
+
+/// The expiration date of the access token.
+@property (nonatomic, readonly, copy) NSDate *expirationDate;
+
+/// The scope granted.
+@property (nonatomic, readonly) SPTScope scope;
+
+/**
+ Check whether the session has expired. `YES` if expired; `NO` otherwise.
+ Note: The session is considered expired once the current date and time is equal to or greater than the expiration date and time.
+*/
+@property (nonatomic, readonly, getter=isExpired) BOOL expired;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTSessionManager.h

@@ -0,0 +1,140 @@
+#import <UIKit/UIKit.h>
+#import "SPTScope.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SPTConfiguration, SPTSession;
+@protocol SPTSessionManagerDelegate;
+
+/// Options for determining the most suitable method for authorization
+typedef NS_OPTIONS(NSUInteger, SPTAuthorizationOptions)
+{
+    /// Authorize using a suitable method. If Spotify is installed the app will be used instead of a web view
+    SPTDefaultAuthorizationOption NS_SWIFT_NAME(default) = (0),
+    /// Authorize using only the Spotify client. If Spotify is not installed authorization will fail.
+    SPTClientAuthorizationOption NS_SWIFT_NAME(clientOnly) = (1 << 0),
+} NS_SWIFT_NAME(AuthorizationOptions);
+
+typedef NSString * const SPTAuthorizationCode;
+
+
+/// This class manages a Spotify user session, in the form of `SPTSession`.
+@interface SPTSessionManager : NSObject
+
+/// The `SPTSession` for the `SPTSessionManager` to manage. If no user has been authenticated this will be nil
+@property (nullable, nonatomic, strong) SPTSession *session;
+
+/// The `SPTSessionManagerDelegate` to notify of initiating a session, renewing a session, and/or errors related to a session
+@property (nullable, nonatomic, weak) id <SPTSessionManagerDelegate> delegate;
+
+/**
+ Determine if the Spotify app is installed.
+
+ Will be `YES` if the Spotify app is installed (and the URL scheme is whitelisted), otherwise is `NO`.
+ Note: You must whitelist the "spotify" URL scheme in your info.plist LSApplicationQueriesSchemes or this will always be NO
+ */
+@property (nonatomic, readonly, getter=isSpotifyAppInstalled) BOOL spotifyAppInstalled;
+
+/**
+ Set this value to `YES` when debugging to have the Spotify app always show the authorization confirmation screen.
+ You SHOULD NOT set this value to `YES` in production or your users will always have to confirm.
+ */
+@property (nonatomic, assign) BOOL alwaysShowAuthorizationDialog;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/**
+ Initiate the authorization process on iOS 11 and later.
+
+ @param scope The scope to request, e.g. `SPTPlaylistReadPrivateScope`|`SPTUserReadEmailScope` if you wish to request read access to private playlists, and read access to the user's email address.
+ @param options Options bitmask that informs authorization behavior.
+ See `SPTSessionManagerDelegate` for messages regarding changes in session state.
+ */
+- (void)initiateSessionWithScope:(SPTScope)scope
+                         options:(SPTAuthorizationOptions)options NS_AVAILABLE_IOS(11_0);
+
+/**
+ Initiate the authorization process on iOS versions < 11.
+
+ @param scope The scope to request, e.g. `SPTPlaylistReadPrivateScope`|`SPTUserReadEmailScope` if you wish to request read access to private playlists, and read access to the user's email address.
+ @param options Options bitmask that informs authorization behavior.
+ @param presentingViewController The `UIViewController` to present the login `SFSafariViewController` on
+ See `SPTSessionManagerDelegate` for messages regarding changes in session state.
+ */
+- (void)initiateSessionWithScope:(SPTScope)scope
+                         options:(SPTAuthorizationOptions)options
+        presentingViewController: (UIViewController *)presentingViewController NS_DEPRECATED_IOS(9_0, 11_0);
+
+/// Attempt to renew the access token, using the refresh token in the current `SPTSession` which must be valid.
+- (void)renewSession;
+
+/**
+ Create an `SPTSessionManager` with the provided configuration.
+ 
+ @param configuration An `SPTConfiguration` object.
+ @param delegate An optional delegate conforming to `SPTSessionManagerDelegate`.
+ @return An `SPTSessionManager` with the desired configuration.
+*/
+- (instancetype)initWithConfiguration:(SPTConfiguration *)configuration
+                             delegate:(nullable id <SPTSessionManagerDelegate>)delegate;
+
++ (instancetype)sessionManagerWithConfiguration:(SPTConfiguration *)configuration
+                                       delegate:(nullable id <SPTSessionManagerDelegate>)delegate;
+/**
+ Handle openURL callbacks from the `AppDelegate`
+
+ @param application The `UIApplication` passed into the matching `AppDelegate` method
+ @param URL The URL to attempt to parse the access token from
+ @param options The options passed in to the matching `AppDelegate` method
+ @return Returns `YES` if `SPTSessionManager` recognizes the URL and will attempt to parse an access token, otherwise returns `NO`.
+*/
+- (BOOL)application:(UIApplication *)application
+            openURL:(NSURL *)URL
+            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options;
+
+@end
+
+/// The `SPTSessionManagerDelegate` to use for monitoring state changes of a `SPTSessionManager`
+@protocol SPTSessionManagerDelegate <NSObject>
+
+/**
+ This message is sent when a session has been initiated successfully.
+
+ @param manager The `SPTSessionManager` that initiated the session.
+ @param session The initiated `SPTSession` object.
+*/
+- (void)sessionManager:(SPTSessionManager *)manager didInitiateSession:(SPTSession *)session NS_SWIFT_NAME(sessionManager(manager:didInitiate:));
+
+/**
+ This message is sent when the manager failed to initiate or renew a session.
+
+ @param manager The `SPTSessionManager` instance.
+ @param error The `NSError` that occured.
+*/
+- (void)sessionManager:(SPTSessionManager *)manager didFailWithError:(NSError *)error NS_SWIFT_NAME(sessionManager(manager:didFailWith:));
+
+@optional
+
+/**
+ This message is sent when the manager has renewed a session.
+
+ @param manager The `SPTSessionManager` instance.
+ @param session The renewed `SPTSession` object.
+*/
+- (void)sessionManager:(SPTSessionManager *)manager didRenewSession:(SPTSession *)session  NS_SWIFT_NAME(sessionManager(manager:didRenew:));
+
+/**
+ Sent when the `SPTSessionManager` has obtained an authorization code,
+ and is about to swap it for an access token. If you wish to handle this
+ yourself, return `NO` and use the provided authorization code.
+
+ @param manager The `SPTSessionManager` instance.
+ @param code An OAuth authorization code.
+ @return `NO` to request the access token yourself; `YES` to let `SPTSessionManager` handle it.
+*/
+- (BOOL)sessionManager:(SPTSessionManager *)manager shouldRequestAccessTokenWithAuthorizationCode:(SPTAuthorizationCode)code NS_SWIFT_NAME(sessionManager(manager:shouldRequestAccessTokenWith:));
+
+@end
+
+
+NS_ASSUME_NONNULL_END

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SpotifyAppRemote.h

@@ -0,0 +1,30 @@
+#import <Foundation/Foundation.h>
+
+#ifndef _SPOTIFYAPPREMOTE_
+#define _SPOTIFYAPPREMOTE_
+
+#import "SPTAppRemote.h"
+#import "SPTAppRemoteCommon.h"
+
+#import "SPTAppRemoteConnectionParams.h"
+
+#import "SPTAppRemoteImageAPI.h"
+#import "SPTAppRemotePlayerAPI.h"
+#import "SPTAppRemoteUserAPI.h"
+#import "SPTAppRemoteContentAPI.h"
+
+#import "SPTAppRemoteAlbum.h"
+#import "SPTAppRemoteArtist.h"
+#import "SPTAppRemotePlaybackOptions.h"
+#import "SPTAppRemotePlaybackRestrictions.h"
+#import "SPTAppRemotePlayerState.h"
+#import "SPTAppRemoteCrossfadeState.h"
+#import "SPTAppRemoteTrack.h"
+#import "SPTAppRemoteUserCapabilities.h"
+#import "SPTAppRemoteLibraryState.h"
+#import "SPTAppRemoteContentItem.h"
+#import "SPTAppRemotePodcastPlaybackSpeed.h"
+
+#import "SPTConfiguration.h"
+
+#endif /* _SPOTIFYAPPREMOTE_ */

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SpotifyiOS.h

@@ -0,0 +1,7 @@
+#ifndef _SPOTIFYIOS_
+#define _SPOTIFYIOS_
+
+#import "SpotifyAppRemote.h"
+#import "SPTLogin.h"
+
+#endif /* _SPOTIFYIOS_ */

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Modules/module.modulemap

@@ -0,0 +1,6 @@
+framework module SpotifyiOS {
+  umbrella header "SpotifyiOS.h"
+
+  export *
+  module * { export * }
+}