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

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidAudioFocusMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class AndroidAudioFocusMode; }
 // Forward declaration of `CastState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class CastState; }
 // Forward declaration of `CurrentPlayingType` to properly resolve imports.
@@ -66,6 +68,8 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `RepeatMode` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
+// Forward declaration of `ShufflePlaylistOptions` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct ShufflePlaylistOptions; }
 // Forward declaration of `StorageLocation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
 // Forward declaration of `TimedMetadata` to properly resolve imports.
@@ -90,6 +94,7 @@ namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
 namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 
 // Include C++ defined types
+#include "AndroidAudioFocusMode.hpp"
 #include "CastState.hpp"
 #include "CurrentPlayingType.hpp"
 #include "DownloadConfig.hpp"
@@ -119,6 +124,7 @@ namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
 #include "RepeatMode.hpp"
+#include "ShufflePlaylistOptions.hpp"
 #include "StorageLocation.hpp"
 #include "TimedMetadata.hpp"
 #include "TrackItem.hpp"
@@ -1426,6 +1432,21 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return vector;
   }
   
+  // pragma MARK: std::optional<ShufflePlaylistOptions>
+  /**
+   * Specialized version of `std::optional<ShufflePlaylistOptions>`.
+   */
+  using std__optional_ShufflePlaylistOptions_ = std::optional<ShufflePlaylistOptions>;
+  inline std::optional<ShufflePlaylistOptions> create_std__optional_ShufflePlaylistOptions_(const ShufflePlaylistOptions& value) noexcept {
+    return std::optional<ShufflePlaylistOptions>(value);
+  }
+  inline bool has_value_std__optional_ShufflePlaylistOptions_(const std::optional<ShufflePlaylistOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ShufflePlaylistOptions get_std__optional_ShufflePlaylistOptions_(const std::optional<ShufflePlaylistOptions>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<QueueOperation>
   /**
    * Specialized version of `std::optional<QueueOperation>`.
@@ -1627,6 +1648,21 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_PlayerState_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<AndroidAudioFocusMode>
+  /**
+   * Specialized version of `std::optional<AndroidAudioFocusMode>`.
+   */
+  using std__optional_AndroidAudioFocusMode_ = std::optional<AndroidAudioFocusMode>;
+  inline std::optional<AndroidAudioFocusMode> create_std__optional_AndroidAudioFocusMode_(const AndroidAudioFocusMode& value) noexcept {
+    return std::optional<AndroidAudioFocusMode>(value);
+  }
+  inline bool has_value_std__optional_AndroidAudioFocusMode_(const std::optional<AndroidAudioFocusMode>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidAudioFocusMode get_std__optional_AndroidAudioFocusMode_(const std::optional<AndroidAudioFocusMode>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<Reason>
   /**
    * Specialized version of `std::optional<Reason>`.

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Umbrella.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidAudioFocusMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class AndroidAudioFocusMode; }
 // Forward declaration of `CastState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class CastState; }
 // Forward declaration of `CurrentPlayingType` to properly resolve imports.
@@ -68,6 +70,8 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `RepeatMode` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
+// Forward declaration of `ShufflePlaylistOptions` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct ShufflePlaylistOptions; }
 // Forward declaration of `StorageLocation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
 // Forward declaration of `TimedMetadata` to properly resolve imports.
@@ -78,6 +82,7 @@ namespace margelo::nitro::nitroplayer { struct TrackItem; }
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 
 // Include C++ defined types
+#include "AndroidAudioFocusMode.hpp"
 #include "CastState.hpp"
 #include "CurrentPlayingType.hpp"
 #include "DownloadConfig.hpp"
@@ -108,6 +113,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
 #include "RepeatMode.hpp"
+#include "ShufflePlaylistOptions.hpp"
 #include "StorageLocation.hpp"
 #include "TimedMetadata.hpp"
 #include "TrackItem.hpp"

package/nitrogen/generated/ios/c++/HybridPlayerQueueSpecSwift.hpp

@@ -16,6 +16,8 @@ namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
 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; }
 
@@ -28,6 +30,7 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include "TrackItem.hpp"
 #include <vector>
 #include <NitroModules/AnyMap.hpp>
+#include "ShufflePlaylistOptions.hpp"
 #include "QueueOperation.hpp"
 #include <functional>
 
@@ -153,6 +156,22 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> removeTracksFromPlaylist(const std::string& playlistId, const std::vector<std::string>& trackIds) override {
+      auto __result = _swiftPart.removeTracksFromPlaylist(playlistId, trackIds);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> shufflePlaylist(const std::string& playlistId, const std::optional<ShufflePlaylistOptions>& options) override {
+      auto __result = _swiftPart.shufflePlaylist(playlistId, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) override {
       auto __result = _swiftPart.loadPlaylist(playlistId, index);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -24,6 +24,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.
@@ -42,6 +44,7 @@ namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 #include "CurrentPlayingType.hpp"
 #include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
+#include "AndroidAudioFocusMode.hpp"
 #include "Reason.hpp"
 #include <functional>
 #include "TimedMetadata.hpp"

package/nitrogen/generated/ios/swift/AndroidAudioFocusMode.swift

@@ -0,0 +1,44 @@
+///
+/// AndroidAudioFocusMode.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AndroidAudioFocusMode`, backed by a C++ enum.
+ */
+public typealias AndroidAudioFocusMode = margelo.nitro.nitroplayer.AndroidAudioFocusMode
+
+public extension AndroidAudioFocusMode {
+  /**
+   * Get a AndroidAudioFocusMode for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "pause":
+        self = .pause
+      case "duck":
+        self = .duck
+      case "ignore":
+        self = .ignore
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidAudioFocusMode represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .pause:
+        return "pause"
+      case .duck:
+        return "duck"
+      case .ignore:
+        return "ignore"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec.swift

@@ -22,6 +22,8 @@ public protocol HybridPlayerQueueSpec_protocol: HybridObject {
   func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Promise<Void>
   func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void>
   func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void>
+  func removeTracksFromPlaylist(playlistId: String, trackIds: [String]) throws -> Promise<Void>
+  func shufflePlaylist(playlistId: String, options: ShufflePlaylistOptions?) throws -> Promise<Void>
   func loadPlaylist(playlistId: String, index: Double?) throws -> Promise<Void>
   func getCurrentPlaylistId() throws -> Variant_NullType_String
   func onPlaylistsChanged(callback: @escaping (_ playlists: [Playlist], _ operation: QueueOperation?) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec_cxx.swift

@@ -343,6 +343,44 @@ open class HybridPlayerQueueSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func removeTracksFromPlaylist(playlistId: std.string, trackIds: bridge.std__vector_std__string_) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.removeTracksFromPlaylist(playlistId: String(playlistId), trackIds: trackIds.map({ __item in String(__item) }))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func shufflePlaylist(playlistId: std.string, options: bridge.std__optional_ShufflePlaylistOptions_) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.shufflePlaylist(playlistId: String(playlistId), options: options.value)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func loadPlaylist(playlistId: std.string, index: bridge.std__optional_double_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {

package/nitrogen/generated/ios/swift/PlayerConfig.swift

@@ -18,7 +18,7 @@ public extension PlayerConfig {
   /**
    * Create a new instance of `PlayerConfig`.
    */
-  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?) {
+  init(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, remoteSkipForwardInterval: Double?, remoteSkipBackwardInterval: Double?, lookaheadCount: Double?, androidNotificationIcon: String?, androidAudioFocus: AndroidAudioFocusMode?) {
     self.init({ () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = androidAutoEnabled {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -61,6 +61,12 @@ public extension PlayerConfig {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_AndroidAudioFocusMode_ in
+      if let __unwrappedValue = androidAudioFocus {
+        return bridge.create_std__optional_AndroidAudioFocusMode_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -147,4 +153,9 @@ public extension PlayerConfig {
       }
     }()
   }
+  
+  @inline(__always)
+  var androidAudioFocus: AndroidAudioFocusMode? {
+    return self.__androidAudioFocus.value
+  }
 }

package/nitrogen/generated/ios/swift/ShufflePlaylistOptions.swift

@@ -0,0 +1,42 @@
+///
+/// ShufflePlaylistOptions.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ShufflePlaylistOptions`, backed by a C++ struct.
+ */
+public typealias ShufflePlaylistOptions = margelo.nitro.nitroplayer.ShufflePlaylistOptions
+
+public extension ShufflePlaylistOptions {
+  private typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  /**
+   * Create a new instance of `ShufflePlaylistOptions`.
+   */
+  init(keepCurrentTrackFirst: Bool?) {
+    self.init({ () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = keepCurrentTrackFirst {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var keepCurrentTrackFirst: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__keepCurrentTrackFirst) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__keepCurrentTrackFirst)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/shared/c++/AndroidAudioFocusMode.hpp

@@ -0,0 +1,80 @@
+///
+/// AndroidAudioFocusMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * An enum which can be represented as a JavaScript union (AndroidAudioFocusMode).
+   */
+  enum class AndroidAudioFocusMode {
+    PAUSE      SWIFT_NAME(pause) = 0,
+    DUCK      SWIFT_NAME(duck) = 1,
+    IGNORE      SWIFT_NAME(ignore) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitroplayer
+
+namespace margelo::nitro {
+
+  // C++ AndroidAudioFocusMode <> JS AndroidAudioFocusMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroplayer::AndroidAudioFocusMode> final {
+    static inline margelo::nitro::nitroplayer::AndroidAudioFocusMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("pause"): return margelo::nitro::nitroplayer::AndroidAudioFocusMode::PAUSE;
+        case hashString("duck"): return margelo::nitro::nitroplayer::AndroidAudioFocusMode::DUCK;
+        case hashString("ignore"): return margelo::nitro::nitroplayer::AndroidAudioFocusMode::IGNORE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AndroidAudioFocusMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitroplayer::AndroidAudioFocusMode arg) {
+      switch (arg) {
+        case margelo::nitro::nitroplayer::AndroidAudioFocusMode::PAUSE: return JSIConverter<std::string>::toJSI(runtime, "pause");
+        case margelo::nitro::nitroplayer::AndroidAudioFocusMode::DUCK: return JSIConverter<std::string>::toJSI(runtime, "duck");
+        case margelo::nitro::nitroplayer::AndroidAudioFocusMode::IGNORE: return JSIConverter<std::string>::toJSI(runtime, "ignore");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert AndroidAudioFocusMode to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("pause"):
+        case hashString("duck"):
+        case hashString("ignore"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridPlayerQueueSpec.cpp

@@ -23,6 +23,8 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("addTracksToPlaylist", &HybridPlayerQueueSpec::addTracksToPlaylist);
       prototype.registerHybridMethod("removeTrackFromPlaylist", &HybridPlayerQueueSpec::removeTrackFromPlaylist);
       prototype.registerHybridMethod("reorderTrackInPlaylist", &HybridPlayerQueueSpec::reorderTrackInPlaylist);
+      prototype.registerHybridMethod("removeTracksFromPlaylist", &HybridPlayerQueueSpec::removeTracksFromPlaylist);
+      prototype.registerHybridMethod("shufflePlaylist", &HybridPlayerQueueSpec::shufflePlaylist);
       prototype.registerHybridMethod("loadPlaylist", &HybridPlayerQueueSpec::loadPlaylist);
       prototype.registerHybridMethod("getCurrentPlaylistId", &HybridPlayerQueueSpec::getCurrentPlaylistId);
       prototype.registerHybridMethod("onPlaylistsChanged", &HybridPlayerQueueSpec::onPlaylistsChanged);

package/nitrogen/generated/shared/c++/HybridPlayerQueueSpec.hpp

@@ -17,6 +17,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; }
 
@@ -28,6 +30,7 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include <variant>
 #include <vector>
 #include "TrackItem.hpp"
+#include "ShufflePlaylistOptions.hpp"
 #include "QueueOperation.hpp"
 #include <functional>
 
@@ -71,6 +74,8 @@ namespace margelo::nitro::nitroplayer {
       virtual std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) = 0;
       virtual std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) = 0;
+      virtual std::shared_ptr<Promise<void>> removeTracksFromPlaylist(const std::string& playlistId, const std::vector<std::string>& trackIds) = 0;
+      virtual std::shared_ptr<Promise<void>> shufflePlaylist(const std::string& playlistId, const std::optional<ShufflePlaylistOptions>& options) = 0;
       virtual std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) = 0;
       virtual std::variant<nitro::NullType, std::string> getCurrentPlaylistId() = 0;
       virtual void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) = 0;

package/nitrogen/generated/shared/c++/PlayerConfig.hpp

@@ -28,10 +28,12 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// Forward declaration of `AndroidAudioFocusMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class AndroidAudioFocusMode; }
 
 #include <optional>
 #include <string>
+#include "AndroidAudioFocusMode.hpp"
 
 namespace margelo::nitro::nitroplayer {
 
@@ -47,10 +49,11 @@ namespace margelo::nitro::nitroplayer {
     std::optional<double> remoteSkipBackwardInterval     SWIFT_PRIVATE;
     std::optional<double> lookaheadCount     SWIFT_PRIVATE;
     std::optional<std::string> androidNotificationIcon     SWIFT_PRIVATE;
+    std::optional<AndroidAudioFocusMode> androidAudioFocus     SWIFT_PRIVATE;
 
   public:
     PlayerConfig() = default;
-    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> remoteSkipForwardInterval, std::optional<double> remoteSkipBackwardInterval, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), remoteSkipForwardInterval(remoteSkipForwardInterval), remoteSkipBackwardInterval(remoteSkipBackwardInterval), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon) {}
+    explicit PlayerConfig(std::optional<bool> androidAutoEnabled, std::optional<bool> carPlayEnabled, std::optional<bool> showInNotification, std::optional<double> remoteSkipForwardInterval, std::optional<double> remoteSkipBackwardInterval, std::optional<double> lookaheadCount, std::optional<std::string> androidNotificationIcon, std::optional<AndroidAudioFocusMode> androidAudioFocus): androidAutoEnabled(androidAutoEnabled), carPlayEnabled(carPlayEnabled), showInNotification(showInNotification), remoteSkipForwardInterval(remoteSkipForwardInterval), remoteSkipBackwardInterval(remoteSkipBackwardInterval), lookaheadCount(lookaheadCount), androidNotificationIcon(androidNotificationIcon), androidAudioFocus(androidAudioFocus) {}
 
   public:
     friend bool operator==(const PlayerConfig& lhs, const PlayerConfig& rhs) = default;
@@ -72,7 +75,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipForwardInterval"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon"))),
+        JSIConverter<std::optional<margelo::nitro::nitroplayer::AndroidAudioFocusMode>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAudioFocus")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::PlayerConfig& arg) {
@@ -84,6 +88,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.remoteSkipBackwardInterval));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.lookaheadCount));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.androidNotificationIcon));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "androidAudioFocus"), JSIConverter<std::optional<margelo::nitro::nitroplayer::AndroidAudioFocusMode>>::toJSI(runtime, arg.androidAudioFocus));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -101,6 +106,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "remoteSkipBackwardInterval")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lookaheadCount")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidNotificationIcon")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitroplayer::AndroidAudioFocusMode>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "androidAudioFocus")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/ShufflePlaylistOptions.hpp

