react-native-nitro-player 1.5.1-alpha.0 → 1.6.0-alpha.0

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

@@ -0,0 +1,80 @@
+///
+/// Func_void_TimedMetadata.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.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(metadata: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_TimedMetadata: (TimedMetadata) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(metadata: TimedMetadata): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(metadata: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_TimedMetadata_cxx: Func_void_TimedMetadata {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(metadata: TimedMetadata): Unit
+    = invoke_cxx(metadata)
+
+  @FastNative
+  private external fun invoke_cxx(metadata: TimedMetadata): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(metadata: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(TimedMetadata) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_TimedMetadata_java(private val function: (TimedMetadata) -> Unit): Func_void_TimedMetadata {
+  @DoNotStrip
+  @Keep
+  override fun invoke(metadata: TimedMetadata): Unit {
+    return this.function(metadata)
+  }
+}

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

@@ -121,6 +121,15 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
     return __result
   }
   
+  abstract fun onTimedMetadata(callback: (metadata: TimedMetadata) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun onTimedMetadata_cxx(callback: Func_void_TimedMetadata): Unit {
+    val __result = onTimedMetadata(callback)
+    return __result
+  }
+  
   abstract fun onAndroidAutoConnectionChange(callback: (connected: Boolean) -> Unit): Unit
   
   @DoNotStrip

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

@@ -0,0 +1,47 @@
+///
+/// TimedMetadata.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 "TimedMetadata".
+ */
+@DoNotStrip
+@Keep
+data class TimedMetadata(
+  @DoNotStrip
+  @Keep
+  val title: String?,
+  @DoNotStrip
+  @Keep
+  val artist: String?,
+  @DoNotStrip
+  @Keep
+  val album: String?,
+  @DoNotStrip
+  @Keep
+  val artworkUrl: String?
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(title: String?, artist: String?, album: String?, artworkUrl: String?): TimedMetadata {
+      return TimedMetadata(title, artist, album, artworkUrl)
+    }
+  }
+}

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

