@rntp/player 5.0.0-beta.2 → 5.0.0-beta.4

package/RNTPPlayer.podspec

@@ -16,6 +16,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
   s.exclude_files = "ios/tests/**", "ios/Package.swift"
   s.private_header_files = "ios/**/*.h"
+  s.frameworks = "CarPlay"
 
   install_modules_dependencies(s)
 end

package/android/src/main/java/com/doublesymmetry/trackplayer/TrackPlayerModule.kt

@@ -502,6 +502,66 @@ class TrackPlayerModule internal constructor(private val context: ReactApplicati
 
   // endregion
 
+  // region Sleep Timer
+
+  @ReactMethod
+  override fun sleepAfterTime(seconds: Double, fadeOutSeconds: Double) {
+    controller.run { mc ->
+      val args = Bundle().apply {
+        putDouble("seconds", seconds)
+        putDouble("fadeOutSeconds", fadeOutSeconds)
+      }
+      mc?.sendCustomCommand(
+        SessionCommand(TrackPlayerPlaybackService.COMMAND_SLEEP_AFTER_TIME, Bundle.EMPTY),
+        args
+      )
+    }
+  }
+
+  @ReactMethod
+  override fun sleepAfterMediaItemAtIndex(index: Double) {
+    controller.run { mc ->
+      val args = Bundle().apply { putInt("index", index.toInt()) }
+      mc?.sendCustomCommand(
+        SessionCommand(TrackPlayerPlaybackService.COMMAND_SLEEP_AFTER_MEDIA_ITEM, Bundle.EMPTY),
+        args
+      )
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun getSleepTimer(): WritableMap? {
+    val prefs = context.getSharedPreferences(PLAYER_PREFS_NAME, android.content.Context.MODE_PRIVATE)
+    val jsonStr = prefs.getString(TrackPlayerPlaybackService.SLEEP_TIMER_STATE_KEY, null) ?: return null
+    return try {
+      val json = JSONObject(jsonStr)
+      val type = json.getString("type")
+      val map = Arguments.createMap()
+      map.putString("type", type)
+      if (type == "time") {
+        map.putDouble("remainingSeconds", json.getDouble("remainingSeconds"))
+        map.putDouble("fadeOutSeconds", json.getDouble("fadeOutSeconds"))
+      } else {
+        map.putInt("index", json.getInt("index"))
+      }
+      map
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  @ReactMethod
+  override fun cancelSleepTimer() {
+    controller.run { mc ->
+      mc?.sendCustomCommand(
+        SessionCommand(TrackPlayerPlaybackService.COMMAND_CANCEL_SLEEP_TIMER, Bundle.EMPTY),
+        Bundle.EMPTY
+      )
+    }
+  }
+
+  // endregion
+
   // region Destroy
 
   @ReactMethod

package/android/src/main/java/com/doublesymmetry/trackplayer/TrackPlayerPlaybackService.kt

@@ -56,6 +56,7 @@ import com.doublesymmetry.trackplayer.models.WakeMode
 import android.os.Handler
 import android.os.Looper
 import com.doublesymmetry.trackplayer.models.PlaybackProgressUpdatedEvent
+import com.doublesymmetry.trackplayer.models.SleepTimerTriggeredEvent
 import org.json.JSONObject
 
 class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.MediaLibrarySession.Callback {
@@ -68,6 +69,14 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
   private var progressSyncTimer: java.util.Timer? = null
   private var progressSyncExecutor: java.util.concurrent.ExecutorService? = null
 
+  private var sleepTimerType: String? = null // "time" or "mediaItem"
+  private var sleepTimerRemainingSeconds: Double = 0.0
+  private var sleepTimerFadeOutSeconds: Double = 0.0
+  private var sleepTimerTargetIndex: Int? = null
+  private var sleepTimer: java.util.Timer? = null
+  private var sleepTimerPreFadeVolume: Float? = null
+  private var sleepTimerPreviousIndex: Int? = null
+
   @OptIn(UnstableApi::class)
   override fun onCreate() {
     super.onCreate()
@@ -136,6 +145,26 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
       override fun onIsPlayingChanged(isPlaying: Boolean) {
         if (isPlaying) startProgressSyncTimer() else stopProgressSyncTimer(fireFinalTick = true)
       }
+
+      override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+        val currentIndex = activePlayer?.currentMediaItemIndex ?: 0
+        if (sleepTimerType == "mediaItem") {
+          val targetIndex = sleepTimerTargetIndex
+          if (targetIndex != null && sleepTimerPreviousIndex == targetIndex && currentIndex != targetIndex) {
+            this@TrackPlayerPlaybackService.emitEvent(SleepTimerTriggeredEvent("mediaItem"))
+            cancelSleepTimerInternal(restoreVolume = false)
+            // Defer pause to next run loop — calling during transition gets overridden
+            Handler(Looper.getMainLooper()).post { activePlayer?.pause() }
+          }
+        }
+        sleepTimerPreviousIndex = currentIndex
+      }
+
+      override fun onTimelineChanged(timeline: androidx.media3.common.Timeline, reason: Int) {
+        if (sleepTimerType == "mediaItem" && (activePlayer?.mediaItemCount ?: 0) == 0) {
+          cancelSleepTimerInternal(restoreVolume = false)
+        }
+      }
     })
     val player = createForwardingPlayer(activePlayer, config)
 
@@ -275,6 +304,7 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
     simpleCache?.release()
     simpleCache = null
     sharedCache = null
+    cancelSleepTimerInternal(restoreVolume = false)
     stopProgressSyncTimer(fireFinalTick = false)
     progressSyncExecutor?.shutdown()
     progressSyncExecutor = null
@@ -355,6 +385,37 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
         activePlayer?.seekToPreviousMediaItem()
         return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
       }
+      COMMAND_SLEEP_AFTER_TIME -> {
+        val seconds = args.getDouble("seconds")
+        val fadeOutSeconds = args.getDouble("fadeOutSeconds")
+        cancelSleepTimerInternal(restoreVolume = true)
+        sleepTimerType = "time"
+        sleepTimerRemainingSeconds = seconds
+        sleepTimerFadeOutSeconds = fadeOutSeconds.coerceAtMost(seconds)
+        persistSleepTimerState()
+
+        if (seconds <= 0) {
+          activePlayer?.pause()
+          this@TrackPlayerPlaybackService.emitEvent(SleepTimerTriggeredEvent("time"))
+          cancelSleepTimerInternal(restoreVolume = true)
+        } else {
+          startSleepCountdownTimer()
+        }
+        return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+      }
+      COMMAND_SLEEP_AFTER_MEDIA_ITEM -> {
+        val index = args.getInt("index")
+        cancelSleepTimerInternal(restoreVolume = true)
+        sleepTimerType = "mediaItem"
+        sleepTimerTargetIndex = index
+        sleepTimerPreviousIndex = activePlayer?.currentMediaItemIndex
+        persistSleepTimerState()
+        return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+      }
+      COMMAND_CANCEL_SLEEP_TIMER -> {
+        cancelSleepTimerInternal(restoreVolume = true)
+        return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+      }
     }
     return super.onCustomCommand(session, controller, customCommand, args)
   }
@@ -404,12 +465,20 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
       return Futures.immediateFuture(LibraryResult.ofItemList(ImmutableList.copyOf(categoryItems), params))
     }
 