@@ -0,0 +1,83 @@
+///
+/// ShufflePlaylistOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ShufflePlaylistOptions).
+   */
+  struct ShufflePlaylistOptions final {
+  public:
+    std::optional<bool> keepCurrentTrackFirst     SWIFT_PRIVATE;
+
+  public:
+    ShufflePlaylistOptions() = default;
+    explicit ShufflePlaylistOptions(std::optional<bool> keepCurrentTrackFirst): keepCurrentTrackFirst(keepCurrentTrackFirst) {}
+
+  public:
+    friend bool operator==(const ShufflePlaylistOptions& lhs, const ShufflePlaylistOptions& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitroplayer
+
+namespace margelo::nitro {
+
+  // C++ ShufflePlaylistOptions <> JS ShufflePlaylistOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroplayer::ShufflePlaylistOptions> final {
+    static inline margelo::nitro::nitroplayer::ShufflePlaylistOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitroplayer::ShufflePlaylistOptions(
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keepCurrentTrackFirst")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::ShufflePlaylistOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "keepCurrentTrackFirst"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.keepCurrentTrackFirst));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "keepCurrentTrackFirst")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.7.0-alpha.3",
+  "version": "1.7.0-alpha.4",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",

package/src/hooks/callbackManager.ts

@@ -37,6 +37,7 @@ class CallbackSubscriptionManager {
   private androidAutoConnectionSubscribers =
     new Set<AndroidAutoConnectionCallback>()
   private isPlaylistsChangedRegistered = false
+  private playlistsChangedFanOutScheduled = false
   private isAndroidAutoConnectionRegistered = false
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
@@ -204,21 +205,35 @@ class CallbackSubscriptionManager {
     }
   }
 
+  // Task-level, not a microtask: native callbacks arrive as separate JS tasks.
+  private schedulePlaylistsChangedFanOut(): void {
+    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)
+  }
+
   private ensurePlaylistsChangedRegistered(): void {
     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
     } catch (error) {