@@ -315,6 +315,14 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const TimedMetadata& /* metadata */)>
+  Func_void_TimedMetadata create_Func_void_TimedMetadata(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroPlayer::Func_void_TimedMetadata::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const TimedMetadata& metadata) mutable -> void {
+      swiftClosure.call(metadata);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
   Func_void_std__vector_TrackItem__double create_Func_void_std__vector_TrackItem__double(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroPlayer::Func_void_std__vector_TrackItem__double::fromUnsafe(swiftClosureWrapper);

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

@@ -68,6 +68,8 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `StorageLocation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -118,6 +120,7 @@ namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 #include "Reason.hpp"
 #include "RepeatMode.hpp"
 #include "StorageLocation.hpp"
+#include "TimedMetadata.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include <NitroModules/AnyMap.hpp>
@@ -1727,6 +1730,28 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_double_double_std__optional_bool__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const TimedMetadata& /* metadata */)>
+  /**
+   * Specialized version of `std::function<void(const TimedMetadata&)>`.
+   */
+  using Func_void_TimedMetadata = std::function<void(const TimedMetadata& /* metadata */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TimedMetadata& / * metadata * /)>`, this can be used from Swift.
+   */
+  class Func_void_TimedMetadata_Wrapper final {
+  public:
+    explicit Func_void_TimedMetadata_Wrapper(std::function<void(const TimedMetadata& /* metadata */)>&& func): _function(std::make_unique<std::function<void(const TimedMetadata& /* metadata */)>>(std::move(func))) {}
+    inline void call(TimedMetadata metadata) const noexcept {
+      _function->operator()(metadata);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TimedMetadata& /* metadata */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TimedMetadata create_Func_void_TimedMetadata(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TimedMetadata_Wrapper wrap_Func_void_TimedMetadata(Func_void_TimedMetadata value) noexcept {
+    return Func_void_TimedMetadata_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>
   /**
    * Specialized version of `std::function<void(const std::vector<TrackItem>&, double)>`.

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

@@ -70,6 +70,8 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `StorageLocation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -107,6 +109,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "Reason.hpp"
 #include "RepeatMode.hpp"
 #include "StorageLocation.hpp"
+#include "TimedMetadata.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include <NitroModules/AnyMap.hpp>

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

@@ -26,6 +26,8 @@ namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -42,6 +44,7 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "PlayerConfig.hpp"
 #include "Reason.hpp"
 #include <functional>
+#include "TimedMetadata.hpp"
 
 #include "NitroPlayer-Swift-Cxx-Umbrella.hpp"
 
@@ -229,6 +232,12 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void onTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& callback) override {
+      auto __result = _swiftPart.onTimedMetadata(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override {
       auto __result = _swiftPart.onAndroidAutoConnectionChange(callback);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_TimedMetadata.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_TimedMetadata.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ metadata: TimedMetadata) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_TimedMetadata {
+  public typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  private let closure: (_ metadata: TimedMetadata) -> Void
+
+  public init(_ closure: @escaping (_ metadata: TimedMetadata) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(metadata: TimedMetadata) -> Void {
+    self.closure(metadata)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_TimedMetadata`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_TimedMetadata>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_TimedMetadata {
+    return Unmanaged<Func_void_TimedMetadata>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -31,6 +31,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onPlaybackStateChange(callback: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) throws -> Void
   func onSeek(callback: @escaping (_ position: Double, _ totalDuration: Double) -> Void) throws -> Void
   func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws -> Void
+  func onTimedMetadata(callback: @escaping (_ metadata: TimedMetadata) -> Void) throws -> Void
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
   func setVolume(volume: Double) throws -> Promise<Void>

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -478,6 +478,22 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func onTimedMetadata(callback: bridge.Func_void_TimedMetadata) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.onTimedMetadata(callback: { () -> (TimedMetadata) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_TimedMetadata(callback)
+        return { (__metadata: TimedMetadata) -> Void in
+          __wrappedFunction.call(__metadata)
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func onAndroidAutoConnectionChange(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/TimedMetadata.swift

@@ -0,0 +1,96 @@
+///
+/// TimedMetadata.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 `TimedMetadata`, backed by a C++ struct.
+ */
+public typealias TimedMetadata = margelo.nitro.nitroplayer.TimedMetadata
+
+public extension TimedMetadata {
+  private typealias bridge = margelo.nitro.nitroplayer.bridge.swift
+
+  /**
+   * Create a new instance of `TimedMetadata`.
+   */
+  init(title: String?, artist: String?, album: String?, artworkUrl: String?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = title {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = artist {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = album {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = artworkUrl {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var title: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__title) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__title)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var artist: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__artist) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__artist)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var album: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__album) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__album)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var artworkUrl: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__artworkUrl) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__artworkUrl)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+}

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

@@ -32,6 +32,7 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("onPlaybackStateChange", &HybridTrackPlayerSpec::onPlaybackStateChange);
       prototype.registerHybridMethod("onSeek", &HybridTrackPlayerSpec::onSeek);
       prototype.registerHybridMethod("onPlaybackProgressChange", &HybridTrackPlayerSpec::onPlaybackProgressChange);
+      prototype.registerHybridMethod("onTimedMetadata", &HybridTrackPlayerSpec::onTimedMetadata);
       prototype.registerHybridMethod("onAndroidAutoConnectionChange", &HybridTrackPlayerSpec::onAndroidAutoConnectionChange);
       prototype.registerHybridMethod("isAndroidAutoConnected", &HybridTrackPlayerSpec::isAndroidAutoConnected);
       prototype.registerHybridMethod("setVolume", &HybridTrackPlayerSpec::setVolume);

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

@@ -25,6 +25,8 @@ namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TimedMetadata; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -37,6 +39,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "Reason.hpp"
 #include <functional>
 #include "TrackPlayerState.hpp"
+#include "TimedMetadata.hpp"
 
 namespace margelo::nitro::nitroplayer {
 
@@ -87,6 +90,7 @@ namespace margelo::nitro::nitroplayer {
       virtual void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) = 0;
       virtual void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) = 0;
       virtual void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) = 0;
+      virtual void onTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& callback) = 0;
       virtual void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) = 0;
       virtual bool isAndroidAutoConnected() = 0;
       virtual std::shared_ptr<Promise<void>> setVolume(double volume) = 0;

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

