react-native-nitro-player 1.7.0-alpha.2 → 1.7.0-alpha.4

package/ios/playlist/PlaylistManager.swift

@@ -14,6 +14,7 @@ class PlaylistManager {
   private var listeners: [(String, ([PlaylistModel], QueueOperation?) -> Void)] = []
   private var playlistListeners: [String: [(String, (PlaylistModel, QueueOperation?) -> Void)]] =
     [:]
+  private var anyPlaylistListeners: [(String, (PlaylistModel, QueueOperation?) -> Void)] = []
   // Backing store must only be touched inside `queue`; every current use of the
   // computed property is outside a queue.sync block, so the accessors can sync.
   private var _currentPlaylistId: String?
@@ -257,6 +258,48 @@ class PlaylistManager {
     return true
   }
 
+  /// Removed count; nil when the playlist does not exist. Unknown ids are ignored.
+  func removeTracksFromPlaylist(playlistId: String, trackIds: [String]) -> Int? {
+    let ids = Set(trackIds)
+    let removed: Int? = queue.sync {
+      guard let playlist = playlists[playlistId] else { return nil }
+      let tracks = playlist.tracks.filter { !ids.contains($0.id) }
+      let count = playlist.tracks.count - tracks.count
+      if count > 0 {
+        playlists[playlistId] = PlaylistModel(
+          id: playlist.id, name: playlist.name, description: playlist.description,
+          artwork: playlist.artwork, tracks: tracks)
+      }
+      return count
+    }
+    if let removed, removed > 0 {
+      scheduleSave()
+      notifyPlaylistChanged(playlistId, .remove)
+    }
+    return removed
+  }
+
+  /// Fisher-Yates; `firstTrackId` is pinned at index 0. Nil when the playlist does not exist.
+  func shufflePlaylist(playlistId: String, firstTrackId: String?) -> Bool? {
+    let changed: Bool? = queue.sync {
+      guard let playlist = playlists[playlistId] else { return nil }
+      var tracks = playlist.tracks
+      let pinned = tracks.firstIndex { $0.id == firstTrackId }.map { tracks.remove(at: $0) }
+      tracks.shuffle()
+      if let pinned { tracks.insert(pinned, at: 0) }
+      guard tracks.map(\.id) != playlist.tracks.map(\.id) else { return false }
+      playlists[playlistId] = PlaylistModel(
+        id: playlist.id, name: playlist.name, description: playlist.description,
+        artwork: playlist.artwork, tracks: tracks)
+      return true
+    }
+    if changed == true {
+      scheduleSave()
+      notifyPlaylistChanged(playlistId, .update)
+    }
+    return changed
+  }
+
   /**
    * Load a playlist for playback (sets it as current)
    */
@@ -343,6 +386,11 @@ class PlaylistManager {
     return trackIds.compactMap { foundTracks[$0] }
   }
 
+  /// Mirrors the core's current playlist; playSong bypasses loadPlaylist.
+  func setCurrentPlaylistId(_ playlistId: String?) {
+    currentPlaylistId = playlistId
+  }
+
   /**
    * Get the current playlist ID
    */
@@ -403,11 +451,22 @@ class PlaylistManager {
     currentListeners.forEach { $0.1(allPlaylists, operation) }
   }
 
+  /// Fires for ANY playlist, including ones created after registration.
+  func addAnyPlaylistChangeListener(
+    listener: @escaping (PlaylistModel, QueueOperation?) -> Void
+  ) -> () -> Void {
+    let listenerId = UUID().uuidString
+    queue.sync { anyPlaylistListeners.append((listenerId, listener)) }
+    return {
+      self.queue.sync { self.anyPlaylistListeners.removeAll { $0.0 == listenerId } }
+    }
+  }
+
   private func notifyPlaylistChanged(_ playlistId: String, _ operation: QueueOperation?) {
     let result: (PlaylistModel, [(String, (PlaylistModel, QueueOperation?) -> Void)])? = queue.sync
     {
       guard let p = playlists[playlistId] else { return nil }
-      return (p, playlistListeners[playlistId] ?? [])
+      return (p, (playlistListeners[playlistId] ?? []) + anyPlaylistListeners)
     }
 
     guard let (playlist, currentListeners) = result else { return }

package/ios/queue/HybridPlayerQueue.swift

@@ -73,14 +73,9 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
     }
   }
 
