@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/musickit-audio/SKILL.md

@@ -1,239 +1,199 @@
 ---
 name: musickit-audio
-description: "Integrate Apple Music playback, catalog search, and Now Playing metadata using MusicKit and MediaPlayer. Use when adding music search, Apple Music subscription flows, queue management, playback controls, remote command handling, or Now Playing info to iOS apps."
+description: "MusicKit and MediaPlayer on iOS: Apple Music authorization, catalog search, subscription checks and offers, ApplicationMusicPlayer playback controls and queues, Now Playing info, remote commands. Use when adding Apple Music playback or Now Playing controls."
 metadata:
-  source: "dpearson2699/swift-ios-skills (PolyForm Perimeter 1.0.0)"
+  source: multi-agent-pipeline
 ---
 
-# MusicKit
+# MusicKit and Now Playing
 
-Search the Apple Music catalog, manage playback with `ApplicationMusicPlayer`,
-check subscriptions, and publish Now Playing metadata via `MPNowPlayingInfoCenter`
-and `MPRemoteCommandCenter`. Targets Swift 6.3 / iOS 26+.
+Two frameworks cover music in an iOS app. MusicKit talks to Apple Music:
+permission, catalog, subscription state, library and an app-owned player.
+MediaPlayer talks to the system: the Now Playing card on the Lock Screen, in
+Control Center and in CarPlay, plus the remote commands that headphones and
+those surfaces send. Code here targets Swift 6.3 and iOS 26.
 