+    // Check if it's a category
     val category = browseTree.findCategory(parentId)
     if (category != null) {
       val mediaItems = category.items.map { it.toMediaItem() }
       return Futures.immediateFuture(LibraryResult.ofItemList(ImmutableList.copyOf(mediaItems), params))
     }
 
+    // Check if it's a browsable item with children
+    val browseItem = browseTree.findItem(parentId)
+    if (browseItem != null && browseItem.children != null) {
+      val mediaItems = browseItem.children.map { it.toMediaItem() }
+      return Futures.immediateFuture(LibraryResult.ofItemList(ImmutableList.copyOf(mediaItems), params))
+    }
+
     return Futures.immediateFuture(LibraryResult.ofError(LibraryResult.RESULT_ERROR_BAD_VALUE))
   }
 
@@ -475,6 +544,9 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
       .add(SessionCommand(COMMAND_SEEK_TO_NEXT, Bundle.EMPTY))
       .add(SessionCommand(COMMAND_SEEK_TO_PREVIOUS, Bundle.EMPTY))
       .add(SessionCommand(COMMAND_UPDATE_PROGRESS_SYNC_HEADERS, Bundle.EMPTY))
+      .add(SessionCommand(COMMAND_SLEEP_AFTER_TIME, Bundle.EMPTY))
+      .add(SessionCommand(COMMAND_SLEEP_AFTER_MEDIA_ITEM, Bundle.EMPTY))
+      .add(SessionCommand(COMMAND_CANCEL_SLEEP_TIMER, Bundle.EMPTY))
       .build()
 
   // endregion