+  /// Same semantics as the batch form: unknown ids are skipped, only a missing playlist rejects.
   func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void> {
-    Promise.async {
-      guard self.playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
-      else {
-        throw RuntimeError.error(withMessage: "Track \(trackId) not found in playlist \(playlistId)")
-      }
-      self.core.updatePlaylist(playlistId: playlistId)
-    }
+    try removeTracksFromPlaylist(playlistId: playlistId, trackIds: [trackId])
   }
 
   func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void> {
@@ -94,6 +89,40 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
     }
   }
 
+  /// On the player queue: the live queue must reflect the removal before the promise resolves.
+  func removeTracksFromPlaylist(playlistId: String, trackIds: [String]) throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    core.playerQueue.async {
+      guard let removed = self.playlistManager.removeTracksFromPlaylist(playlistId: playlistId, trackIds: trackIds) else {
+        promise.reject(withError: RuntimeError.error(withMessage: "Playlist not found: \(playlistId)"))
+        return
+      }
+      if removed > 0, self.core.currentPlaylistId == playlistId {
+        self.core.syncCurrentPlaylistOnQueue(playlistId: playlistId)
+      }
+      promise.resolve(withResult: ())
+    }
+    return promise
+  }
+
+  /// On the player queue: the anchor id is player-queue state.
+  func shufflePlaylist(playlistId: String, options: ShufflePlaylistOptions?) throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    core.playerQueue.async {
+      let isCurrent = self.core.currentPlaylistId == playlistId
+      let pin: String? =
+        (isCurrent && options?.keepCurrentTrackFirst != false)
+        ? self.core.currentTracks[safe: self.core.currentTrackIndex]?.id : nil
+      guard let changed = self.playlistManager.shufflePlaylist(playlistId: playlistId, firstTrackId: pin) else {
+        promise.reject(withError: RuntimeError.error(withMessage: "Playlist not found: \(playlistId)"))
+        return
+      }
+      if changed, isCurrent { self.core.syncCurrentPlaylistOnQueue(playlistId: playlistId) }
+      promise.resolve(withResult: ())
+    }
+    return promise
+  }
+
   // MARK: - Playback control
 
   /// Enqueued synchronously on the player queue so a `loadPlaylist()` followed by
@@ -130,13 +159,11 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
   }
 
   func onPlaylistChanged(callback: @escaping (_ playlistId: String, _ playlist: Playlist, _ operation: QueueOperation?) -> Void) throws {
-    let allPlaylists = playlistManager.getAllPlaylists()
-    for playlist in allPlaylists {
-      let remover = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) { updated, operation in
-        callback(updated.id, updated.toGeneratedPlaylist(), operation)
-      }
-      playlistChangeRemovers.append(remover)
+    // Manager-level listener: covers playlists created after registration.
+    let remover = playlistManager.addAnyPlaylistChangeListener { updated, operation in
+      callback(updated.id, updated.toGeneratedPlaylist(), operation)
     }
+    playlistChangeRemovers.append(remover)
   }
 
   // MARK: - Cleanup

package/lib/hooks/callbackManager.d.ts

