react-native-audio-browser 0.2.0-next.34 → 0.2.0-next.35

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -2,93 +2,105 @@ import Testing
 
 @testable import AudioBrowserTestable
 
+private func criteria(
+  mediaName: String? = nil,
+  genreNames: [String] = [],
+  artistName: String? = nil,
+  albumName: String? = nil,
+  mediaTypeMode: String? = nil,
+  reference: MediaIntentCriteria.Reference = .unknown,
+  hasMediaType: Bool = false,
+  appName: String? = "Acme Radio",
+) -> MediaIntentCriteria {
+  MediaIntentCriteria(
+    mediaName: mediaName, genreNames: genreNames, artistName: artistName,
+    albumName: albumName, mediaTypeMode: mediaTypeMode,
+    reference: reference, hasMediaType: hasMediaType, appName: appName,
+  )
+}
+
 @Suite("MediaIntentCriteria")
 struct MediaIntentCriteriaTests {
   @Test func emptyEverything_isResume() {
-    let c = MediaIntentCriteria(query: "", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
-    #expect(c.isResume)
+    #expect(criteria().isResume)
   }
 
   @Test func whitespaceQuery_isResume() {
-    let c = MediaIntentCriteria(query: "   ", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
+    let c = criteria(mediaName: "   ")
+    #expect(c.query == "")
     #expect(c.isResume)
   }
 
   // currentlyPlaying always resumes — "play this" makes the active track play.
   @Test func currentlyPlaying_isResume() {
-    #expect(MediaIntentCriteria(query: "", reference: .currentlyPlaying, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
+    #expect(criteria(reference: .currentlyPlaying).isResume)
     // even with a stray query/filter, "play this" is a resume
-    #expect(MediaIntentCriteria(query: "jazz", reference: .currentlyPlaying, hasGenres: true, hasMediaType: true, matchesAppName: false).isResume)
+    #expect(criteria(mediaName: "jazz", genreNames: ["jazz"], reference: .currentlyPlaying, hasMediaType: true).isResume)
   }
 
   // .my always searches — "play my favorites" goes to the consumer, never resume.
   @Test func my_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "", reference: .my, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .my, hasGenres: false, hasMediaType: false, matchesAppName: true).isResume)
+    #expect(!criteria(reference: .my).isResume)
+    let namesApp = criteria(mediaName: "Acme", reference: .my)
+    #expect(namesApp.matchesAppName)
+    #expect(!namesApp.isResume)
   }
 
   @Test func anyCriteria_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "kcrw", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .unknown, hasGenres: true, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .unknown, hasGenres: false, hasMediaType: true, matchesAppName: false).isResume)
+    #expect(!criteria(mediaName: "kcrw").isResume)
+    #expect(!criteria(genreNames: ["jazz"]).isResume)
+    #expect(!criteria(hasMediaType: true).isResume)
   }
 
   @Test func queryNamesApp_isResume() {
-    let c = MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: false, hasMediaType: true, matchesAppName: true)
+    let c = criteria(mediaName: "Acme", hasMediaType: true)
+    #expect(c.matchesAppName)
     #expect(c.isResume)
   }
 
   @Test func queryNamesApp_withGenre_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: true, hasMediaType: false, matchesAppName: true).isResume)
+    let c = criteria(mediaName: "Acme", genreNames: ["jazz"])
+    #expect(c.matchesAppName)
+    #expect(!c.isResume)
   }
 
   @Test func queryNotApp_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "jazz", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
+    #expect(!criteria(mediaName: "jazz").isResume)
   }
-}
 