@@ -0,0 +1,96 @@
+///
+/// TimedMetadata.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 <string>
+#include <optional>
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * A struct which can be represented as a JavaScript object (TimedMetadata).
+   */
+  struct TimedMetadata final {
+  public:
+    std::optional<std::string> title     SWIFT_PRIVATE;
+    std::optional<std::string> artist     SWIFT_PRIVATE;
+    std::optional<std::string> album     SWIFT_PRIVATE;
+    std::optional<std::string> artworkUrl     SWIFT_PRIVATE;
+
+  public:
+    TimedMetadata() = default;
+    explicit TimedMetadata(std::optional<std::string> title, std::optional<std::string> artist, std::optional<std::string> album, std::optional<std::string> artworkUrl): title(title), artist(artist), album(album), artworkUrl(artworkUrl) {}
+
+  public:
+    friend bool operator==(const TimedMetadata& lhs, const TimedMetadata& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitroplayer
+
+namespace margelo::nitro {
+
+  // C++ TimedMetadata <> JS TimedMetadata (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroplayer::TimedMetadata> final {
+    static inline margelo::nitro::nitroplayer::TimedMetadata fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitroplayer::TimedMetadata(
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkUrl")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::TimedMetadata& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "title"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.title));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "artist"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.artist));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "album"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.album));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "artworkUrl"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.artworkUrl));
+      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<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkUrl")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.5.1-alpha.0",
+  "version": "1.6.0-alpha.0",
   "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

@@ -1,5 +1,10 @@
 import { PlayerQueue, TrackPlayer } from '../index'
-import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue'
+import type {
+  TrackItem,
+  TrackPlayerState,
+  Reason,
+  TimedMetadata,
+} from '../types/PlayerQueue'
 
 type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void
 type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
@@ -9,6 +14,7 @@ type PlaybackProgressCallback = (
   isManuallySeeked?: boolean
 ) => void
 type SeekCallback = (position: number, totalDuration: number) => void
+type TimedMetadataCallback = (metadata: TimedMetadata) => void
 type TemporaryQueueCallback = (
   playNextQueue: TrackItem[],
   upNextQueue: TrackItem[]
@@ -24,6 +30,7 @@ class CallbackSubscriptionManager {
   private trackChangeSubscribers = new Set<TrackChangeCallback>()
   private playbackProgressSubscribers = new Set<PlaybackProgressCallback>()
   private seekSubscribers = new Set<SeekCallback>()
+  private timedMetadataSubscribers = new Set<TimedMetadataCallback>()
   private temporaryQueueSubscribers = new Set<TemporaryQueueCallback>()
   private playlistsChangedSubscribers = new Set<() => void>()
   private isPlaylistsChangedRegistered = false
@@ -31,6 +38,7 @@ class CallbackSubscriptionManager {
   private isTrackChangeRegistered = false
   private isPlaybackProgressRegistered = false
   private isSeekRegistered = false
+  private isTimedMetadataRegistered = false
   private isTemporaryQueueRegistered = false
 
   /**
@@ -263,6 +271,44 @@ class CallbackSubscriptionManager {
       )
     }
   }
+
+  /**
+   * Subscribe to in-stream (timed) metadata events
+   * @returns Unsubscribe function
+   */
+  subscribeToTimedMetadata(callback: TimedMetadataCallback): () => void {
+    this.timedMetadataSubscribers.add(callback)
+    this.ensureTimedMetadataRegistered()
+
+    return () => {
+      this.timedMetadataSubscribers.delete(callback)
+    }
+  }
+
+  private ensureTimedMetadataRegistered(): void {
+    if (this.isTimedMetadataRegistered) return
+
+    try {
+      TrackPlayer.onTimedMetadata((metadata) => {
+        this.timedMetadataSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(metadata)
+          } catch (error) {
+            console.error(
+              '[CallbackManager] Error in timed metadata subscriber:',
+              error
+            )
+          }
+        })
+      })
+      this.isTimedMetadataRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register timed metadata callback:',
+        error
+      )
+    }
+  }
 }
 
 // Export singleton instance

package/src/hooks/index.ts

@@ -4,6 +4,7 @@ export { useOnPlaybackStateChange } from './useOnPlaybackStateChange'
 export type { PlaybackStateResult } from './useOnPlaybackStateChange'
 export { useOnSeek } from './useOnSeek'
 export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange'
+export { useTimedMetadata } from './useTimedMetadata'
 export { useAndroidAutoConnection } from './useAndroidAutoConnection'
 export { useAudioDevices } from './useAudioDevices'
 export { useNowPlaying } from './useNowPlaying'