-## Contents
-
-- [Setup](#setup)
-- [Authorization](#authorization)
-- [Catalog Search](#catalog-search)
-- [Subscription Checks](#subscription-checks)
-- [Playback with ApplicationMusicPlayer](#playback-with-applicationmusicplayer)
-- [Queue Management](#queue-management)
-- [Now Playing Info](#now-playing-info)
-- [Remote Command Center](#remote-command-center)
-- [Common Mistakes](#common-mistakes)
-- [Review Checklist](#review-checklist)
-- [References](#references)
+Longer building blocks (an observable player model, mini player, search screen,
+charts, library and playlist work, `MPNowPlayingSession`, audio session setup,
+interruptions and route changes) live in
+[references/musickit-patterns.md](references/musickit-patterns.md).
 
 ## Setup
 
-### Project Configuration
+### Portal and Info.plist
+
+1. In the developer portal, open the app's explicit App ID and turn on the
+   **MusicKit** App Service. That is what lets the system mint developer tokens
+   for the app automatically; there is no token code to write.
+2. Add `NSAppleMusicUsageDescription` to Info.plist. Without it, access to the
+   user's media library fails wherever the system requires the string.
+3. Only if audio must keep playing in the background: add `audio` to the
+   `UIBackgroundModes` array.
 
-1. Enable the **MusicKit App Service** for the app's explicit bundle ID in the Apple Developer portal so MusicKit can generate developer tokens automatically.
-2. Add `NSAppleMusicUsageDescription` to Info.plist explaining why the app accesses the user's media library.
-3. For background playback, add the `audio` background mode to `UIBackgroundModes`.
+There is no `com.apple.developer.musickit` entitlement to add on iOS, and a
+missing entitlement is not what makes authorization fail. The App Service and
+the usage string are the two requirements.
 
 ### Imports
 
 ```swift
-import MusicKit       // Catalog, auth, playback
-import MediaPlayer    // MPRemoteCommandCenter, MPNowPlayingInfoCenter
+import MusicKit      // authorization, catalog, subscription, ApplicationMusicPlayer
+import MediaPlayer   // MPNowPlayingInfoCenter, MPRemoteCommandCenter
 ```
 
 ## Authorization
 
-Request permission before accessing the user's music data or playing Apple Music
-content. `request()` presents Apple's consent dialog when necessary; use
-`currentStatus` to read the current setting without prompting.
+Ask before touching the user's music data or starting Apple Music playback.
 
 ```swift
-func requestMusicAccess() async -> MusicAuthorization.Status {
-    let status = await MusicAuthorization.request()
-    switch status {
+func ensureMusicAccess() async -> Bool {
+    switch await MusicAuthorization.request() {
     case .authorized:
-        // Full access to MusicKit APIs
-        break
+        return true
     case .denied, .restricted:
-        // Show guidance to enable in Settings
-        break
+        // Explain the limitation and point the user at Settings.
+        return false
     case .notDetermined:
-        break
+        return false
     @unknown default:
-        break
+        return false
     }
-    return status
 }
-
-// Check current status without prompting
-let current = MusicAuthorization.currentStatus
 ```
 
-## Catalog Search
+`request()` shows the consent prompt only when the user has not answered yet;
+otherwise it returns the stored answer. To read the state without any chance of
+a prompt, use `MusicAuthorization.currentStatus`.
 
-Use `MusicCatalogSearchRequest` to search the Apple Music catalog. Catalog lookup
-can fetch Apple Music resources, but playback of subscription catalog content
-must still be gated on `MusicSubscription.current.canPlayCatalogContent`.
+## Catalog search
 
-```swift
-func searchCatalog(term: String) async throws -> MusicItemCollection<Song> {
-    var request = MusicCatalogSearchRequest(term: term, types: [Song.self])
-    request.limit = 25
+Searching the catalog works for anyone who granted access. Playing what you
+found is a separate question, answered by the subscription check below.
 
-    let response = try await request.response()
-    return response.songs
+```swift
+func findTracks(matching phrase: String) async throws -> MusicItemCollection<Song> {
+    var search = MusicCatalogSearchRequest(term: phrase, types: [Song.self])
+    search.limit = 25
+    let result = try await search.response()
+    return result.songs
 }
 ```
 
-### Displaying Results
+For a row, read `song.title`, `song.artistName` and
+`song.artwork?.url(width: 120, height: 120)`.
+
+## Subscription state
 
 ```swift
-for song in songs {
-    print("\(song.title) by \(song.artistName)")
-    if let artwork = song.artwork {
-        let url = artwork.url(width: 300, height: 300)
-        // Load artwork from url
-    }
-}
+let membership = try await MusicSubscription.current
+let mayPlay = membership.canPlayCatalogContent
 ```
 
-## Subscription Checks
-
-Check whether the user has an active Apple Music subscription before offering playback features.
+Subscription state changes while the app runs. Keep the UI in step:
 
 ```swift
-func checkSubscription() async throws -> Bool {
-    let subscription = try await MusicSubscription.current
-    return subscription.canPlayCatalogContent
-}
-
-// Observe subscription changes
-func observeSubscription() async {
-    for await subscription in MusicSubscription.subscriptionUpdates {
-        if subscription.canPlayCatalogContent {
-            // Enable full playback UI
-        } else {
-            // Show subscription offer
-        }
+.task {
+    for await membership in MusicSubscription.subscriptionUpdates {
+        showsPlayControls = membership.canPlayCatalogContent
+        showsJoinButton = !membership.canPlayCatalogContent && membership.canBecomeSubscriber
     }
 }
 ```
 
-### Offering Apple Music
+### Presenting the Apple Music offer
 
-Present the Apple Music subscription offer sheet when the user is not subscribed.
-Check `canBecomeSubscriber` first, and pass `MusicSubscriptionOffer.Options` or
-`onLoadCompletion` when the sheet needs contextual metadata or load-error handling.
+Only offer when `canBecomeSubscriber` is true. The sheet comes from a view
+modifier:
 
 ```swift
-import MusicKit
-import SwiftUI
-
-struct MusicOfferView: View {
-    @State private var showOffer = false
+struct JoinAppleMusicButton: View {
+    @State private var offerVisible = false
+    @State private var offerOptions = MusicSubscriptionOffer.Options.default
+    @State private var offerError: (any Error)?
 
     var body: some View {
-        Button("Subscribe to Apple Music") {
-            Task {
-                let subscription = try? await MusicSubscription.current
-                showOffer = subscription?.canBecomeSubscriber == true
-            }
-        }
-        .musicSubscriptionOffer(
-            isPresented: $showOffer,
-            options: .default,
-            onLoadCompletion: { error in
-                if let error {
-                    // Surface loading errors in app UI or diagnostics.
-                    print(error)
-                }
-            }
-        )
+        Button("Try Apple Music") { offerVisible = true }
+            .musicSubscriptionOffer(
+                isPresented: $offerVisible,
+                options: offerOptions,
+                onLoadCompletion: { failure in offerError = failure }
+            )
     }
 }
 ```
 
-## Playback with ApplicationMusicPlayer
+When `offerError` is non-nil the sheet did not load; show a fallback message.
 
-`ApplicationMusicPlayer` plays Apple Music content independently from the Music app. It does not affect the system player's state.
+## ApplicationMusicPlayer
 
-```swift
-let player = ApplicationMusicPlayer.shared
+`ApplicationMusicPlayer.shared` is the app's own player. It plays alongside the
+Music app without touching the Music app's queue or state.
 
-func playSong(_ song: Song) async throws {
-    player.queue = [song]
+```swift
+func start(_ track: Song) async throws {
+    let player = ApplicationMusicPlayer.shared
+    player.queue = [track]
     try await player.play()
 }
 
-func pause() {
-    player.pause()
-}
+func halt() { ApplicationMusicPlayer.shared.pause() }
 
-func skipToNext() async throws {
-    try await player.skipToNextEntry()
-}
+func forward() async throws { try await ApplicationMusicPlayer.shared.skipToNextEntry() }
 ```
 
-### Observing Playback State
+The player is not `Sendable`. Read `.shared` where it is used; a global
+`let player`, or a property on a main-actor type, fails Swift 6 checking once
+an async method is called on it. The snippets below use `player` for
+`ApplicationMusicPlayer.shared`.
+
+`player.state` is observable, so SwiftUI redraws when it changes. Branch on
+`playbackStatus`:
 
 ```swift
-func observePlayback() {
-    // player.state is an @Observable property
-    let state = player.state
-    switch state.playbackStatus {
-    case .playing:
-        break
-    case .paused:
-        break
-    case .stopped, .interrupted, .seekingForward, .seekingBackward:
-        break
-    @unknown default:
-        break
-    }
+switch player.state.playbackStatus {
+case .playing:            label = "Playing"
+case .paused:             label = "Paused"
+case .stopped:            label = "Stopped"
+case .interrupted:        label = "Interrupted"
+case .seekingForward,
+     .seekingBackward:    label = "Seeking"
+@unknown default:         label = ""
 }
 ```
 
-## Queue Management
+## Queue management
 
-Build and manipulate the playback queue using `ApplicationMusicPlayer.Queue`.
+`player.queue` is an `ApplicationMusicPlayer.Queue`. Assigning a collection
+replaces it, and an album or playlist works as well as songs:
 
 ```swift
-// Initialize with multiple items
-func playAlbum(_ album: Album) async throws {
-    player.queue = [album]
-    try await player.play()
-}
+player.queue = [albumToPlay]
+```
 
-// Append songs to the existing queue
-func appendToQueue(_ songs: [Song]) async throws {
-    try await player.queue.insert(songs, position: .tail)
-}
+To add without replacing:
 
-// Insert song to play next
-func playNext(_ song: Song) async throws {
-    try await player.queue.insert(song, position: .afterCurrentEntry)
-}
+```swift
+try await player.queue.insert(extraTracks, position: .tail)              // at the end
+try await player.queue.insert(nextUp, position: .afterCurrentEntry)      // play next
 ```
 
-## Now Playing Info
+## Now Playing info
 
-Update `MPNowPlayingInfoCenter` so the Lock Screen, Control Center, and CarPlay
-display current track metadata. This is essential when playing custom audio
-(non-MusicKit sources). `ApplicationMusicPlayer` handles this automatically for
-Apple Music content.
+`MPNowPlayingInfoCenter` feeds the Lock Screen, Control Center and CarPlay.
+When `ApplicationMusicPlayer` plays Apple Music content, the system fills this
+in for you. Write it yourself only for audio the app plays some other way, such
+as an `AVPlayer` streaming podcasts.
 
 ```swift
-import MediaPlayer
-
-func updateNowPlaying(title: String, artist: String, duration: TimeInterval, elapsed: TimeInterval) {
-    var info = [String: Any]()
-    info[MPMediaItemPropertyTitle] = title
-    info[MPMediaItemPropertyArtist] = artist
-    info[MPMediaItemPropertyPlaybackDuration] = duration
-    info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsed
-    info[MPNowPlayingInfoPropertyPlaybackRate] = 1.0
-    info[MPNowPlayingInfoPropertyMediaType] = MPNowPlayingInfoMediaType.audio.rawValue
-
-    MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+func publishNowPlaying(for episode: Episode, position: TimeInterval) {
+    MPNowPlayingInfoCenter.default().nowPlayingInfo = [
+        MPMediaItemPropertyTitle: episode.title,
+        MPMediaItemPropertyArtist: episode.showName,
+        MPMediaItemPropertyPlaybackDuration: episode.length,
+        MPNowPlayingInfoPropertyElapsedPlaybackTime: position,
+        MPNowPlayingInfoPropertyPlaybackRate: 1.0,
+        MPNowPlayingInfoPropertyMediaType: MPNowPlayingInfoMediaType.audio.rawValue
+    ]
 }
 
 func clearNowPlaying() {
@@ -241,184 +201,98 @@ func clearNowPlaying() {
 }
 ```
 
-### Adding Artwork
+Artwork goes in under `MPMediaItemPropertyArtwork`. Merge it into the existing
+dictionary rather than replacing the whole thing:
 
 ```swift
-func setArtwork(_ image: UIImage) {
-    let artwork = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
+func attachCover(_ cover: UIImage) {
+    let art = MPMediaItemArtwork(boundsSize: cover.size) { _ in cover }
     var info = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
-    info[MPMediaItemPropertyArtwork] = artwork
+    info[MPMediaItemPropertyArtwork] = art
     MPNowPlayingInfoCenter.default().nowPlayingInfo = info
 }
 ```
 
-## Remote Command Center
-
-Register handlers for `MPRemoteCommandCenter` to respond to Lock Screen controls,
-AirPods tap gestures, and CarPlay buttons.
+Refresh the elapsed time on a timer or at each seek, so the Lock Screen
+scrubber stays accurate.
 
-```swift
-func setupRemoteCommands() {
-    let center = MPRemoteCommandCenter.shared()
-
-    center.playCommand.addTarget { _ in
-        resumePlayback()
-        return .success
-    }
-
-    center.pauseCommand.addTarget { _ in
-        pausePlayback()
-        return .success
-    }
+## Remote commands
 
-    center.nextTrackCommand.addTarget { _ in
-        skipToNext()
-        return .success
-    }
+`MPRemoteCommandCenter.shared()` receives Lock Screen buttons, AirPods taps and
+CarPlay controls. Register the handlers from the main actor so they can call a
+main-actor engine directly; `EpisodeEngine` stands for that type.
 
-    center.previousTrackCommand.addTarget { _ in
-        skipToPrevious()
-        return .success
-    }
+```swift
+@MainActor
+func wireRemoteControls(to engine: EpisodeEngine) {
+    let commands = MPRemoteCommandCenter.shared()
 
-    // Disable commands you do not support
-    center.seekForwardCommand.isEnabled = false
-    center.seekBackwardCommand.isEnabled = false
-}
-```
+    commands.playCommand.addTarget { _ in engine.resume(); return .success }
+    commands.pauseCommand.addTarget { _ in engine.suspend(); return .success }
+    commands.nextTrackCommand.addTarget { _ in engine.advance(); return .success }
+    commands.previousTrackCommand.addTarget { _ in engine.rewind(); return .success }
 
-### Scrubbing Support
+    commands.seekForwardCommand.isEnabled = false
+    commands.seekBackwardCommand.isEnabled = false
 
-```swift
-func enableScrubbing() {
-    let center = MPRemoteCommandCenter.shared()
-    center.changePlaybackPositionCommand.addTarget { event in
-        guard let positionEvent = event as? MPChangePlaybackPositionCommandEvent else {
+    commands.changePlaybackPositionCommand.addTarget { event in
+        guard let jump = event as? MPChangePlaybackPositionCommandEvent else {
             return .commandFailed
         }
-        seek(to: positionEvent.positionTime)
+        engine.move(to: jump.positionTime)
         return .success
     }
 }
 ```
 
-## Common Mistakes
-
-### DON'T: Skip MusicKit App Service setup or usage description
-
-Without the MusicKit App Service on the app's explicit bundle ID, automatic
-developer token generation for Apple Music API requests is not configured.
-Without `NSAppleMusicUsageDescription`, the app cannot access the user's media
-library on Apple platforms that require the purpose string.
-
-```swift
-// WRONG: MusicKit App Service not enabled for this bundle ID
-
-// CORRECT: Enable MusicKit App Service in the developer portal,
-// set the matching bundle ID, then add NSAppleMusicUsageDescription.
-let status = await MusicAuthorization.request()
-```
-
-### DON'T: Forget to check subscription before playback
-
-Attempting to play catalog content without a subscription silently fails or throws.
-
-```swift
-// WRONG
-func play(_ song: Song) async throws {
-    player.queue = [song]
-    try await player.play() // Fails if no subscription
-}
-
-// CORRECT
-func play(_ song: Song) async throws {
-    let sub = try await MusicSubscription.current
-    guard sub.canPlayCatalogContent else {
-        showSubscriptionOffer()
-        return
-    }
-    player.queue = [song]
-    try await player.play()
-}
-```
-
-### DON'T: Use SystemMusicPlayer when you mean ApplicationMusicPlayer
-
-`SystemMusicPlayer` controls the global Music app queue. Changes affect the user's
-Music app state. Use `ApplicationMusicPlayer` for app-scoped playback.
-
-```swift
-// WRONG: Modifies the user's Music app queue
-let player = SystemMusicPlayer.shared
-
-// CORRECT: App-scoped playback
-let player = ApplicationMusicPlayer.shared
-```
-
-### DON'T: Forget to update Now Playing info when track changes
-
-Stale metadata on the Lock Screen confuses users. Update Now Playing info
-every time the current track changes.
-
-```swift
-// WRONG: Set once and forget
-updateNowPlaying(title: firstSong.title, ...)
-
-// CORRECT: Update on every track change
-func onTrackChanged(_ song: Song) {
-    updateNowPlaying(
-        title: song.title,
-        artist: song.artistName,
-        duration: song.duration ?? 0,
-        elapsed: 0
-    )
-}
-```
-
-### DON'T: Register remote commands without handling them
-
-Registering a command but returning `.commandFailed` breaks Lock Screen controls.
-Disable commands you do not support instead.
-
-```swift
-// WRONG
-center.skipForwardCommand.addTarget { _ in .commandFailed }
-
-// CORRECT
-center.skipForwardCommand.isEnabled = false
-```
-
-## Review Checklist
-
-- [ ] MusicKit App Service enabled for the app's explicit bundle ID
-- [ ] `NSAppleMusicUsageDescription` added to Info.plist
-- [ ] `MusicAuthorization.request()` called before any MusicKit access
-- [ ] Subscription checked before attempting catalog playback
-- [ ] `canBecomeSubscriber` checked before presenting a subscription offer
+## Common mistakes
+
+- **Skipping portal or plist setup.** Without the MusicKit App Service there is
+  no automatic developer token; without `NSAppleMusicUsageDescription`, library
+  access fails where it is required.
+- **Playing catalog items without a subscription.** Playback fails quietly or
+  throws. Check `canPlayCatalogContent` first and show the offer when it is
+  false.
+- **Reaching for `SystemMusicPlayer`.** It drives the Music app's global queue
+  and changes the user's own listening state. App-scoped playback belongs in
+  `ApplicationMusicPlayer`.
+- **Stale Now Playing data.** For custom audio, rewrite the dictionary on every
+  track change: title, artist, duration (use `track.duration ?? 0` when it is
+  optional) and an elapsed time reset to 0.
+- **Registering commands you cannot honor.** A handler that returns
+  `.commandFailed` leaves a dead button on the Lock Screen. Turn the command off
+  instead, for example `MPRemoteCommandCenter.shared().skipForwardCommand.isEnabled = false`.
+
+## Review checklist
+
+- [ ] MusicKit App Service enabled on the explicit App ID
+- [ ] `NSAppleMusicUsageDescription` present
+- [ ] `MusicAuthorization.request()` runs before any MusicKit access
+- [ ] Subscription checked before catalog playback
+- [ ] `canBecomeSubscriber` checked before the offer is shown
+- [ ] Offer shown when the user is not subscribed
 - [ ] `hasCloudLibraryEnabled` checked before library writes
-- [ ] `ApplicationMusicPlayer` used (not `SystemMusicPlayer`) for app-scoped playback
-- [ ] Background audio mode enabled if music plays in background
-- [ ] Now Playing info updated on every track change (for custom audio)
-- [ ] Remote command handlers return `.success` for supported commands
-- [ ] Unsupported remote commands disabled with `isEnabled = false`
-- [ ] Artwork provided in Now Playing info for Lock Screen display
-- [ ] Elapsed playback time updated periodically for scrubber accuracy
-- [ ] Subscription offer presented when user lacks Apple Music subscription
+- [ ] `ApplicationMusicPlayer` used, not `SystemMusicPlayer`
+- [ ] `audio` background mode set if playback continues in the background
+- [ ] Now Playing updated on each track change (custom audio)
+- [ ] Artwork supplied for the Lock Screen
+- [ ] Elapsed time refreshed so the scrubber is accurate
+- [ ] Supported remote commands return `.success`; unsupported ones are disabled
 
 ## References
 
-- Extended patterns (SwiftUI integration, genre browsing, playlist management): [references/musickit-patterns.md](references/musickit-patterns.md)
-- [MusicKit framework](https://sosumi.ai/documentation/musickit)
-- [Using automatic developer token generation for Apple Music API](https://sosumi.ai/documentation/musickit/using-automatic-token-generation-for-apple-music-api)
-- [MusicAuthorization](https://sosumi.ai/documentation/musickit/musicauthorization)
-- [ApplicationMusicPlayer](https://sosumi.ai/documentation/musickit/applicationmusicplayer)
-- [MusicCatalogSearchRequest](https://sosumi.ai/documentation/musickit/musiccatalogsearchrequest)
-- [MusicSubscription](https://sosumi.ai/documentation/musickit/musicsubscription)
-- [canPlayCatalogContent](https://sosumi.ai/documentation/musickit/musicsubscription/canplaycatalogcontent)
-- [canBecomeSubscriber](https://sosumi.ai/documentation/musickit/musicsubscription/canbecomesubscriber)
-- [hasCloudLibraryEnabled](https://sosumi.ai/documentation/musickit/musicsubscription/hascloudlibraryenabled)
-- [MusicCatalogChartsRequest initializer](https://sosumi.ai/documentation/musickit/musiccatalogchartsrequest/init(genre:kinds:types:))
-- [musicSubscriptionOffer(isPresented:options:onLoadCompletion:)](https://sosumi.ai/documentation/swiftui/view/musicsubscriptionoffer(ispresented:options:onloadcompletion:))
-- [MPRemoteCommandCenter](https://sosumi.ai/documentation/mediaplayer/mpremotecommandcenter)
-- [MPNowPlayingInfoCenter](https://sosumi.ai/documentation/mediaplayer/mpnowplayinginfocenter)
-- [NSAppleMusicUsageDescription](https://sosumi.ai/documentation/bundleresources/information-property-list/nsapplemusicusagedescription)
+- [references/musickit-patterns.md](references/musickit-patterns.md)
+- [MusicKit](https://developer.apple.com/documentation/musickit)
+- [Using automatic developer token generation](https://developer.apple.com/documentation/musickit/using-automatic-developer-token-generation-for-apple-music-api)
+- [MusicAuthorization](https://developer.apple.com/documentation/musickit/musicauthorization)
+- [ApplicationMusicPlayer](https://developer.apple.com/documentation/musickit/applicationmusicplayer)
+- [MusicCatalogSearchRequest](https://developer.apple.com/documentation/musickit/musiccatalogsearchrequest)
+- [MusicSubscription](https://developer.apple.com/documentation/musickit/musicsubscription)
+- [canPlayCatalogContent](https://developer.apple.com/documentation/musickit/musicsubscription/canplaycatalogcontent)
+- [canBecomeSubscriber](https://developer.apple.com/documentation/musickit/musicsubscription/canbecomesubscriber)
+- [hasCloudLibraryEnabled](https://developer.apple.com/documentation/musickit/musicsubscription/hascloudlibraryenabled)
+- [MusicCatalogChartsRequest init(genre:kinds:types:)](https://developer.apple.com/documentation/musickit/musiccatalogchartsrequest/init(genre:kinds:types:))
+- [musicSubscriptionOffer(isPresented:options:onLoadCompletion:)](https://developer.apple.com/documentation/swiftui/view/musicsubscriptionoffer(ispresented:options:onloadcompletion:))
+- [MPRemoteCommandCenter](https://developer.apple.com/documentation/mediaplayer/mpremotecommandcenter)
+- [MPNowPlayingInfoCenter](https://developer.apple.com/documentation/mediaplayer/mpnowplayinginfocenter)
+- [NSAppleMusicUsageDescription](https://developer.apple.com/documentation/bundleresources/information-property-list/nsapplemusicusagedescription)