@@ -554,6 +626,86 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
 
   // endregion
 
+  // region Sleep Timer
+
+  private fun cancelSleepTimerInternal(restoreVolume: Boolean) {
+    sleepTimer?.cancel()
+    sleepTimer = null
+    if (restoreVolume) {
+      sleepTimerPreFadeVolume?.let { activePlayer?.volume = it }
+    }
+    sleepTimerPreFadeVolume = null
+    sleepTimerType = null
+    sleepTimerRemainingSeconds = 0.0
+    sleepTimerFadeOutSeconds = 0.0
+    sleepTimerTargetIndex = null
+    sleepTimerPreviousIndex = null
+    persistSleepTimerState()
+  }
+
+  private fun onSleepTimerTick() {
+    sleepTimerRemainingSeconds -= 1.0
+    persistSleepTimerState()
+
+    // Handle fade-out (before zero-check so final tick sets volume to 0)
+    if (sleepTimerFadeOutSeconds > 0 && sleepTimerRemainingSeconds < sleepTimerFadeOutSeconds) {
+      if (sleepTimerPreFadeVolume == null) {
+        sleepTimerPreFadeVolume = activePlayer?.volume ?: 1f
+      }
+      val progress = maxOf(0.0, sleepTimerRemainingSeconds / sleepTimerFadeOutSeconds).toFloat()
+      activePlayer?.volume = (sleepTimerPreFadeVolume ?: 1f) * progress
+    }
+
+    if (sleepTimerRemainingSeconds <= 0) {
+      sleepTimerRemainingSeconds = 0.0
+      activePlayer?.pause()
+      this@TrackPlayerPlaybackService.emitEvent(SleepTimerTriggeredEvent("time"))
+      // Restore volume after pausing so next playback isn't muted
+      cancelSleepTimerInternal(restoreVolume = true)
+      return
+    }
+  }
+
+  private fun startSleepCountdownTimer() {
+    sleepTimer?.cancel()
+    val handler = Handler(Looper.getMainLooper())
+    sleepTimer = java.util.Timer().apply {
+      scheduleAtFixedRate(object : java.util.TimerTask() {
+        override fun run() {
+          handler.post { onSleepTimerTick() }
+        }
+      }, 1000L, 1000L)
+    }
+  }
+
+  private fun pauseSleepCountdownTimer() {
+    sleepTimer?.cancel()
+    sleepTimer = null
+  }
+
+  private fun persistSleepTimerState() {
+    val prefs = getSharedPreferences(TrackPlayerModule.PLAYER_PREFS_NAME, MODE_PRIVATE)
+    val editor = prefs.edit()
+    val type = sleepTimerType
+    if (type == null) {
+      editor.remove(SLEEP_TIMER_STATE_KEY)
+    } else {
+      val json = JSONObject().apply {
+        put("type", type)
+        if (type == "time") {
+          put("remainingSeconds", sleepTimerRemainingSeconds)
+          put("fadeOutSeconds", sleepTimerFadeOutSeconds)
+        } else {
+          put("index", sleepTimerTargetIndex ?: 0)
+        }
+      }
+      editor.putString(SLEEP_TIMER_STATE_KEY, json.toString())
+    }
+    editor.apply()
+  }
+
+  // endregion
+
   // region Progress Sync
 
   private fun startProgressSyncTimer() {
@@ -651,6 +803,10 @@ class TrackPlayerPlaybackService: MediaLibraryService(), MediaLibraryService.Med
     const val COMMAND_SEEK_TO_PREVIOUS = "trackplayer.seek_to_previous"
     const val COMMAND_UPDATE_PROGRESS_SYNC_HEADERS = "trackplayer.update_progress_sync_headers"
     const val PROGRESS_SYNC_SAVED_KEY = "progress_sync_saved"
+    const val COMMAND_SLEEP_AFTER_TIME = "trackplayer.sleep_after_time"
+    const val COMMAND_SLEEP_AFTER_MEDIA_ITEM = "trackplayer.sleep_after_media_item"
+    const val COMMAND_CANCEL_SLEEP_TIMER = "trackplayer.cancel_sleep_timer"
+    const val SLEEP_TIMER_STATE_KEY = "sleep_timer_state"
 
     @Volatile
     var sharedCache: SimpleCache? = null

package/android/src/main/java/com/doublesymmetry/trackplayer/models/BrowseTree.kt

@@ -26,14 +26,18 @@ data class BrowseCategory(
 @Serializable
 data class BrowseMediaItem(
   val mediaId: String,
-  val url: String,
+  val url: String? = null,
   val title: String? = null,
   val artist: String? = null,
   val albumTitle: String? = null,
   val artworkUrl: String? = null,
   val duration: Double? = null,
   val isLive: Boolean? = null,
+  val children: List<BrowseMediaItem>? = null,
 ) {
+  val isPlayable: Boolean get() = url != null
+  val isBrowsable: Boolean get() = children != null && url == null
+
   fun toMediaItem(): MediaItem {
     val extras = Bundle()
     duration?.let { extras.putDouble("duration", it) }
@@ -44,16 +48,20 @@ data class BrowseMediaItem(
       .setArtist(artist)
       .setAlbumTitle(albumTitle)
       .setArtworkUri(artworkUrl?.let { Uri.parse(it) })
-      .setIsBrowsable(false)
-      .setIsPlayable(true)
+      .setIsBrowsable(isBrowsable)
+      .setIsPlayable(isPlayable)
+      .setMediaType(if (isBrowsable) MediaMetadata.MEDIA_TYPE_FOLDER_MIXED else MediaMetadata.MEDIA_TYPE_MUSIC)
       .setExtras(extras)
       .build()
 
     val builder = MediaItem.Builder()
       .setMediaId(mediaId)
-      .setUri(url)
       .setMediaMetadata(metadata)
 
+    if (url != null) {
+      builder.setUri(url)
+    }
+
     if (isLive == true) {
       builder.setLiveConfiguration(MediaItem.LiveConfiguration.Builder().build())
     }
@@ -75,7 +83,7 @@ data class BrowseTree(
     categories.find { it.mediaId == mediaId }
 
   fun findItem(mediaId: String): BrowseMediaItem? =
-    categories.flatMap { it.items }.find { it.mediaId == mediaId }
+    categories.flatMap { findItemRecursive(it.items, mediaId) }.firstOrNull()
 
   companion object {
     private const val BROWSE_TREE_KEY = "browse_tree"
@@ -98,24 +106,47 @@ data class BrowseTree(
         val title = catMap.getString("title") ?: continue
         val itemsArray = catMap.getArray("items") ?: continue
 
-        val items = mutableListOf<BrowseMediaItem>()
-        for (j in 0 until itemsArray.size()) {
-          val itemMap = itemsArray.getMap(j) ?: continue
-          items.add(BrowseMediaItem(
-            mediaId = itemMap.getString("mediaId") ?: continue,
-            url = itemMap.getString("url") as? String ?: continue,
-            title = if (itemMap.hasKey("title")) itemMap.getString("title") else null,
-            artist = if (itemMap.hasKey("artist")) itemMap.getString("artist") else null,
-            albumTitle = if (itemMap.hasKey("albumTitle")) itemMap.getString("albumTitle") else null,
-            artworkUrl = if (itemMap.hasKey("artworkUrl")) itemMap.getString("artworkUrl") else null,
-            duration = if (itemMap.hasKey("duration")) itemMap.getDouble("duration") else null,
-            isLive = if (itemMap.hasKey("isLive")) itemMap.getBoolean("isLive") else null,
-          ))
-        }
-
+        val items = parseItems(itemsArray)
         categories.add(BrowseCategory(mediaId = mediaId, title = title, items = items))
       }
       return BrowseTree(categories)
     }
+
+    private fun parseItems(data: ReadableArray): List<BrowseMediaItem> {
+      val items = mutableListOf<BrowseMediaItem>()
+      for (i in 0 until data.size()) {
+        val itemMap = data.getMap(i) ?: continue
+        val mediaId = itemMap.getString("mediaId") ?: continue
+
+        val children = if (itemMap.hasKey("children")) {
+          itemMap.getArray("children")?.let { parseItems(it) }
+        } else null
+
+        items.add(BrowseMediaItem(
+          mediaId = mediaId,
+          url = if (itemMap.hasKey("url")) itemMap.getString("url") else null,
+          title = if (itemMap.hasKey("title")) itemMap.getString("title") else null,
+          artist = if (itemMap.hasKey("artist")) itemMap.getString("artist") else null,
+          albumTitle = if (itemMap.hasKey("albumTitle")) itemMap.getString("albumTitle") else null,
+          artworkUrl = if (itemMap.hasKey("artworkUrl")) itemMap.getString("artworkUrl") else null,
+          duration = if (itemMap.hasKey("duration")) itemMap.getDouble("duration") else null,
+          isLive = if (itemMap.hasKey("isLive")) itemMap.getBoolean("isLive") else null,
+          children = children,
+        ))
+      }
+      return items
+    }
+
+    private fun findItemRecursive(items: List<BrowseMediaItem>, mediaId: String): List<BrowseMediaItem> {
+      for (item in items) {
+        if (item.mediaId == mediaId) return listOf(item)
+        val children = item.children
+        if (children != null) {
+          val found = findItemRecursive(children, mediaId)
+          if (found.isNotEmpty()) return found
+        }
+      }
+      return emptyList()
+    }
   }
 }

package/android/src/main/java/com/doublesymmetry/trackplayer/models/EmitEventType.kt

@@ -21,6 +21,7 @@ enum class EmitEventType(val value: String) {
   REMOTE_SKIP_FORWARD("event.remote-skip-forward"),
   REMOTE_SKIP_BACKWARD("event.remote-skip-backward"),
   PLAYBACK_PROGRESS_UPDATED("event.playback-progress-updated"),
+  SLEEP_TIMER_TRIGGERED("event.sleep-timer-triggered"),
 }
 
 interface EmitEvent {
@@ -116,3 +117,13 @@ data class PlaybackProgressUpdatedEvent(
     )
   }
 }
+
+data class SleepTimerTriggeredEvent(
+  val sleepType: String,
+): EmitEvent {
+  override val type = EmitEventType.SLEEP_TIMER_TRIGGERED
+
+  override fun pairs(): Array<Pair<String, Any>> {
+    return arrayOf("type" to sleepType)
+  }
+}

package/ios/CarPlay/BrowseTreeStore.swift

@@ -0,0 +1,40 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import Foundation
+
+class BrowseTreeStore {
+    static let shared = BrowseTreeStore()
+
+    static let didChangeNotification = Notification.Name("RNTPBrowseTreeDidChange")
+    static let nowPlayingChangedNotification = Notification.Name("RNTPNowPlayingChanged")
+
+    /// The current browse tree categories as raw dictionaries from JS.
+    private(set) var categories: [[String: Any]] = []
+
+    /// Reference to the AudioPlayer, set during setupPlayer().
+    weak var player: AudioPlayer?
+
+    /// The mediaId of the currently playing item, if any.
+    private(set) var currentMediaId: String?
+
+    private init() {}
+
+    func updateNowPlaying(mediaId: String?) {
+        currentMediaId = mediaId
+        NotificationCenter.default.post(name: Self.nowPlayingChangedNotification, object: nil)
+    }
+
+    func update(categories: [[String: Any]]) {
+        self.categories = categories
+        NotificationCenter.default.post(name: Self.didChangeNotification, object: nil)
+    }
+
+    func clear() {
+        self.categories = []
+        self.player = nil
+        NotificationCenter.default.post(name: Self.didChangeNotification, object: nil)
+    }
+}