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

package/android/src/test/java/com/doublesymmetry/trackplayer/models/TrackPlayerMediaItemTest.kt

@@ -0,0 +1,380 @@
+package com.doublesymmetry.trackplayer.models
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import com.facebook.react.bridge.ReadableType
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkStatic
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class TrackPlayerMediaItemTest {
+
+    @Before
+    fun setUp() {
+        // Arguments.createMap() and createArray() call into native code; replace with JavaOnlyMap.
+        mockkStatic(Arguments::class)
+        every { Arguments.createMap() } answers { JavaOnlyMap() }
+    }
+
+    @After
+    fun tearDown() {
+        unmockkStatic(Arguments::class)
+    }
+
+    // ---- fromReadableMap ----
+
+    @Test
+    fun `fromReadableMap parses basic fields`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "String" }
+            every { getString("url") } returns "https://example.com/track.mp3"
+            every { hasKey("mediaId") } returns true
+            every { getString("mediaId") } returns "track-123"
+            every { hasKey("title") } returns true
+            every { getString("title") } returns "My Track"
+            every { hasKey("artist") } returns true
+            every { getString("artist") } returns "My Artist"
+            every { hasKey("albumTitle") } returns true
+            every { getString("albumTitle") } returns "My Album"
+            every { hasKey("artworkUrl") } returns true
+            every { getString("artworkUrl") } returns "https://example.com/art.jpg"
+            every { hasKey("duration") } returns true
+            every { getDouble("duration") } returns 180.5
+            every { hasKey("isLive") } returns true
+            every { getBoolean("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertEquals("track-123", item.mediaId)
+        assertEquals("https://example.com/track.mp3", item.url)
+        assertEquals("My Track", item.title)
+        assertEquals("My Artist", item.artist)
+        assertEquals("My Album", item.albumTitle)
+        assertEquals("https://example.com/art.jpg", item.artworkUrl)
+        assertEquals(180.5, item.duration!!, 0.001)
+        assertEquals(false, item.isLive)
+        assertNull(item.mimeType)
+        assertNull(item.headers)
+    }
+
+    @Test
+    fun `fromReadableMap with missing optional fields uses null`() {
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "String" }
+            every { getString("url") } returns "https://example.com/track.mp3"
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertNull(item.mediaId)
+        assertEquals("https://example.com/track.mp3", item.url)
+        assertNull(item.title)
+        assertNull(item.artist)
+        assertNull(item.albumTitle)
+        assertNull(item.artworkUrl)
+        assertNull(item.duration)
+        assertNull(item.isLive)
+        assertNull(item.headers)
+    }
+
+    @Test
+    fun `fromReadableMap with url as object parses uri and headers`() {
+        val headersIterator = mockk<ReadableMapKeySetIterator> {
+            every { hasNextKey() } returnsMany listOf(true, true, false)
+            every { nextKey() } returnsMany listOf("Authorization", "X-Custom")
+        }
+        val headersMap = mockk<ReadableMap>(relaxed = true) {
+            every { keySetIterator() } returns headersIterator
+            every { getString("Authorization") } returns "Bearer token123"
+            every { getString("X-Custom") } returns "custom-value"
+        }
+        val urlMap = mockk<ReadableMap>(relaxed = true) {
+            every { getString("uri") } returns "https://example.com/secure.mp3"
+            every { getString("url") } returns null
+            every { getMap("headers") } returns headersMap
+        }
+
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "Map" }
+            every { getMap("url") } returns urlMap
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+
+        assertEquals("https://example.com/secure.mp3", item.url)
+        assertNotNull(item.headers)
+        assertEquals("Bearer token123", item.headers!!["Authorization"])
+        assertEquals("custom-value", item.headers!!["X-Custom"])
+    }
+
+    @Test
+    fun `fromReadableMap with url object falls back to url key when uri absent`() {
+        val urlMap = mockk<ReadableMap>(relaxed = true) {
+            every { getString("uri") } returns null
+            every { getString("url") } returns "https://example.com/fallback.mp3"
+            every { getMap("headers") } returns null
+        }
+
+        val map = mockk<ReadableMap>(relaxed = true) {
+            every { hasKey("url") } returns true
+            every { getType("url") } returns mockk { every { name } returns "Map" }
+            every { getMap("url") } returns urlMap
+            every { hasKey("mediaId") } returns false
+            every { hasKey("title") } returns false
+            every { hasKey("artist") } returns false
+            every { hasKey("albumTitle") } returns false
+            every { hasKey("artworkUrl") } returns false
+            every { hasKey("duration") } returns false
+            every { hasKey("isLive") } returns false
+            every { hasKey("mimeType") } returns false
+        }
+
+        val item = TrackPlayerMediaItem.fromReadableMap(map)
+        assertEquals("https://example.com/fallback.mp3", item.url)
+    }
+
+    // ---- asMediaItem ----
+
+    @Test
+    fun `asMediaItem produces correct Media3 MediaItem`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = "track-abc",
+            url = "https://example.com/track.mp3",
+            title = "Test Track",
+            artist = "Test Artist",
+            albumTitle = "Test Album",
+            artworkUrl = "https://example.com/art.jpg",
+        )
+
+        val mediaItem = item.asMediaItem()
+
+        assertEquals("track-abc", mediaItem.mediaId)
+        assertNotNull(mediaItem.localConfiguration)
+        assertEquals("https://example.com/track.mp3", mediaItem.localConfiguration!!.uri.toString())
+        assertEquals("Test Track", mediaItem.mediaMetadata.title.toString())
+        assertEquals("Test Artist", mediaItem.mediaMetadata.artist.toString())
+        assertEquals("Test Album", mediaItem.mediaMetadata.albumTitle.toString())
+        assertEquals("https://example.com/art.jpg", mediaItem.mediaMetadata.artworkUri.toString())
+    }
+
+    @Test
+    fun `asMediaItem uses url as mediaId when mediaId is null`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = null,
+            url = "https://example.com/track.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        assertEquals("https://example.com/track.mp3", mediaItem.mediaId)
+    }
+
+    @Test
+    fun `asMediaItem stores duration and isLive in extras`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            duration = 240.0,
+            isLive = true,
+        )
+
+        val mediaItem = item.asMediaItem()
+        val extras = mediaItem.mediaMetadata.extras
+
+        assertNotNull(extras)
+        assertEquals(240.0, extras!!.getDouble("duration"), 0.001)
+        assertTrue(extras.getBoolean("isLive"))
+        assertNotNull(mediaItem.liveConfiguration)
+    }
+
+    @Test
+    fun `asMediaItem with headers stores headers in request extras`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            headers = mapOf("Authorization" to "Bearer xyz", "Accept" to "audio/*"),
+        )
+
+        val mediaItem = item.asMediaItem()
+        val requestExtras = mediaItem.requestMetadata.extras
+        assertNotNull(requestExtras)
+        val headerBundle = requestExtras!!.getBundle("headers")
+        assertNotNull(headerBundle)
+        assertEquals("Bearer xyz", headerBundle!!.getString("Authorization"))
+        assertEquals("audio/*", headerBundle.getString("Accept"))
+    }
+
+    @Test
+    fun `asMediaItem sets mediaUri in requestMetadata for http urls`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        // HTTP URIs should be set as mediaUri for Cast support
+        assertNotNull(mediaItem.requestMetadata.mediaUri)
+        assertEquals("https://example.com/track.mp3", mediaItem.requestMetadata.mediaUri.toString())
+    }
+
+    @Test
+    fun `asMediaItem does not set mediaUri for file urls`() {
+        val item = TrackPlayerMediaItem(
+            url = "file:///storage/music/local.mp3",
+        )
+
+        val mediaItem = item.asMediaItem()
+        // Local file URIs should not be set as mediaUri (inaccessible from Chromecast)
+        assertNull(mediaItem.requestMetadata.mediaUri)
+    }
+
+    @Test
+    fun `asMediaItem sets mimeType when provided`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+            mimeType = "audio/mpeg",
+        )
+
+        val mediaItem = item.asMediaItem()
+        assertEquals("audio/mpeg", mediaItem.localConfiguration?.mimeType)
+    }
+
+    // ---- toWritableMap ----
+
+    @Test
+    fun `toWritableMap includes all fields`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = "t1",
+            url = "https://example.com/track.mp3",
+            title = "Track",
+            artist = "Artist",
+            albumTitle = "Album",
+            artworkUrl = "https://example.com/art.jpg",
+            duration = 120.0,
+            isLive = false,
+        )
+
+        val map = item.toWritableMap()
+        // WritableMap from Arguments.createMap() — verify no exception thrown and key existence
+        // (JavaOnlyMap in Robolectric supports getString/getDouble/getBoolean)
+        assertEquals("t1", map.getString("mediaId"))
+        assertEquals("https://example.com/track.mp3", map.getString("url"))
+        assertEquals("Track", map.getString("title"))
+        assertEquals("Artist", map.getString("artist"))
+        assertEquals("Album", map.getString("albumTitle"))
+        assertEquals("https://example.com/art.jpg", map.getString("artworkUrl"))
+        assertEquals(120.0, map.getDouble("duration"), 0.001)
+        assertFalse(map.getBoolean("isLive"))
+    }
+
+    @Test
+    fun `toWritableMap uses url as mediaId when mediaId is null`() {
+        val item = TrackPlayerMediaItem(
+            mediaId = null,
+            url = "https://example.com/track.mp3",
+        )
+
+        val map = item.toWritableMap()
+        assertEquals("https://example.com/track.mp3", map.getString("mediaId"))
+    }
+
+    @Test
+    fun `toWritableMap omits null optional fields`() {
+        val item = TrackPlayerMediaItem(
+            url = "https://example.com/track.mp3",
+        )
+
+        val map = item.toWritableMap()
+        assertFalse(map.hasKey("title"))
+        assertFalse(map.hasKey("artist"))
+        assertFalse(map.hasKey("albumTitle"))
+        assertFalse(map.hasKey("artworkUrl"))
+        assertFalse(map.hasKey("duration"))
+        assertFalse(map.hasKey("isLive"))
+    }
+
+    // ---- fromMediaItem round-trip ----
+
+    @Test
+    fun `fromMediaItem round-trips correctly`() {
+        val original = TrackPlayerMediaItem(
+            mediaId = "round-trip-id",
+            url = "https://example.com/track.mp3",
+            title = "Round Trip",
+            artist = "Artist",
+            albumTitle = "Album",
+            artworkUrl = "https://example.com/art.jpg",
+            duration = 90.0,
+        )
+
+        val mediaItem = original.asMediaItem()
+        val restored = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals("round-trip-id", restored.mediaId)
+        assertEquals("https://example.com/track.mp3", restored.url)
+        assertEquals("Round Trip", restored.title)
+        assertEquals("Artist", restored.artist)
+        assertEquals("Album", restored.albumTitle)
+        assertEquals("https://example.com/art.jpg", restored.artworkUrl)
+        assertEquals(90.0, restored.duration!!, 0.001)
+        assertNull(restored.isLive) // not set so extras won't contain "isLive"
+    }
+
+    @Test
+    fun `fromMediaItem preserves isLive true`() {
+        val original = TrackPlayerMediaItem(
+            url = "https://example.com/live.mp3",
+            isLive = true,
+        )
+
+        val mediaItem = original.asMediaItem()
+        val restored = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals(true, restored.isLive)
+    }
+
+    @Test
+    fun `fromMediaItem with no localConfiguration falls back to mediaId as url`() {
+        // Build a Media3 MediaItem without a URI (e.g., cast-only item)
+        val mediaItem = MediaItem.Builder()
+            .setMediaId("cast-item-id")
+            .setMediaMetadata(MediaMetadata.Builder().setTitle("Cast Track").build())
+            .build()
+
+        val item = TrackPlayerMediaItem.fromMediaItem(mediaItem)
+
+        assertEquals("cast-item-id", item.mediaId)
+        // Falls back to mediaId when no localConfiguration
+        assertEquals("cast-item-id", item.url)
+        assertEquals("Cast Track", item.title)
+    }
+}