@@ -21,6 +21,7 @@ declare class CallbackSubscriptionManager {
     private playlistsChangedSubscribers;
     private androidAutoConnectionSubscribers;
     private isPlaylistsChangedRegistered;
+    private playlistsChangedFanOutScheduled;
     private isAndroidAutoConnectionRegistered;
     private isPlaybackStateRegistered;
     private isTrackChangeRegistered;
@@ -61,6 +62,7 @@ declare class CallbackSubscriptionManager {
      * @returns Unsubscribe function
      */
     subscribeToPlaylistsChanged(callback: () => void): () => void;
+    private schedulePlaylistsChangedFanOut;
     private ensurePlaylistsChangedRegistered;
     private ensureTemporaryQueueRegistered;
     private ensureSeekRegistered;

package/lib/hooks/callbackManager.js

@@ -14,6 +14,7 @@ class CallbackSubscriptionManager {
     playlistsChangedSubscribers = new Set();
     androidAutoConnectionSubscribers = new Set();
     isPlaylistsChangedRegistered = false;
+    playlistsChangedFanOutScheduled = false;
     isAndroidAutoConnectionRegistered = false;
     isPlaybackStateRegistered = false;
     isTrackChangeRegistered = false;
@@ -147,19 +148,33 @@ class CallbackSubscriptionManager {
             this.playlistsChangedSubscribers.delete(callback);
         };
     }
+    // Task-level, not a microtask: native callbacks arrive as separate JS tasks.
+    schedulePlaylistsChangedFanOut() {
+        if (this.playlistsChangedFanOutScheduled)
+            return;
+        this.playlistsChangedFanOutScheduled = true;
+        setTimeout(() => {
+            this.playlistsChangedFanOutScheduled = false;
+            this.playlistsChangedSubscribers.forEach((subscriber) => {
+                try {
+                    subscriber();
+                }
+                catch (error) {
+                    console.error('[CallbackManager] Error in playlists changed subscriber:', error);
+                }
+            });
+        }, 0);
+    }
     ensurePlaylistsChangedRegistered() {
         if (this.isPlaylistsChangedRegistered)
             return;
         try {
             PlayerQueue.onPlaylistsChanged(() => {
-                this.playlistsChangedSubscribers.forEach((subscriber) => {
-                    try {
-                        subscriber();
-                    }
-                    catch (error) {
-                        console.error('[CallbackManager] Error in playlists changed subscriber:', error);
-                    }
-                });
+                this.schedulePlaylistsChangedFanOut();
+            });
+            // Track-level mutations only fire the per-playlist event.
+            PlayerQueue.onPlaylistChanged(() => {
+                this.schedulePlaylistsChangedFanOut();
             });
             this.isPlaylistsChangedRegistered = true;
         }

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -1,5 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules';
-import type { QueueOperation, Reason, TrackItem, TrackPlayerState, PlayerState, PlayerConfig, Playlist, TimedMetadata } from '../types/PlayerQueue';
+import type { QueueOperation, Reason, TrackItem, TrackPlayerState, PlayerState, PlayerConfig, Playlist, TimedMetadata, ShufflePlaylistOptions } from '../types/PlayerQueue';
 export interface PlayerQueue extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
@@ -13,6 +13,10 @@ export interface PlayerQueue extends HybridObject<{
     addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): Promise<void>;
     removeTrackFromPlaylist(playlistId: string, trackId: string): Promise<void>;
     reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): Promise<void>;
+    /** One native pass. Unknown ids are skipped; rejects only if the playlist does not exist. */
+    removeTracksFromPlaylist(playlistId: string, trackIds: string[]): Promise<void>;
+    /** Fisher-Yates shuffle of the stored playlist, persisted. Never interrupts the playing item. */
+    shufflePlaylist(playlistId: string, options?: ShufflePlaylistOptions): Promise<void>;
     loadPlaylist(playlistId: string, index?: number): Promise<void>;
     getCurrentPlaylistId(): string | null;
     onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;

package/lib/types/PlayerQueue.d.ts

@@ -18,6 +18,10 @@ export interface Playlist {
     tracks: TrackItem[];
 }
 export type QueueOperation = 'add' | 'remove' | 'clear' | 'update';
+export interface ShufflePlaylistOptions {
+    /** Move the playing track to index 0 and shuffle the rest behind it (default: true). */
+    keepCurrentTrackFirst?: boolean;
+}
 export type TrackPlayerState = 'playing' | 'paused' | 'stopped' | 'buffering';
 export type Reason = 'user_action' | 'skip' | 'end' | 'error' | 'repeat';
 export interface PlayerState {
@@ -44,6 +48,14 @@ export interface TimedMetadata {
     /** Artwork URL the stream tagged as artwork, when it sends one explicitly */
     artworkUrl?: string;
 }
+/**
+ * How Android reacts when another app takes audio focus.
+ * - 'pause': pause for any interruption and resume after it (default, today's behaviour)
+ * - 'duck': keep playing at a reduced volume through transient interruptions
+ * - 'ignore': never react to audio focus at all
+ * iOS ignores this option.
+ */
+export type AndroidAudioFocusMode = 'pause' | 'duck' | 'ignore';
 export interface PlayerConfig {
     androidAutoEnabled?: boolean;
     carPlayEnabled?: boolean;
@@ -62,4 +74,6 @@ export interface PlayerConfig {
      */
     lookaheadCount?: number;
     androidNotificationIcon?: string;
+    /** How Android reacts when another app takes audio focus (default: 'pause'). */
+    androidAudioFocus?: AndroidAudioFocusMode;
 }

package/nitrogen/generated/android/c++/JAndroidAudioFocusMode.hpp

@@ -0,0 +1,61 @@
+///
+/// JAndroidAudioFocusMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AndroidAudioFocusMode.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidAudioFocusMode" and the the Kotlin enum "AndroidAudioFocusMode".
+   */
+  struct JAndroidAudioFocusMode final: public jni::JavaClass<JAndroidAudioFocusMode> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/AndroidAudioFocusMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidAudioFocusMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidAudioFocusMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidAudioFocusMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidAudioFocusMode> fromCpp(AndroidAudioFocusMode value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidAudioFocusMode::PAUSE:
+          static const auto fieldPAUSE = clazz->getStaticField<JAndroidAudioFocusMode>("PAUSE");
+          return clazz->getStaticFieldValue(fieldPAUSE);
+        case AndroidAudioFocusMode::DUCK:
+          static const auto fieldDUCK = clazz->getStaticField<JAndroidAudioFocusMode>("DUCK");
+          return clazz->getStaticFieldValue(fieldDUCK);
+        case AndroidAudioFocusMode::IGNORE:
+          static const auto fieldIGNORE = clazz->getStaticField<JAndroidAudioFocusMode>("IGNORE");
+          return clazz->getStaticFieldValue(fieldIGNORE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/c++/JHybridPlayerQueueSpec.cpp

@@ -11,6 +11,8 @@
 namespace margelo::nitro::nitroplayer { struct Playlist; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `ShufflePlaylistOptions` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct ShufflePlaylistOptions; }
 // Forward declaration of `QueueOperation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 
@@ -31,6 +33,8 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include "JTrackItem.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/JAnyMap.hpp>
+#include "ShufflePlaylistOptions.hpp"
+#include "JShufflePlaylistOptions.hpp"
 #include "QueueOperation.hpp"
 #include <functional>
 #include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"
@@ -205,6 +209,45 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<void>> JHybridPlayerQueueSpec::removeTracksFromPlaylist(const std::string& playlistId, const std::vector<std::string>& trackIds) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JArrayClass<jni::JString>> /* trackIds */)>("removeTracksFromPlaylist");
+    auto __result = method(_javaPart, jni::make_jstring(playlistId), [&]() {
+      size_t __size = trackIds.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = trackIds[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridPlayerQueueSpec::shufflePlaylist(const std::string& playlistId, const std::optional<ShufflePlaylistOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<JShufflePlaylistOptions> /* options */)>("shufflePlaylist");
+    auto __result = method(_javaPart, jni::make_jstring(playlistId), options.has_value() ? JShufflePlaylistOptions::fromCpp(options.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   std::shared_ptr<Promise<void>> JHybridPlayerQueueSpec::loadPlaylist(const std::string& playlistId, std::optional<double> index) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JDouble> /* index */)>("loadPlaylist");
     auto __result = method(_javaPart, jni::make_jstring(playlistId), index.has_value() ? jni::JDouble::valueOf(index.value()) : nullptr);

package/nitrogen/generated/android/c++/JHybridPlayerQueueSpec.hpp

@@ -63,6 +63,8 @@ namespace margelo::nitro::nitroplayer {
     std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) override;
     std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) override;
     std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) override;
+    std::shared_ptr<Promise<void>> removeTracksFromPlaylist(const std::string& playlistId, const std::vector<std::string>& trackIds) override;
+    std::shared_ptr<Promise<void>> shufflePlaylist(const std::string& playlistId, const std::optional<ShufflePlaylistOptions>& options) override;
     std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) override;
     std::variant<nitro::NullType, std::string> getCurrentPlaylistId() override;
     void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) override;

package/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.cpp

@@ -19,6 +19,8 @@ namespace margelo::nitro::nitroplayer { enum class CurrentPlayingType; }
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
+// Forward declaration of `AndroidAudioFocusMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class AndroidAudioFocusMode; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `TimedMetadata` to properly resolve imports.
@@ -49,6 +51,8 @@ namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 #include "JRepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "JPlayerConfig.hpp"
+#include "AndroidAudioFocusMode.hpp"
+#include "JAndroidAudioFocusMode.hpp"
 #include "Reason.hpp"
 #include <functional>
 #include "JFunc_void_TrackItem_std__optional_Reason_.hpp"

package/nitrogen/generated/android/c++/JPlayerConfig.hpp

@@ -10,6 +10,8 @@
 #include <fbjni/fbjni.h>
 #include "PlayerConfig.hpp"
 
+#include "AndroidAudioFocusMode.hpp"
+#include "JAndroidAudioFocusMode.hpp"
 #include <optional>
 #include <string>
 
@@ -46,6 +48,8 @@ namespace margelo::nitro::nitroplayer {
       jni::local_ref<jni::JDouble> lookaheadCount = this->getFieldValue(fieldLookaheadCount);
       static const auto fieldAndroidNotificationIcon = clazz->getField<jni::JString>("androidNotificationIcon");
       jni::local_ref<jni::JString> androidNotificationIcon = this->getFieldValue(fieldAndroidNotificationIcon);
+      static const auto fieldAndroidAudioFocus = clazz->getField<JAndroidAudioFocusMode>("androidAudioFocus");
+      jni::local_ref<JAndroidAudioFocusMode> androidAudioFocus = this->getFieldValue(fieldAndroidAudioFocus);
       return PlayerConfig(
         androidAutoEnabled != nullptr ? std::make_optional(static_cast<bool>(androidAutoEnabled->value())) : std::nullopt,
         carPlayEnabled != nullptr ? std::make_optional(static_cast<bool>(carPlayEnabled->value())) : std::nullopt,
@@ -53,7 +57,8 @@ namespace margelo::nitro::nitroplayer {
         remoteSkipForwardInterval != nullptr ? std::make_optional(remoteSkipForwardInterval->value()) : std::nullopt,
         remoteSkipBackwardInterval != nullptr ? std::make_optional(remoteSkipBackwardInterval->value()) : std::nullopt,
         lookaheadCount != nullptr ? std::make_optional(lookaheadCount->value()) : std::nullopt,
-        androidNotificationIcon != nullptr ? std::make_optional(androidNotificationIcon->toStdString()) : std::nullopt
+        androidNotificationIcon != nullptr ? std::make_optional(androidNotificationIcon->toStdString()) : std::nullopt,
+        androidAudioFocus != nullptr ? std::make_optional(androidAudioFocus->toCpp()) : std::nullopt
       );
     }
 
@@ -63,7 +68,7 @@ namespace margelo::nitro::nitroplayer {
      */
     [[maybe_unused]]
     static jni::local_ref<JPlayerConfig::javaobject> fromCpp(const PlayerConfig& value) {
-      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>);
+      using JSignature = JPlayerConfig(jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>, jni::alias_ref<JAndroidAudioFocusMode>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -74,7 +79,8 @@ namespace margelo::nitro::nitroplayer {
         value.remoteSkipForwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipForwardInterval.value()) : nullptr,
         value.remoteSkipBackwardInterval.has_value() ? jni::JDouble::valueOf(value.remoteSkipBackwardInterval.value()) : nullptr,
         value.lookaheadCount.has_value() ? jni::JDouble::valueOf(value.lookaheadCount.value()) : nullptr,
-        value.androidNotificationIcon.has_value() ? jni::make_jstring(value.androidNotificationIcon.value()) : nullptr
+        value.androidNotificationIcon.has_value() ? jni::make_jstring(value.androidNotificationIcon.value()) : nullptr,
+        value.androidAudioFocus.has_value() ? JAndroidAudioFocusMode::fromCpp(value.androidAudioFocus.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/c++/JShufflePlaylistOptions.hpp

@@ -0,0 +1,57 @@
+///
+/// JShufflePlaylistOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ShufflePlaylistOptions.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ShufflePlaylistOptions" and the the Kotlin data class "ShufflePlaylistOptions".
+   */
+  struct JShufflePlaylistOptions final: public jni::JavaClass<JShufflePlaylistOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/ShufflePlaylistOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ShufflePlaylistOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ShufflePlaylistOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldKeepCurrentTrackFirst = clazz->getField<jni::JBoolean>("keepCurrentTrackFirst");
+      jni::local_ref<jni::JBoolean> keepCurrentTrackFirst = this->getFieldValue(fieldKeepCurrentTrackFirst);
+      return ShufflePlaylistOptions(
+        keepCurrentTrackFirst != nullptr ? std::make_optional(static_cast<bool>(keepCurrentTrackFirst->value())) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JShufflePlaylistOptions::javaobject> fromCpp(const ShufflePlaylistOptions& value) {
+      using JSignature = JShufflePlaylistOptions(jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.keepCurrentTrackFirst.has_value() ? jni::JBoolean::valueOf(value.keepCurrentTrackFirst.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/AndroidAudioFocusMode.kt

@@ -0,0 +1,24 @@
+///
+/// AndroidAudioFocusMode.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AndroidAudioFocusMode".
+ */
+@DoNotStrip
+@Keep
+enum class AndroidAudioFocusMode(@DoNotStrip @Keep val value: Int) {
+  PAUSE(0),
+  DUCK(1),
+  IGNORE(2);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridPlayerQueueSpec.kt

@@ -66,6 +66,14 @@ abstract class HybridPlayerQueueSpec: HybridObject() {
   @Keep
   abstract fun reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double): Promise<Unit>
   
+  @DoNotStrip
+  @Keep
+  abstract fun removeTracksFromPlaylist(playlistId: String, trackIds: Array<String>): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun shufflePlaylist(playlistId: String, options: ShufflePlaylistOptions?): Promise<Unit>
+  
   @DoNotStrip
   @Keep
   abstract fun loadPlaylist(playlistId: String, index: Double?): Promise<Unit>

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/PlayerConfig.kt

@@ -37,7 +37,10 @@ data class PlayerConfig(
   val lookaheadCount: Double?,
   @DoNotStrip
   @Keep
-  val androidNotificationIcon: String?
+  val androidNotificationIcon: String?,
+  @DoNotStrip
+  @Keep
+  val androidAudioFocus: AndroidAudioFocusMode?
 ) {
   /* primary constructor */
 
@@ -49,8 +52,8 @@ data class PlayerConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?): PlayerConfig {
-      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, remoteSkipForwardInterval, remoteSkipBackwardInterval, lookaheadCount, androidNotificationIcon)
+    private fun fromCpp(androidAutoEnabled: Boolean?, carPlayEnabled: Boolean?, showInNotification: Boolean?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?, androidAudioFocus: AndroidAudioFocusMode?): PlayerConfig {
+      return PlayerConfig(androidAutoEnabled, carPlayEnabled, showInNotification, remoteSkipForwardInterval, remoteSkipBackwardInterval, lookaheadCount, androidNotificationIcon, androidAudioFocus)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/ShufflePlaylistOptions.kt

@@ -0,0 +1,38 @@
+///
+/// ShufflePlaylistOptions.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "ShufflePlaylistOptions".
+ */
+@DoNotStrip
+@Keep
+data class ShufflePlaylistOptions(
+  @DoNotStrip
+  @Keep
+  val keepCurrentTrackFirst: Boolean?
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(keepCurrentTrackFirst: Boolean?): ShufflePlaylistOptions {
+      return ShufflePlaylistOptions(keepCurrentTrackFirst)
+    }
+  }
+}