@javascriptcommon/react-native-track-player 4.1.17 → 4.1.18

package/android/src/main/java/com/doublesymmetry/trackplayer/module/MusicModule.kt

@@ -242,6 +242,7 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
             this["CAPABILITY_LIKE"] = -1
             this["CAPABILITY_DISLIKE"] = -1
             this["CAPABILITY_BOOKMARK"] = -1
+            this["CAPABILITY_SHUFFLE"] = Capability.SHUFFLE.ordinal
 
         }
     }
@@ -420,6 +421,18 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
         val bundle = Arguments.toBundle(data)
         if (bundle is Bundle) {
             musicService.load(bundleToTrack(bundle))
+
+            // Update heart state based on rating (for notification icon)
+            try {
+                val rating = bundle.get("rating")
+                val heartState = when (rating) {
+                    is Number -> rating.toDouble() > 0
+                    is Boolean -> rating
+                    else -> false
+                }
+                musicService.setHeartState(heartState)
+            } catch (_: Exception) { }
+
             callback.resolve(null)
         } else {
             callback.reject("invalid_track_object", "Track was not a dictionary type")
@@ -474,12 +487,27 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
     override fun updateNowPlayingMetadata(map: ReadableMap?, callback: Promise) = launchInScope {
         if (verifyServiceBoundOrReject(callback)) return@launchInScope
 
-        if (musicService.tracks.isEmpty())
+        if (musicService.tracks.isEmpty()) {
             callback.reject("no_current_item", "There is no current item in the player")
+            return@launchInScope
+        }
 
         Arguments.toBundle(map)?.let {
             val track = bundleToTrack(it)
             musicService.updateNowPlayingMetadata(track)
+
+            // Update heart state based on rating (for notification icon)
+            try {
+                val rating = it.get("rating")
+                if (rating != null) {
+                    val heartState = when (rating) {
+                        is Number -> rating.toDouble() > 0
+                        is Boolean -> rating
+                        else -> false
+                    }
+                    musicService.setHeartState(heartState)
+                }
+            } catch (_: Exception) { }
         }
 
         callback.resolve(null)

package/android/src/main/java/com/doublesymmetry/trackplayer/service/MusicService.kt

@@ -135,6 +135,9 @@ class MusicService : HeadlessJsMediaService() {
     private var playerCommands: Player.Commands? = null
     private var customLayout: List<CommandButton> = listOf()
     private var lastWake: Long = 0
+    private var shuffleState: Boolean = false
+    private var heartState: Boolean = false
+    private var notificationCapabilities: List<Capability> = emptyList()
     var searchResults: List<MediaItem> = listOf()
     var searchBrowser: MediaSession.ControllerInfo? = null
     var searchQuery: String = ""
@@ -402,7 +405,14 @@ class MusicService : HeadlessJsMediaService() {
         }
 
         player.alwaysPauseOnInterruption = androidOptions?.getBoolean(PAUSE_ON_INTERRUPTION_KEY) ?: false
-        player.shuffleMode = androidOptions?.getBoolean(SHUFFLE_KEY) ?: false
+        val newShuffleState = androidOptions?.getBoolean(SHUFFLE_KEY) ?: false
+        player.shuffleMode = newShuffleState
+        shuffleState = newShuffleState
+
+        // Update heart state if provided
+        if (androidOptions?.containsKey("heartState") == true) {
+            heartState = androidOptions.getBoolean("heartState")
+        }
 
         // setup progress update events if configured
         progressUpdateJob?.cancel()
@@ -414,7 +424,7 @@ class MusicService : HeadlessJsMediaService() {
         }
 
         val capabilities = options.getIntegerArrayList("capabilities")?.map { Capability.entries[it] } ?: emptyList()
-        var notificationCapabilities = options.getIntegerArrayList("notificationCapabilities")?.map { Capability.entries[it] } ?: emptyList()
+        notificationCapabilities = options.getIntegerArrayList("notificationCapabilities")?.map { Capability.entries[it] } ?: emptyList()
         compactCapabilities = options.getIntegerArrayList("compactCapabilities")?.map { Capability.entries[it] } ?: emptyList()
         val customActions = options.getBundle(CUSTOM_ACTIONS_KEY)
         val customActionsList = customActions?.getStringArrayList(CUSTOM_ACTIONS_LIST_KEY)
@@ -464,7 +474,7 @@ class MusicService : HeadlessJsMediaService() {
                 else -> { }
             }
         }
-        customLayout = customActionsList?.map {
+        val customButtons = customActionsList?.map {
                 v -> CustomButton(
             displayName = v,
             sessionCommand = v,
@@ -475,7 +485,29 @@ class MusicService : HeadlessJsMediaService() {
                 TrackPlayerR.drawable.ifl_24px
             )
         ).commandButton
-        } ?: ImmutableList.of()
+        }?.toMutableList() ?: mutableListOf()
+
+        // Add heart button if SetRating capability is present
+        if (notificationCapabilities.contains(Capability.SET_RATING)) {
+            val heartIcon = if (heartState) TrackPlayerR.drawable.heart_24px else TrackPlayerR.drawable.hearte_24px
+            customButtons.add(0, CustomButton(
+                displayName = "Heart",
+                sessionCommand = "heart",
+                iconRes = heartIcon
+            ).commandButton)
+        }
+
+        // Add shuffle button if capability is present
+        if (notificationCapabilities.contains(Capability.SHUFFLE)) {
+            val shuffleIcon = if (shuffleState) TrackPlayerR.drawable.shuffle_on_24px else TrackPlayerR.drawable.shuffle_24px
+            customButtons.add(0, CustomButton(
+                displayName = "Shuffle",
+                sessionCommand = "shuffle",
+                iconRes = shuffleIcon
+            ).commandButton)
+        }
+
+        customLayout = customButtons
 
         val sessionCommandsBuilder = MediaSession.ConnectionResult.DEFAULT_SESSION_AND_LIBRARY_COMMANDS.buildUpon()
         customLayout.forEach {
@@ -486,17 +518,15 @@ class MusicService : HeadlessJsMediaService() {
         sessionCommands = sessionCommandsBuilder.build()
         playerCommands = playerCommandsBuilder.build()
 
-        if (mediaSession.mediaNotificationControllerInfo != null) {
+        // Use safe call to avoid race condition
+        mediaSession.mediaNotificationControllerInfo?.let { controllerInfo ->
             // https://github.com/androidx/media/blob/c35a9d62baec57118ea898e271ac66819399649b/demos/session_service/src/main/java/androidx/media3/demo/session/DemoMediaLibrarySessionCallback.kt#L107
-            mediaSession.setCustomLayout(
-                mediaSession.mediaNotificationControllerInfo!!,
-                customLayout
-            )
-            mediaSession.setAvailableCommands(
-                mediaSession.mediaNotificationControllerInfo!!,
-                sessionCommands!!,
-                playerCommands!!
-            )
+            mediaSession.setCustomLayout(controllerInfo, customLayout)
+            sessionCommands?.let { sc ->
+                playerCommands?.let { pc ->
+                    mediaSession.setAvailableCommands(controllerInfo, sc, pc)
+                }
+            }
         }
     }
 
@@ -648,6 +678,61 @@ class MusicService : HeadlessJsMediaService() {
         player.repeatMode = value
     }
 
+    @MainThread
+    fun setShuffleState(enabled: Boolean) {
+        if (shuffleState != enabled) {
+            shuffleState = enabled
+            updateCustomLayout()
+        }
+    }
+
+    @MainThread
+    fun setHeartState(saved: Boolean) {
+        if (heartState != saved) {
+            heartState = saved
+            updateCustomLayout()
+        }
+    }
+
+    @MainThread
+    private fun updateCustomLayout() {
+        // Check if mediaSession is initialized before accessing it
+        if (!::mediaSession.isInitialized) return
+
+        try {
+            val customButtons = mutableListOf<CommandButton>()
+
+            // Add heart button if SetRating capability is present
+            if (notificationCapabilities.contains(Capability.SET_RATING)) {
+                val heartIcon = if (heartState) TrackPlayerR.drawable.heart_24px else TrackPlayerR.drawable.hearte_24px
+                customButtons.add(CustomButton(
+                    displayName = "Heart",
+                    sessionCommand = "heart",
+                    iconRes = heartIcon
+                ).commandButton)
+            }
+
+            // Add shuffle button if capability is present
+            if (notificationCapabilities.contains(Capability.SHUFFLE)) {
+                val shuffleIcon = if (shuffleState) TrackPlayerR.drawable.shuffle_on_24px else TrackPlayerR.drawable.shuffle_24px
+                customButtons.add(0, CustomButton(
+                    displayName = "Shuffle",
+                    sessionCommand = "shuffle",
+                    iconRes = shuffleIcon
+                ).commandButton)
+            }
+
+            customLayout = customButtons
+
+            // Use safe call to avoid race condition where mediaNotificationControllerInfo becomes null
+            mediaSession.mediaNotificationControllerInfo?.let { controllerInfo ->
+                mediaSession.setCustomLayout(controllerInfo, customLayout)
+            }
+        } catch (e: Exception) {
+            // Ignore errors in custom layout update - notification is non-critical
+        }
+    }
+
     @MainThread
     fun getVolume(): Float = player.volume
 
@@ -869,9 +954,13 @@ class MusicService : HeadlessJsMediaService() {
                     }
 
                     is MediaSessionCallback.CUSTOMACTION -> {
-                        Bundle().apply {
-                            putString("customAction", it.customAction)
-                            emit(MusicEvents.BUTTON_CUSTOM_ACTION, this)
+                        when (it.customAction) {
+                            "shuffle" -> emit(MusicEvents.BUTTON_SHUFFLE)
+                            "heart" -> emit(MusicEvents.BUTTON_SET_RATING, Bundle())
+                            else -> Bundle().apply {
+                                putString("customAction", it.customAction)
+                                emit(MusicEvents.BUTTON_CUSTOM_ACTION, this)
+                            }
                         }
                     }
                 }
@@ -1224,7 +1313,11 @@ class MusicService : HeadlessJsMediaService() {
             customCommand: SessionCommand,
             args: Bundle
         ): ListenableFuture<SessionResult> {
-            emit(MusicEvents.BUTTON_CUSTOM_ACTION, Bundle().apply { putString("customAction", customCommand.customAction) })
+            when (customCommand.customAction) {
+                "shuffle" -> emit(MusicEvents.BUTTON_SHUFFLE)
+                "heart" -> emit(MusicEvents.BUTTON_SET_RATING, Bundle())
+                else -> emit(MusicEvents.BUTTON_CUSTOM_ACTION, Bundle().apply { putString("customAction", customCommand.customAction) })
+            }
             return super.onCustomCommand(session, controller, customCommand, args)
         }
 

package/lib/specs/NativeTrackPlayer.d.ts

@@ -74,6 +74,7 @@ export interface Spec extends TurboModule {
         CAPABILITY_LIKE: number;
         CAPABILITY_DISLIKE: number;
         CAPABILITY_BOOKMARK: number;
+        CAPABILITY_SHUFFLE: number;
         STATE_NONE: string;
         STATE_READY: string;
         STATE_PLAYING: string;
@@ -121,6 +122,7 @@ export declare const Constants: {
     CAPABILITY_LIKE: number;
     CAPABILITY_DISLIKE: number;
     CAPABILITY_BOOKMARK: number;
+    CAPABILITY_SHUFFLE: number;
     STATE_NONE: string;
     STATE_READY: string;
     STATE_PLAYING: string;

package/lib/src/constants/Capability.d.ts

@@ -13,5 +13,6 @@ export declare enum Capability {
     SetRating,
     Like,
     Dislike,
-    Bookmark
+    Bookmark,
+    Shuffle
 }

package/lib/src/constants/Capability.js

@@ -16,4 +16,5 @@ export var Capability;
     Capability[Capability["Like"] = TrackPlayer.CAPABILITY_LIKE] = "Like";
     Capability[Capability["Dislike"] = TrackPlayer.CAPABILITY_DISLIKE] = "Dislike";
     Capability[Capability["Bookmark"] = TrackPlayer.CAPABILITY_BOOKMARK] = "Bookmark";
+    Capability[Capability["Shuffle"] = TrackPlayer.CAPABILITY_SHUFFLE] = "Shuffle";
 })(Capability || (Capability = {}));

package/lib/src/constants/Event.d.ts

@@ -141,6 +141,10 @@ export declare enum Event {
      * See https://rntp.dev/docs/api/events#remoteCustomAction
      **/
     RemoteCustomAction = "remote-custom-action",
+    /**
+     * (Android only) Fired when the user presses the shuffle button.
+     **/
+    RemoteShuffle = "remote-shuffle",
     /** (iOS only) Fired when chapter metadata is received.
      * See https://rntp.dev/docs/api/events#chaptermetadatareceived
      **/

package/lib/src/constants/Event.js

@@ -142,6 +142,10 @@ export var Event;
      * See https://rntp.dev/docs/api/events#remoteCustomAction
      **/
     Event["RemoteCustomAction"] = "remote-custom-action";
+    /**
+     * (Android only) Fired when the user presses the shuffle button.
+     **/
+    Event["RemoteShuffle"] = "remote-shuffle";
     /** (iOS only) Fired when chapter metadata is received.
      * See https://rntp.dev/docs/api/events#chaptermetadatareceived
      **/

package/lib/src/interfaces/events/EventPayloadByEvent.d.ts

@@ -57,6 +57,7 @@ export type EventPayloadByEvent = {
     [Event.RemoteBrowse]: RemoteBrowseEvent;
     [Event.PlaybackResume]: PlaybackResumeEvent;
     [Event.RemoteCustomAction]: RemoteCustomActionEvent;
+    [Event.RemoteShuffle]: never;
     [Event.MetadataChapterReceived]: AudioMetadataReceivedEvent;
     [Event.MetadataTimedReceived]: AudioMetadataReceivedEvent;
     [Event.MetadataCommonReceived]: AudioCommonMetadataReceivedEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.17",
+  "version": "4.1.18",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

package/specs/NativeTrackPlayer.ts

@@ -101,6 +101,7 @@ export interface Spec extends TurboModule {
     CAPABILITY_LIKE: number;
     CAPABILITY_DISLIKE: number;
     CAPABILITY_BOOKMARK: number;
+    CAPABILITY_SHUFFLE: number;
 
     // States
     STATE_NONE: string;

package/src/constants/Capability.ts

@@ -16,4 +16,5 @@ export enum Capability {
   Like = TrackPlayer.CAPABILITY_LIKE,
   Dislike = TrackPlayer.CAPABILITY_DISLIKE,
   Bookmark = TrackPlayer.CAPABILITY_BOOKMARK,
+  Shuffle = TrackPlayer.CAPABILITY_SHUFFLE,
 }

package/src/constants/Event.ts

@@ -142,6 +142,10 @@ export enum Event {
    * See https://rntp.dev/docs/api/events#remoteCustomAction
    **/
   RemoteCustomAction = 'remote-custom-action',
+  /**
+   * (Android only) Fired when the user presses the shuffle button.
+   **/
+  RemoteShuffle = 'remote-shuffle',
   /** (iOS only) Fired when chapter metadata is received.
    * See https://rntp.dev/docs/api/events#chaptermetadatareceived
    **/

package/src/interfaces/events/EventPayloadByEvent.ts

@@ -62,6 +62,7 @@ export type EventPayloadByEvent = {
   [Event.RemoteBrowse]: RemoteBrowseEvent;
   [Event.PlaybackResume]: PlaybackResumeEvent;
   [Event.RemoteCustomAction]: RemoteCustomActionEvent;
+  [Event.RemoteShuffle]: never;
   [Event.MetadataChapterReceived]: AudioMetadataReceivedEvent;
   [Event.MetadataTimedReceived]: AudioMetadataReceivedEvent;
   [Event.MetadataCommonReceived]: AudioCommonMetadataReceivedEvent;