react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -0,0 +1,223 @@
+///
+/// HybridEqualizerSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridEqualizerSpec.hpp"
+
+// Forward declaration of `HybridEqualizerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridEqualizerSpec_cxx; }
+
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerBand; }
+// Forward declaration of `GainRange` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct GainRange; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerPreset; }
+// Forward declaration of `PresetType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PresetType; }
+// Forward declaration of `EqualizerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerState; }
+
+#include "EqualizerBand.hpp"
+#include <vector>
+#include <string>
+#include "GainRange.hpp"
+#include "EqualizerPreset.hpp"
+#include "PresetType.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "EqualizerState.hpp"
+#include <optional>
+#include <functional>
+
+#include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * The C++ part of HybridEqualizerSpec_cxx.swift.
+   *
+   * HybridEqualizerSpecSwift (C++) accesses HybridEqualizerSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridEqualizerSpec_cxx can directly inherit from the C++ class HybridEqualizerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridEqualizerSpecSwift: public virtual HybridEqualizerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridEqualizerSpecSwift(const NitroPlayer::HybridEqualizerSpec_cxx& swiftPart):
+      HybridObject(HybridEqualizerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroPlayer::HybridEqualizerSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline bool setEnabled(bool enabled) override {
+      auto __result = _swiftPart.setEnabled(std::forward<decltype(enabled)>(enabled));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isEnabled() override {
+      auto __result = _swiftPart.isEnabled();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<EqualizerBand> getBands() override {
+      auto __result = _swiftPart.getBands();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setBandGain(double bandIndex, double gainDb) override {
+      auto __result = _swiftPart.setBandGain(std::forward<decltype(bandIndex)>(bandIndex), std::forward<decltype(gainDb)>(gainDb));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool setAllBandGains(const std::vector<double>& gains) override {
+      auto __result = _swiftPart.setAllBandGains(gains);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline GainRange getBandRange() override {
+      auto __result = _swiftPart.getBandRange();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<EqualizerPreset> getPresets() override {
+      auto __result = _swiftPart.getPresets();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<EqualizerPreset> getBuiltInPresets() override {
+      auto __result = _swiftPart.getBuiltInPresets();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<EqualizerPreset> getCustomPresets() override {
+      auto __result = _swiftPart.getCustomPresets();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool applyPreset(const std::string& presetName) override {
+      auto __result = _swiftPart.applyPreset(presetName);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<nitro::NullType, std::string> getCurrentPresetName() override {
+      auto __result = _swiftPart.getCurrentPresetName();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool saveCustomPreset(const std::string& name) override {
+      auto __result = _swiftPart.saveCustomPreset(name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool deleteCustomPreset(const std::string& name) override {
+      auto __result = _swiftPart.deleteCustomPreset(name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline EqualizerState getState() override {
+      auto __result = _swiftPart.getState();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void reset() override {
+      auto __result = _swiftPart.reset();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onEnabledChange(const std::function<void(bool /* enabled */)>& callback) override {
+      auto __result = _swiftPart.onEnabledChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onBandChange(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& callback) override {
+      auto __result = _swiftPart.onBandChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onPresetChange(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& callback) override {
+      auto __result = _swiftPart.onPresetChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroPlayer::HybridEqualizerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -26,6 +26,7 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include <variant>
 #include "TrackItem.hpp"
 #include <vector>
+#include <NitroModules/AnyMap.hpp>
 #include "QueueOperation.hpp"
 #include <functional>
 

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

@@ -12,12 +12,14 @@
 // Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 
-// Forward declaration of `PlayerState` to properly resolve imports.
-namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `CurrentPlayingType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class CurrentPlayingType; }
 // Forward declaration of `RepeatMode` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
@@ -25,13 +27,17 @@ namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 
+#include <NitroModules/Promise.hpp>
 #include <string>
 #include <optional>
-#include "PlayerState.hpp"
-#include <NitroModules/Null.hpp>
 #include "TrackItem.hpp"
+#include <vector>
+#include <NitroModules/Null.hpp>
 #include <variant>
+#include <NitroModules/AnyMap.hpp>
+#include "PlayerState.hpp"
 #include "TrackPlayerState.hpp"
+#include "CurrentPlayingType.hpp"
 #include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "Reason.hpp"
@@ -93,11 +99,13 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override {
+    inline std::shared_ptr<Promise<void>> playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override {
       auto __result = _swiftPart.playSong(songId, fromPlaylist);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void skipToNext() override {
       auto __result = _swiftPart.skipToNext();
@@ -105,6 +113,14 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::shared_ptr<Promise<bool>> skipToIndex(double index) override {
+      auto __result = _swiftPart.skipToIndex(std::forward<decltype(index)>(index));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void skipToPrevious() override {
       auto __result = _swiftPart.skipToPrevious();
       if (__result.hasError()) [[unlikely]] {
@@ -117,7 +133,31 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
-    inline PlayerState getState() override {
+    inline std::shared_ptr<Promise<void>> addToUpNext(const std::string& trackId) override {
+      auto __result = _swiftPart.addToUpNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> playNext(const std::string& trackId) override {
+      auto __result = _swiftPart.playNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::vector<TrackItem>>> getActualQueue() override {
+      auto __result = _swiftPart.getActualQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<PlayerState>> getState() override {
       auto __result = _swiftPart.getState();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/CurrentPlayingType.swift

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

package/nitrogen/generated/ios/swift/DownloadConfig.swift

@@ -0,0 +1,270 @@
+///
+/// DownloadConfig.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `DownloadConfig`, backed by a C++ struct.
+ */
+public typealias DownloadConfig = margelo.nitro.nitroplayer.DownloadConfig
+
+public extension DownloadConfig {
+  private typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  /**
+   * Create a new instance of `DownloadConfig`.
+   */
+  init(storageLocation: StorageLocation?, maxConcurrentDownloads: Double?, autoRetry: Bool?, maxRetryAttempts: Double?, backgroundDownloadsEnabled: Bool?, downloadArtwork: Bool?, customDownloadPath: Variant_NullType_String?, wifiOnlyDownloads: Bool?) {
+    self.init({ () -> bridge.std__optional_StorageLocation_ in
+      if let __unwrappedValue = storageLocation {
+        return bridge.create_std__optional_StorageLocation_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = maxConcurrentDownloads {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = autoRetry {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = maxRetryAttempts {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = backgroundDownloadsEnabled {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = downloadArtwork {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in
+      if let __unwrappedValue = customDownloadPath {
+        return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null)
+            case .second(let __value):
+              return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value))
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = wifiOnlyDownloads {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var storageLocation: StorageLocation? {
+    @inline(__always)
+    get {
+      return self.__storageLocation.value
+    }
+    @inline(__always)
+    set {
+      self.__storageLocation = { () -> bridge.std__optional_StorageLocation_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_StorageLocation_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var maxConcurrentDownloads: Double? {
+    @inline(__always)
+    get {
+      return self.__maxConcurrentDownloads.value
+    }
+    @inline(__always)
+    set {
+      self.__maxConcurrentDownloads = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var autoRetry: Bool? {
+    @inline(__always)
+    get {
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__autoRetry) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__autoRetry)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__autoRetry = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var maxRetryAttempts: Double? {
+    @inline(__always)
+    get {
+      return self.__maxRetryAttempts.value
+    }
+    @inline(__always)
+    set {
+      self.__maxRetryAttempts = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var backgroundDownloadsEnabled: Bool? {
+    @inline(__always)
+    get {
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__backgroundDownloadsEnabled) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__backgroundDownloadsEnabled)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__backgroundDownloadsEnabled = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var downloadArtwork: Bool? {
+    @inline(__always)
+    get {
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__downloadArtwork) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__downloadArtwork)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__downloadArtwork = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var customDownloadPath: Variant_NullType_String? {
+    @inline(__always)
+    get {
+      return { () -> Variant_NullType_String? in
+        if bridge.has_value_std__optional_std__variant_nitro__NullType__std__string__(self.__customDownloadPath) {
+          let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__string__(self.__customDownloadPath)
+          return { () -> Variant_NullType_String in
+            let __variant = bridge.std__variant_nitro__NullType__std__string_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(NullType.null)
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(String(__actual))
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__customDownloadPath = { () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null)
+              case .second(let __value):
+                return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value))
+            }
+          }().variant)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var wifiOnlyDownloads: Bool? {
+    @inline(__always)
+    get {
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__wifiOnlyDownloads) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__wifiOnlyDownloads)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__wifiOnlyDownloads = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}