react-native-audio-browser 0.1.1 → 0.2.0-next.10

package/ios/Browser/SectionScope.swift

@@ -0,0 +1,35 @@
+// Queue scope is the tapped section, not the whole page (ADR 0006): the
+// playback context a listener expects is the list they tapped in — a page
+// aggregating several sections must not leak next/previous across them.
+enum SectionScope {
+  enum Section {
+    /// The tapped id lives inside an image row's items.
+    case imageRow([ImageRowItem])
+    /// The contiguous `groupTitle` run around the tapped child (items with
+    /// no group title form runs of their own).
+    case run([Track])
+  }
+
+  /// The section of `children` containing the playable `trackId`, or nil
+  /// when the id is not found.
+  static func section(of children: [Track], containing trackId: String) -> Section? {
+    for child in children {
+      if let items = child.imageRow, items.contains(where: { $0.src == trackId }) {
+        return .imageRow(items)
+      }
+    }
+    guard let index = children.firstIndex(where: { $0.src == trackId }) else {
+      return nil
+    }
+    let group = children[index].groupTitle
+    var start = index
+    while start > 0, children[start - 1].groupTitle == group {
+      start -= 1
+    }
+    var end = index
+    while end + 1 < children.count, children[end + 1].groupTitle == group {
+      end += 1
+    }
+    return .run(Array(children[start ... end]))
+  }
+}

package/ios/Browser/TabBarEntries.swift

@@ -0,0 +1,15 @@
+/// Compares the tab-list fields the CarPlay tab bar actually renders.
+enum TabBarEntries {
+  /// Whether two tab lists produce identical tab-bar entries — title, url,
+  /// and the artwork inputs of `applyTabBarEntry`. Used to suppress
+  /// `tabsChanged` when a tabs re-query (e.g. from `invalidateAllContent()`)
+  /// resolves to the same entries, so an unchanged result never churns the
+  /// tab bar or resets its selection.
+  static func same(_ old: [Track]?, _ new: [Track]) -> Bool {
+    guard let old, old.count == new.count else { return false }
+    return zip(old, new).allSatisfy {
+      $0.title == $1.title && $0.url == $1.url && $0.artwork == $1.artwork
+        && $0.artworkSource?.uri == $1.artworkSource?.uri
+    }
+  }
+}

package/ios/CarPlay/CPInterfaceController+Safe.swift