-@Suite("MediaIntentCriteria.from")
-struct MediaIntentCriteriaFromTests {
-  private func from(
-    mediaName: String? = nil,
-    genreNames: [String] = [],
-    artistName: String? = nil,
-    albumName: String? = nil,
-    mediaTypeMode: String? = nil,
-    reference: MediaIntentCriteria.Reference = .unknown,
-    hasMediaType: Bool = false,
-    appName: String? = "Radio Garden",
-  ) -> MediaIntentCriteria {
-    MediaIntentCriteria.from(
-      mediaName: mediaName, genreNames: genreNames, artistName: artistName,
-      albumName: albumName, mediaTypeMode: mediaTypeMode,
-      reference: reference, hasMediaType: hasMediaType, appName: appName,
-    )
+  // An empty genre name is still a genre filter: the fact is that genres were given.
+  @Test func emptyGenreName_isStillAGenreFilter() {
+    let c = criteria(genreNames: [""])
+    #expect(c.genre == "")
+    #expect(!c.isResume)
   }
+}
 
+@Suite("MediaIntentCriteria from intent fields")
+struct MediaIntentCriteriaFromTests {
   // MARK: resume vs search
 
   @Test func playAppName_resumes() {
-    let c = from(mediaName: "Garden", hasMediaType: true)
-    #expect(c.query == "Garden")
+    let c = criteria(mediaName: "Acme", hasMediaType: true)
+    #expect(c.query == "Acme")
     #expect(c.matchesAppName)
     #expect(c.isResume)
   }
 
   @Test func emptyIntent_resumes() {
-    let c = from()
+    let c = criteria()
     #expect(c.query == "")
     #expect(c.isResume)
   }
 
   @Test func playMyFavorites_searches() {
-    let c = from(reference: .my)
+    let c = criteria(reference: .my)
     #expect(!c.isResume)
     #expect(c.reference == .my)
   }
 
   @Test func stationName_searches() {
-    let c = from(mediaName: "KCRW")
+    let c = criteria(mediaName: "KCRW")
     #expect(c.query == "KCRW")
     #expect(!c.matchesAppName)
     #expect(!c.isResume)
@@ -99,23 +111,22 @@ struct MediaIntentCriteriaFromTests {
 
   // "Play jazz" → genre is a FILTER, not a mode. mode stays nil; genre set.
   @Test func genre_isFilterNotMode() {
-    let c = from(genreNames: ["jazz"], hasMediaType: true)
+    let c = criteria(genreNames: ["jazz"], hasMediaType: true)
     #expect(c.query == "jazz")
     #expect(c.searchMode == nil)
     #expect(c.genre == "jazz")
-    #expect(c.hasGenres)
     #expect(!c.isResume)
   }
 
   @Test func multiWordGenre_joined_noMode() {
-    let c = from(mediaName: "   ", genreNames: ["classic", "rock"])
+    let c = criteria(mediaName: "   ", genreNames: ["classic", "rock"])
     #expect(c.query == "classic rock")
     #expect(c.genre == "classic rock")
     #expect(c.searchMode == nil)
   }
 
   @Test func artist_isFilterNotMode() {
-    let c = from(artistName: "Michael Jackson")
+    let c = criteria(artistName: "Michael Jackson")
     #expect(c.query == "Michael Jackson")
     #expect(c.searchMode == nil)
     #expect(c.artist == "Michael Jackson")
@@ -123,7 +134,7 @@ struct MediaIntentCriteriaFromTests {
   }
 
   @Test func albumAndArtist_areFiltersNotMode() {
-    let c = from(mediaName: "Thriller", artistName: "Michael Jackson", albumName: "Thriller")
+    let c = criteria(mediaName: "Thriller", artistName: "Michael Jackson", albumName: "Thriller")
     #expect(c.searchMode == nil)
     #expect(c.album == "Thriller")
     #expect(c.artist == "Michael Jackson")
@@ -132,7 +143,7 @@ struct MediaIntentCriteriaFromTests {
 
   // A vertical mediaType DOES set the mode, and travels with its filters.
   @Test func song_viaMediaTypeMode_setsTitle() {
-    let c = from(mediaName: "Billie Jean", mediaTypeMode: "song")
+    let c = criteria(mediaName: "Billie Jean", mediaTypeMode: "song")
     #expect(c.query == "Billie Jean")
     #expect(c.searchMode == "song")
     #expect(c.title == "Billie Jean")
@@ -140,7 +151,7 @@ struct MediaIntentCriteriaFromTests {
   }
 
   @Test func playlist_viaMediaTypeMode_setsPlaylist() {
-    let c = from(mediaName: "Workout", mediaTypeMode: "playlist")
+    let c = criteria(mediaName: "Workout", mediaTypeMode: "playlist")
     #expect(c.query == "Workout")
     #expect(c.searchMode == "playlist")
     #expect(c.playlist == "Workout")
@@ -149,19 +160,19 @@ struct MediaIntentCriteriaFromTests {
 
   // "Play jazz station" → vertical wins as mode; genre rides as a filter.
   @Test func station_withGenreFilter() {
-    let c = from(genreNames: ["jazz"], mediaTypeMode: "station", hasMediaType: true)
+    let c = criteria(genreNames: ["jazz"], mediaTypeMode: "station", hasMediaType: true)
     #expect(c.searchMode == "station")
     #expect(c.genre == "jazz")
   }
 
   @Test func podcast_setsMode() {
-    let c = from(mediaName: "Serial", mediaTypeMode: "podcast", hasMediaType: true)
+    let c = criteria(mediaName: "Serial", mediaTypeMode: "podcast", hasMediaType: true)
     #expect(c.searchMode == "podcast")
     #expect(c.query == "Serial")
   }
 
   @Test func plainName_hasNoStructuredFields() {
-    let c = from(mediaName: "KCRW")
+    let c = criteria(mediaName: "KCRW")
     #expect(c.searchMode == nil)
     #expect(c.genre == nil)
     #expect(c.artist == nil)

package/ios/Tests/NowPlayingButtonRulesTests.swift

@@ -0,0 +1,43 @@
+@testable import AudioBrowserTestable
+import Testing
+
+@Suite("NowPlayingButtonRules")
+struct NowPlayingButtonRulesTests {
+  @Test func buttons_dropRepeats_keepingFirstOrder() {
+    #expect(NowPlayingButtonRules.buttons(["shuffle", "favorite", "shuffle", "repeat"]) == ["shuffle", "favorite", "repeat"])
+  }
+
+  @Test func buttons_capAtFive_afterDroppingRepeats() {
+    let configured = ["a", "a", "b", "c", "d", "e", "f"]
+    #expect(NowPlayingButtonRules.buttons(configured) == ["a", "b", "c", "d", "e"])
+  }
+
+  @Test func buttons_empty() {
+    #expect(NowPlayingButtonRules.buttons([String]()).isEmpty)
+  }
+
+  @Test func repeatMode_cyclesOffTrackQueue() {
+    #expect(NowPlayingButtonRules.repeatMode(after: .off) == .track)
+    #expect(NowPlayingButtonRules.repeatMode(after: .track) == .queue)
+    #expect(NowPlayingButtonRules.repeatMode(after: .queue) == .off)
+  }
+
+  @Test func rate_advancesFromAConfiguredRate_andWraps() {
+    let rates = [0.5, 1, 1.5, 2]
+    #expect(NowPlayingButtonRules.rate(after: 1, in: rates) == 1.5)
+    #expect(NowPlayingButtonRules.rate(after: 2, in: rates) == 0.5)
+  }
+
+  @Test func rate_matchesAConfiguredRateWithinAHundredth() {
+    #expect(NowPlayingButtonRules.rate(after: 1.005, in: [1, 1.5]) == 1.5)
+  }
+
+  @Test func rate_offTheList_takesTheFirstAboveIt_elseTheFirst() {
+    #expect(NowPlayingButtonRules.rate(after: 1.2, in: [0.5, 1, 1.5]) == 1.5)
+    #expect(NowPlayingButtonRules.rate(after: 3, in: [0.5, 1, 1.5]) == 0.5)
+  }
+
+  @Test func rate_noRates_isNil() {
+    #expect(NowPlayingButtonRules.rate(after: 1, in: []) == nil)
+  }
+}

package/ios/Tests/PlayerTests.swift

@@ -1395,3 +1395,44 @@ struct MediaStackEffectTests {
     #expect(eh.appliedTimedMetadata == [metadata])
   }
 }
+
+@Suite("Player - now-playing preview")
+struct NowPlayingPreviewTests {
+  @Test @MainActor
+  func preview_showsTheTappedTrackWithoutLoadingIt() {
+    let (c, eh, _, _) = makeCoordinator()
+    let tapped = Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped")
+
+    c.previewNowPlaying(tapped)
+
+    #expect(eh.loadNowPlayingMetadataCalls.map(\.id) == ["tapped"])
+    #expect(eh.resolveAndLoadCalls.isEmpty)
+    #expect(c.currentTrack == nil)
+  }
+
+  @Test @MainActor
+  func endingPreview_restoresTheCurrentTrackAndRendersItsLines() {
+    let (c, eh, _, _) = makeCoordinator()
+    loadTrack(c, id: "current")
+    c.previewNowPlaying(Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped"))
+    let rendersBefore = eh.nowPlayingRenderCount
+
+    c.endNowPlayingPreview()
+
+    #expect(eh.loadNowPlayingMetadataCalls.last?.id == "current")
+    #expect(eh.nowPlayingRenderCount == rendersBefore + 1)
+    #expect(eh.clearNowPlayingCallCount == 0)
+  }
+
+  @Test @MainActor
+  func endingPreview_withNothingCurrent_clearsTheSurface() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.previewNowPlaying(Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped"))
+
+    c.endNowPlayingPreview()
+
+    #expect(eh.clearNowPlayingCallCount == 1)
+    #expect(eh.loadNowPlayingMetadataCalls.map(\.id) == ["tapped"])
+    #expect(eh.nowPlayingRenderCount == 0)
+  }
+}

package/ios/Util/ConcurrentMap.swift

@@ -0,0 +1,19 @@
+extension Array where Element: Sendable {
+  /// `transform` over every element at once, with the results in element order. Cancelling the
+  /// caller cancels every transform still running.
+  func concurrentMap<T: Sendable>(_ transform: @escaping @MainActor (Element) async -> T) async -> [T] {
+    await withTaskGroup(of: (Int, T).self) { group in
+      for (index, element) in enumerated() {
+        group.addTask {
+          let result = await transform(element)
+          return (index, result)
+        }
+      }
+      var results: [(Int, T)] = []
+      for await result in group {
+        results.append(result)
+      }
+      return results.sorted { $0.0 < $1.0 }.map(\.1)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-browser",
-  "version": "0.2.0-next.34",
+  "version": "0.2.0-next.35",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",

package/ios/CarPlay/HybridAudioBrowser+IntentFavorite.swift

@@ -1,20 +0,0 @@
-import Foundation
-import os.log
-
-private let intentLogger = Logger(subsystem: "com.audiobrowser", category: "MediaIntent")
-
-extension HybridAudioBrowser {
-  /// Sets the favorite state of the playing track for a Siri intent, through the same path as
-  /// the CarPlay favorite button. False when nothing is playing, the playing track has no
-  /// identity to favorite, or the change throws.
-  @MainActor
-  static func favoriteCurrentTrack(_ favorited: Bool) -> Bool {
-    guard let browser = shared else { return false }
-    do {
-      return try browser.favoriteActiveTrack(favorited)
-    } catch {
-      intentLogger.error("favoriteCurrentTrack(\(favorited)) failed: \(error.localizedDescription)")
-      return false
-    }
-  }
-}

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -1,59 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INAddMediaIntent` handler — "Hey Siri, add this to my favorites."
-/// Adding to the user's collection maps onto the library-managed favorite state
-/// of the **currently playing** track via `setActiveTrackFavorited` — the same
-/// path as the CarPlay favorite button and the `INUpdateMediaAffinityIntent`
-/// "like", so it flips the now-playing heart and fires `onFavoriteChanged` for
-/// the consumer to persist. No extra config beyond the `favorite` capability.
-///
-/// We expose a single flat favorites collection (no named playlists), so the
-/// destination always resolves to the user's library. Adding a *named* item
-/// that isn't currently playing needs the structured-intent consumer callback
-/// and is out of scope here — like the named play-by-search case.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAddHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-@objc(RNABMediaAddHandler)
-class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAddHandler")
-
-  func handle(
-    intent _: INAddMediaIntent,
-    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void,
-  ) {
-    Self.logger.info("Add media — favorite current track")
-
-    Task { @MainActor in
-      let applied = HybridAudioBrowser.favoriteCurrentTrack(true)
-      completion(INAddMediaIntentResponse(code: applied ? .success : .failure, userActivity: nil))
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). These are
-  // *optional* @objc protocol methods, so pin the exact selectors SiriKit
-  // dispatches to (otherwise they aren't exposed and are "not found"). We act on
-  // the currently-playing track / our single library, so pass both through.
-  @objc(resolveMediaItemsForAddMedia:withCompletion:)
-  func resolveMediaItems(
-    for intent: INAddMediaIntent,
-    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-
-  @objc(resolveMediaDestinationForAddMedia:withCompletion:)
-  func resolveMediaDestination(
-    for _: INAddMediaIntent,
-    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
-  ) {
-    // One flat favorites collection — always the user's library, no playlists.
-    completion(.success(with: INMediaDestination.library))
-  }
-}

package/ios/CarPlay/RNABMediaAffinityHandler.swift

@@ -1,53 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INUpdateMediaAffinityIntent` handler — "Hey Siri, I like / don't like
-/// this." Maps the affinity onto the library-managed favorite state of the
-/// **currently playing** track via `setActiveTrackFavorited` — the same path as
-/// the CarPlay favorite button — so it flips the now-playing heart and fires
-/// `onFavoriteChanged` for the consumer to persist. Like → favorited, dislike →
-/// unfavorited. No extra config beyond the `favorite` capability.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAffinityHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-///
-/// Affinity for a *named* item ("I like «station»") is out of scope here — that
-/// needs the structured-intent consumer callback.
-@objc(RNABMediaAffinityHandler)
-class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAffinityHandler")
-
-  func handle(
-    intent: INUpdateMediaAffinityIntent,
-    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void,
-  ) {
-    let affinity = intent.affinityType
-    Self.logger.info("Update media affinity — type=\(affinity.rawValue)")
-
-    Task { @MainActor in
-      let applied = switch affinity {
-      case .like: HybridAudioBrowser.favoriteCurrentTrack(true)
-      case .dislike: HybridAudioBrowser.favoriteCurrentTrack(false)
-      default: false
-      }
-      completion(INUpdateMediaAffinityIntentResponse(code: applied ? .success : .failure, userActivity: nil))
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). This is an
-  // *optional* @objc protocol method, so pin the exact selector SiriKit dispatches
-  // to (otherwise it isn't exposed and is "not found"). We act on the currently
-  // playing track regardless, so pass the spoken item straight through.
-  @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
-  func resolveMediaItems(
-    for intent: INUpdateMediaAffinityIntent,
-    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-}