package/android/src/test/resources/robolectric.properties

@@ -0,0 +1 @@
+sdk=33

package/ios/TrackPlayer.swift

@@ -22,13 +22,7 @@ class TrackPlayer: RCTEventEmitter {
   private var progressSyncHttpUrl: String?
   private var progressSyncHttpHeaders: [String: String]?
 
-  private var sleepTimerType: String? // "time" or "mediaItem"
-  private var sleepTimerRemainingSeconds: Double = 0
-  private var sleepTimerFadeOutSeconds: Double = 0
-  private var sleepTimerTargetIndex: Int?
-  private var sleepTimer: Timer?
-  private var sleepTimerPreFadeVolume: Float?
-  private var sleepTimerPreviousIndex: Int?
+  private var sleepTimerController: SleepTimerController?
 
   // MARK: - Initializers
 
@@ -71,19 +65,29 @@ class TrackPlayer: RCTEventEmitter {
     try? AVAudioSession.sharedInstance().setCategory(.playback, mode: mode)
 
     var cache: AudioCache? = nil
+    var preloadWindow = 0
     if let cacheConfig = config["cache"] as? [String: Any] {
-      let maxSize = (cacheConfig["maxSizeBytes"] as? NSNumber)?.int64Value ?? (100 * 1024 * 1024)
+      let maxSize = (cacheConfig["maxSizeBytes"] as? NSNumber)?.int64Value ?? (500 * 1024 * 1024)
       cache = AudioCache(maxSizeBytes: maxSize)
+      if let preloadConfig = cacheConfig["preloading"] as? [String: Any] {
+        preloadWindow = (preloadConfig["window"] as? NSNumber)?.intValue ?? 0
+      }
     }
     audioCache = cache
 
     let handleNoisy = config["handleAudioBecomingNoisy"] as? Bool ?? true
     player = AudioPlayer(handleAudioBecomingNoisy: handleNoisy, cache: cache)
+    player.preloadWindow = preloadWindow
     bindPlayerCallbacks()
     BrowseTreeStore.shared.player = player
     lastEmittedStateString = nil
     lastIsPlaying = false
 
+    sleepTimerController = SleepTimerController(player: player)
+    sleepTimerController?.onTriggered = { [weak self] type in
+      self?.emitEvent(event: SleepTimerTriggeredEvent(sleepType: type))
+    }
+
     if let progressSync = config["progressSync"] as? [String: Any] {
       progressSyncIntervalSeconds = progressSync["intervalSeconds"] as? Double ?? 0
       if let http = progressSync["http"] as? [String: Any] {
@@ -149,9 +153,32 @@ class TrackPlayer: RCTEventEmitter {
 
   @objc(clearCache)
   func clearCache() {
+    player.cancelAllDownloads()
     audioCache?.removeAll()
   }
 
+  @objc(preload:duration:)
+  func preload(item: [String: Any], duration: Double) {
+    guard let urlString = extractUrl(from: item),
+          let url = URL(string: urlString) else { return }
+
+    let headers = item["headers"] as? [String: String]
+    player.preloader?.preload(url: url, headers: headers)
+  }
+
+  @objc(cancelPreload:)
+  func cancelPreload(item: [String: Any]) {
+    guard let urlString = extractUrl(from: item),
+          let url = URL(string: urlString) else { return }
+    player.preloader?.cancel(url: url)
+  }
+
+  private func extractUrl(from item: [String: Any]) -> String? {
+    if let url = item["url"] as? String { return url }
+    if let urlObj = item["url"] as? [String: Any], let uri = urlObj["uri"] as? String { return uri }
+    return nil
+  }
+
   @objc(setPlaybackSpeed:)
   func setPlaybackSpeed(speed: Double) {
     player.rate = Float(speed)
@@ -233,8 +260,8 @@ class TrackPlayer: RCTEventEmitter {
   @objc(clear)
   func clear() {
     player.clear()
-    if sleepTimerType == "mediaItem" {
-      cancelSleepTimerInternal(restoreVolume: false)
+    if sleepTimerController?.sleepTimerType == "mediaItem" {
+      sleepTimerController?.cancelInternal(restoreVolume: false)
     }
     emitEvent(event: QueueChangedEvent())
   }
@@ -413,101 +440,24 @@ class TrackPlayer: RCTEventEmitter {
 
   // MARK: - Sleep Timer
 
-  private func cancelSleepTimerInternal(restoreVolume: Bool) {
-    sleepTimer?.invalidate()
-    sleepTimer = nil
-    if restoreVolume, let preFadeVolume = sleepTimerPreFadeVolume {
-      player.volume = preFadeVolume
-    }
-    sleepTimerPreFadeVolume = nil
-    sleepTimerType = nil
-    sleepTimerRemainingSeconds = 0
-    sleepTimerFadeOutSeconds = 0
-    sleepTimerTargetIndex = nil
-    sleepTimerPreviousIndex = nil
-  }
-
-  private func onSleepTimerTick() {
-    sleepTimerRemainingSeconds -= 1
-
-    // Handle fade-out (before zero-check so final tick sets volume to 0)
-    if sleepTimerFadeOutSeconds > 0 && sleepTimerRemainingSeconds < sleepTimerFadeOutSeconds {
-      if sleepTimerPreFadeVolume == nil {
-        sleepTimerPreFadeVolume = player.volume
-      }
-      let progress = max(0, sleepTimerRemainingSeconds) / sleepTimerFadeOutSeconds
-      player.volume = (sleepTimerPreFadeVolume ?? 1.0) * Float(progress)
-    }
-
-    if sleepTimerRemainingSeconds <= 0 {
-      sleepTimerRemainingSeconds = 0
-      player.pause()
-      emitEvent(event: SleepTimerTriggeredEvent(sleepType: "time"))
-      // Restore volume after pausing so next playback isn't muted
-      cancelSleepTimerInternal(restoreVolume: true)
-      return
-    }
-  }
-
-  private func startSleepCountdownTimer() {
-    sleepTimer?.invalidate()
-    let timer = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
-      self?.onSleepTimerTick()
-    }
-    RunLoop.main.add(timer, forMode: .common)
-    sleepTimer = timer
-  }
-
-  private func pauseSleepCountdownTimer() {
-    sleepTimer?.invalidate()
-    sleepTimer = nil
-  }
-
   @objc(sleepAfterTime:fadeOutSeconds:)
   func sleepAfterTime(seconds: Double, fadeOutSeconds: Double) {
-    cancelSleepTimerInternal(restoreVolume: true)
-    sleepTimerType = "time"
-    sleepTimerRemainingSeconds = seconds
-    sleepTimerFadeOutSeconds = min(fadeOutSeconds, seconds)
-
-    if seconds <= 0 {
-      player.pause()
-      emitEvent(event: SleepTimerTriggeredEvent(sleepType: "time"))
-      cancelSleepTimerInternal(restoreVolume: true)
-      return
-    }
-
-    startSleepCountdownTimer()
+    sleepTimerController?.sleepAfterTime(seconds: seconds, fadeOutSeconds: fadeOutSeconds)
   }
 
   @objc(sleepAfterMediaItemAtIndex:)
   func sleepAfterMediaItemAtIndex(index: Double) {
-    cancelSleepTimerInternal(restoreVolume: true)
-    sleepTimerType = "mediaItem"
-    sleepTimerTargetIndex = Int(index)
-    sleepTimerPreviousIndex = player.currentIndex
+    sleepTimerController?.sleepAfterMediaItemAtIndex(index: Int(index))
   }
 
   @objc(getSleepTimer)
   func getSleepTimer() -> [String: Any]? {
-    guard let type = sleepTimerType else { return nil }
-    if type == "time" {
-      return [
-        "type": "time",
-        "remainingSeconds": sleepTimerRemainingSeconds,
-        "fadeOutSeconds": sleepTimerFadeOutSeconds
-      ]
-    } else {
-      return [
-        "type": "mediaItem",
-        "index": sleepTimerTargetIndex ?? 0
-      ]
-    }
+    return sleepTimerController?.getState()
   }
 
   @objc(cancelSleepTimer)
   func cancelSleepTimer() {
-    cancelSleepTimerInternal(restoreVolume: true)
+    sleepTimerController?.cancel()
   }
 
   // MARK: - Browse Tree
@@ -522,7 +472,8 @@ class TrackPlayer: RCTEventEmitter {
   @objc(destroy)
   func destroy() {
     BrowseTreeStore.shared.clear()
-    cancelSleepTimerInternal(restoreVolume: false)
+    sleepTimerController?.cancel()
+    sleepTimerController = nil
     stopProgressSyncTimer(fireFinalTick: false)
     let commandCenter = MPRemoteCommandCenter.shared()
     commandCenter.togglePlayPauseCommand.removeTarget(nil)
@@ -580,17 +531,12 @@ class TrackPlayer: RCTEventEmitter {
 
   func handleCurrentItemChanged(item: AudioItem?, index: Int) {
     // Sleep timer: check if the target item just finished
-    if sleepTimerType == "mediaItem", let targetIndex = sleepTimerTargetIndex {
-      if sleepTimerPreviousIndex == targetIndex && index != targetIndex {
-        emitEvent(event: SleepTimerTriggeredEvent(sleepType: "mediaItem"))
-        cancelSleepTimerInternal(restoreVolume: false)
-        // Defer pause to next run loop — calling during transition gets overridden
-        DispatchQueue.main.async { [weak self] in
-          self?.player.pause()
-        }
+    if sleepTimerController?.handleItemTransition(to: index) == true {
+      // Defer pause to next run loop — calling during transition gets overridden
+      DispatchQueue.main.async { [weak self] in
+        self?.player.pause()
       }
     }
-    sleepTimerPreviousIndex = index
     let mediaItem = item as? MediaItem
     let dict = mediaItem?.toDictionary()
     BrowseTreeStore.shared.updateNowPlaying(mediaId: mediaItem?.mediaId)

package/ios/TrackPlayerBridge.mm

@@ -29,6 +29,8 @@ RCT_EXTERN_METHOD(skipToPrevious);
 RCT_EXTERN_METHOD(skipToIndex:(double)index);
 RCT_EXTERN_METHOD(retry);
 RCT_EXTERN_METHOD(clearCache);
+RCT_EXTERN_METHOD(preload:(NSDictionary *)item duration:(double)duration);
+RCT_EXTERN_METHOD(cancelPreload:(NSDictionary *)item);
 RCT_EXTERN_METHOD(setPlaybackSpeed:(double)speed);
 RCT_EXTERN_METHOD(setVolume:(double)volume);