@@ -0,0 +1,126 @@
+import CarPlay
+import os.log
+
+/// Logged, precondition-guarded wrappers around `CPInterfaceController`'s
+/// template-stack mutations.
+///
+/// Per the SDK header, an unsuccessful push/setRoot/present with a nil
+/// completion doesn't fail quietly — it throws an Objective-C exception (depth
+/// limit included) that takes down the whole app, not just the CarPlay scene;
+/// pushing a template that is already in the hierarchy raises regardless.
+/// Every stack mutation therefore goes through these helpers: the raise-prone
+/// preconditions are checked up front, the underlying call always gets a
+/// completion, and every failure is logged, with an optional caller completion
+/// for call sites that chain on the result.
+@MainActor
+extension CPInterfaceController {
+  private static let stackLogger = Logger(subsystem: "com.audiobrowser", category: "TemplateStack")
+
+  private static func name(of template: CPTemplate) -> String {
+    String(describing: type(of: template))
+  }
+
+  /// CarPlay's template-stack depth cap for audio apps. Not exposed by the SDK;
+  /// exceeding it raises `NSGenericException` ("Application exceeded the
+  /// hierarchy depth limit") synchronously — even through the completion-based
+  /// push — taking down the whole app, not just the CarPlay scene.
+  private static let maximumStackDepth = 5
+
+  /// Pushes `template`, skipping the raise cases (already in the hierarchy,
+  /// stack at the depth limit).
+  func safePush(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    guard !templates.contains(where: { $0 === template }) else {
+      Self.stackLogger.warning("push skipped: \(Self.name(of: template)) is already in the stack")
+      completion?(false, nil)
+      return
+    }
+    guard templates.count < Self.maximumStackDepth else {
+      Self.stackLogger.error("push skipped: \(Self.name(of: template)) would exceed the depth limit (\(self.templates.count) templates)")
+      completion?(false, nil)
+      return
+    }
+    pushTemplate(template, animated: animated) { pushed, error in
+      if let error {
+        Self.stackLogger.error("pushTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
+      }
+      completion?(pushed, error)
+    }
+  }
+
+  /// Pops the top template, skipping the raise case (nothing above the root).
+  func safePop(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    guard templates.count > 1 else {
+      Self.stackLogger.warning("pop skipped: already at the root template")
+      completion?(false, nil)
+      return
+    }
+    popTemplate(animated: animated) { popped, error in
+      if let error {
+        Self.stackLogger.error("popTemplate failed: \(error.localizedDescription)")
+      }
+      completion?(popped, error)
+    }
+  }
+
+  /// Pops back to `template`, skipping the raise case (not in the hierarchy).
+  /// A no-op success when it is already the top template.
+  func safePop(to template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    guard templates.contains(where: { $0 === template }) else {
+      Self.stackLogger.warning("pop(to:) skipped: \(Self.name(of: template)) is not in the stack")
+      completion?(false, nil)
+      return
+    }
+    guard topTemplate !== template else {
+      completion?(true, nil)
+      return
+    }
+    pop(to: template, animated: animated) { popped, error in
+      if let error {
+        Self.stackLogger.error("pop(to:) \(Self.name(of: template)) failed: \(error.localizedDescription)")
+      }
+      completion?(popped, error)
+    }
+  }
+
+  func safePopToRoot(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    popToRootTemplate(animated: animated) { popped, error in
+      if let error {
+        Self.stackLogger.error("popToRootTemplate failed: \(error.localizedDescription)")
+      }
+      completion?(popped, error)
+    }
+  }
+
+  func safeSetRoot(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    setRootTemplate(template, animated: animated) { set, error in
+      if let error {
+        Self.stackLogger.error("setRootTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
+      }
+      completion?(set, error)
+    }
+  }
+
+  func safePresent(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    presentTemplate(template, animated: animated) { presented, error in
+      if let error {
+        Self.stackLogger.error("presentTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
+      }
+      completion?(presented, error)
+    }
+  }
+
+  /// Dismisses the presented template, skipping when nothing is presented.
+  func safeDismiss(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
+    guard presentedTemplate != nil else {
+      Self.stackLogger.debug("dismiss skipped: no presented template")
+      completion?(false, nil)
+      return
+    }
+    dismissTemplate(animated: animated) { dismissed, error in
+      if let error {
+        Self.stackLogger.error("dismissTemplate failed: \(error.localizedDescription)")
+      }
+      completion?(dismissed, error)
+    }
+  }
+}

package/ios/CarPlay/CarPlayArtworkResolver.swift

@@ -41,7 +41,7 @@ enum CarPlayArtworkResolver {
     targetWidth: Double,
     targetHeight: Double,
     displayScale: Double,
-    urlResolver: ((Double, Double) async -> ArtworkResolvedImage?)?
+    urlResolver: ((Double, Double) async -> ArtworkResolvedImage?)?,
   ) async -> ArtworkLoadAction {
     // 1. Primary SF symbol check
     if let artwork, artwork.hasPrefix("sf:") {
@@ -59,7 +59,7 @@ enum CarPlayArtworkResolver {
             artworkSourceUri: artworkSourceUri,
             artworkCarPlayTinted: artworkCarPlayTinted,
             targetWidth: targetWidth,
-            targetHeight: targetHeight
+            targetHeight: targetHeight,
           )
         }
         let isSvg = resolvedUrl.pathExtension.lowercased() == "svg"
@@ -67,7 +67,7 @@ enum CarPlayArtworkResolver {
           uri: resolved.uri,
           headers: resolved.headers,
           shouldTint: artworkCarPlayTinted ?? false,
-          isSvg: isSvg
+          isSvg: isSvg,
         )
       }
     }
@@ -78,7 +78,7 @@ enum CarPlayArtworkResolver {
       artworkSourceUri: artworkSourceUri,
       artworkCarPlayTinted: artworkCarPlayTinted,
       targetWidth: targetWidth,
-      targetHeight: targetHeight
+      targetHeight: targetHeight,
     )
   }
 
@@ -87,7 +87,7 @@ enum CarPlayArtworkResolver {
     artworkSourceUri: String?,
     artworkCarPlayTinted: Bool?,
     targetWidth: Double,
-    targetHeight: Double
+    targetHeight: Double,
   ) -> ArtworkLoadAction {
     guard let directUri = artwork ?? artworkSourceUri else { return .none }
 
@@ -101,7 +101,7 @@ enum CarPlayArtworkResolver {
       uri: directUri,
       headers: nil,
       shouldTint: artworkCarPlayTinted ?? false,
-      isSvg: isSvg
+      isSvg: isSvg,
     )
   }
 }