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

package/ios/download/DownloadDatabase.swift

@@ -28,6 +28,39 @@ final class DownloadDatabase {
   private let queue = DispatchQueue(
     label: "com.nitroplayer.downloadDatabase", attributes: .concurrent)
 
+  /// Memoized `fileExists` verdicts, keyed by track ID.
+  ///
+  /// Queue building calls `isTrackDownloaded` / `getDownloadedTrack` once per track,
+  /// and each call used to stat() the file — O(playlist) syscalls per rebuild, on the
+  /// thread that also drives playback. Downloads only change through this class (or
+  /// through the user deleting files behind our back, which `syncDownloads()` handles),
+  /// so the verdict is cached and invalidated on every mutation.
+  /// Guarded by its own lock rather than `queue` so it can be filled from inside
+  /// concurrent read blocks (`queue.sync`) without a barrier.
+  private var existenceCache: [String: Bool] = [:]
+  private let existenceCacheLock = NSLock()
+
+  private func cachedFileExists(trackId: String, path: @autoclosure () -> String) -> Bool {
+    existenceCacheLock.lock()
+    let cached = existenceCache[trackId]
+    existenceCacheLock.unlock()
+    if let cached { return cached }
+
+    let exists = FileManager.default.fileExists(atPath: path())
+    existenceCacheLock.lock()
+    existenceCache[trackId] = exists
+    existenceCacheLock.unlock()
+    return exists
+  }
+
+  /// Drops every memoized verdict. Called on any record mutation, and safe to call
+  /// externally when files may have changed outside the app.
+  func invalidateExistenceCache() {
+    existenceCacheLock.lock()
+    existenceCache.removeAll()
+    existenceCacheLock.unlock()
+  }
+
   // MARK: - Initialization
 
   private init() {
@@ -70,22 +103,14 @@ final class DownloadDatabase {
         NitroPlayerLogger.log("DownloadDatabase", "🔍 Track \(trackId) NOT found in database")
         return false
       }
-      // Verify file still exists
-      let absolutePath = resolveAbsolutePath(for: record)
-      let exists = FileManager.default.fileExists(atPath: absolutePath)
-      if exists {
-        NitroPlayerLogger.log("DownloadDatabase", "✅ Track \(trackId) IS downloaded at \(absolutePath)")
-      } else {
-        NitroPlayerLogger.log("DownloadDatabase", "❌ Track \(trackId) record exists but file NOT found at \(absolutePath)")
-      }
-      return exists
+      // Verify file still exists (memoized — this runs once per track per queue rebuild)
+      return cachedFileExists(trackId: trackId, path: resolveAbsolutePath(for: record))
     }
   }
 
   private func _isTrackDownloadedUnsafe(trackId: String) -> Bool {
     guard let record = downloadedTracks[trackId] else { return false }
-    let absolutePath = resolveAbsolutePath(for: record)
-    return FileManager.default.fileExists(atPath: absolutePath)
+    return cachedFileExists(trackId: trackId, path: resolveAbsolutePath(for: record))
   }
 
   func isPlaylistDownloaded(playlistId: String) -> Bool {
@@ -137,8 +162,8 @@ final class DownloadDatabase {
       let absolutePath = resolveAbsolutePath(for: record)
       NitroPlayerLogger.log("DownloadDatabase", "   Found record, checking file at: \(absolutePath)")
 
-      // Verify file still exists
-      guard FileManager.default.fileExists(atPath: absolutePath) else {
+      // Verify file still exists (memoized)
+      guard cachedFileExists(trackId: trackId, path: absolutePath) else {
         NitroPlayerLogger.log("DownloadDatabase", "   ❌ File does NOT exist, cleaning up record")
         // File was deleted externally, clean up record
         queue.async(flags: .barrier) {
@@ -357,6 +382,9 @@ final class DownloadDatabase {
   // MARK: - Persistence
 
   private func saveToDisk() {
+    // Every record mutation funnels through here, so this is the one place that has
+    // to drop memoized fileExists verdicts.
+    invalidateExistenceCache()
     do {
       let tracksData = try JSONEncoder().encode(downloadedTracks)
       // Convert Set to Array for encoding

package/ios/media/MediaSessionManager.swift

@@ -31,7 +31,11 @@ class MediaSessionManager {
   // Cached values received from playerQueue — main-thread-only reads (no sync needed)
   private var cachedTrack: TrackItem?
   private var cachedState: PlayerState?
-  private var cachedQueue: [TrackItem] = []
+  // Only the queue length and the current track's position are needed — never the
+  // items themselves. Copying the whole queue on every state change was O(playlist)
+  // per event; these two Ints are computed on playerQueue instead.
+  private var cachedQueueCount: Int = 0
+  private var cachedPositionInQueue: Int = -1
 
   init() {
     setupRemoteCommandCenter()
@@ -56,10 +60,13 @@ class MediaSessionManager {
   //
   // Receives pre-computed values captured on playerQueue — no player access here.
 
-  func updateFromPlayerQueue(track: TrackItem, state: PlayerState, queue: [TrackItem]) {
+  func updateFromPlayerQueue(
+    track: TrackItem, state: PlayerState, queueCount: Int, positionInQueue: Int
+  ) {
     cachedTrack = track
     cachedState = state
-    cachedQueue = queue
+    cachedQueueCount = queueCount
+    cachedPositionInQueue = positionInQueue
     refreshInternal()
   }
 
@@ -88,11 +95,11 @@ class MediaSessionManager {
       return
     }
 
-    let queue = cachedQueue
-    let positionInQueue = queue.firstIndex(where: { $0.id == track.id }) ?? -1
-
-    updateNowPlayingInfoInternal(track: track, state: state, queue: queue, positionInQueue: positionInQueue)
-    updateCommandCenterState(state: state, queue: queue, positionInQueue: positionInQueue)
+    updateNowPlayingInfoInternal(
+      track: track, state: state,
+      queueCount: cachedQueueCount, positionInQueue: cachedPositionInQueue)
+    updateCommandCenterState(
+      state: state, queueCount: cachedQueueCount, positionInQueue: cachedPositionInQueue)
   }
 
   // MARK: - Now Playing Info
@@ -100,7 +107,7 @@ class MediaSessionManager {
   private func updateNowPlayingInfoInternal(
     track: TrackItem,
     state: PlayerState,
-    queue: [TrackItem],
+    queueCount: Int,
     positionInQueue: Int
   ) {
     let playerDuration = state.totalDuration
@@ -125,7 +132,7 @@ class MediaSessionManager {
       MPMediaItemPropertyPlaybackDuration: effectiveDuration,
       MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? 1.0 : 0.0,
       MPNowPlayingInfoPropertyDefaultPlaybackRate: 1.0,
-      MPNowPlayingInfoPropertyPlaybackQueueCount: max(1, queue.count),
+      MPNowPlayingInfoPropertyPlaybackQueueCount: max(1, queueCount),
       MPNowPlayingInfoPropertyPlaybackQueueIndex: max(0, positionInQueue),
     ]
 
@@ -238,12 +245,12 @@ class MediaSessionManager {
 
   private func updateCommandCenterState(
     state: PlayerState,
-    queue: [TrackItem],
+    queueCount: Int,
     positionInQueue: Int
   ) {
     let commandCenter = MPRemoteCommandCenter.shared()
     let hasCurrentTrack = positionInQueue >= 0
-    let isNotLast = positionInQueue < queue.count - 1
+    let isNotLast = positionInQueue < queueCount - 1
 
     let playerDuration = state.totalDuration
     let hasDuration = playerDuration > 0 && !playerDuration.isNaN && !playerDuration.isInfinite

package/ios/queue/HybridPlayerQueue.swift

@@ -77,14 +77,19 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
 
   // MARK: - Playback control
 
+  /// Enqueued synchronously on the player queue so a `loadPlaylist()` followed by
+  /// `play()` from JS cannot be reordered — see HybridTrackPlayer.enqueue.
   func loadPlaylist(playlistId: String, index: Double?) throws -> Promise<Void> {
-    Promise.async {
-      let startIndex = index.map { Int($0) }
+    let startIndex = index.map { Int($0) }
+    let promise = Promise<Void>()
+    core.playerQueue.async {
       // Update PlaylistManager.currentPlaylistId so getCurrentPlaylistId() returns correctly
-      let loaded = self.playlistManager.loadPlaylist(playlistId: playlistId, index: startIndex)
-      guard loaded else { return }
-      await self.core.loadPlaylist(playlistId: playlistId, startIndex: startIndex)
+      if self.playlistManager.loadPlaylist(playlistId: playlistId, index: startIndex) {
+        self.core.loadPlaylistOnQueue(playlistId: playlistId, startIndex: startIndex)
+      }
+      promise.resolve(withResult: ())
     }
+    return promise
   }
 
   func getCurrentPlaylistId() throws -> Variant_NullType_String {

package/lib/hooks/callbackManager.d.ts

@@ -1,8 +1,10 @@
-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;
 type PlaybackProgressCallback = (position: number, totalDuration: number, isManuallySeeked?: boolean) => void;
 type SeekCallback = (position: number, totalDuration: number) => void;
+type TimedMetadataCallback = (metadata: TimedMetadata) => void;
+type TemporaryQueueCallback = (playNextQueue: TrackItem[], upNextQueue: TrackItem[]) => void;
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
  * to a single native callback. This solves the problem where registering
@@ -13,10 +15,16 @@ declare class CallbackSubscriptionManager {
     private trackChangeSubscribers;
     private playbackProgressSubscribers;
     private seekSubscribers;
+    private timedMetadataSubscribers;
+    private temporaryQueueSubscribers;
+    private playlistsChangedSubscribers;
+    private isPlaylistsChangedRegistered;
     private isPlaybackStateRegistered;
     private isTrackChangeRegistered;
     private isPlaybackProgressRegistered;
     private isSeekRegistered;
+    private isTimedMetadataRegistered;
+    private isTemporaryQueueRegistered;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -40,7 +48,25 @@ declare class CallbackSubscriptionManager {
      */
     subscribeToSeek(callback: SeekCallback): () => void;
     private ensurePlaybackProgressRegistered;
+    /**
+     * Subscribe to playNext / upNext changes
+     * @returns Unsubscribe function
+     */
+    subscribeToTemporaryQueueChange(callback: TemporaryQueueCallback): () => void;
+    /**
+     * Subscribe to playlist mutations (tracks added/removed/reordered).
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaylistsChanged(callback: () => void): () => void;
+    private ensurePlaylistsChangedRegistered;
+    private ensureTemporaryQueueRegistered;
     private ensureSeekRegistered;
+    /**
+     * Subscribe to in-stream (timed) metadata events
+     * @returns Unsubscribe function
+     */
+    subscribeToTimedMetadata(callback: TimedMetadataCallback): () => void;
+    private ensureTimedMetadataRegistered;
 }
 export declare const callbackManager: CallbackSubscriptionManager;
 export {};

package/lib/hooks/callbackManager.js

@@ -1,4 +1,4 @@
-import { TrackPlayer } from '../index';
+import { PlayerQueue, TrackPlayer } from '../index';
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
  * to a single native callback. This solves the problem where registering
@@ -9,10 +9,16 @@ class CallbackSubscriptionManager {
     trackChangeSubscribers = new Set();
     playbackProgressSubscribers = new Set();
     seekSubscribers = new Set();
+    timedMetadataSubscribers = new Set();
+    temporaryQueueSubscribers = new Set();
+    playlistsChangedSubscribers = new Set();
+    isPlaylistsChangedRegistered = false;
     isPlaybackStateRegistered = false;
     isTrackChangeRegistered = false;
     isPlaybackProgressRegistered = false;
     isSeekRegistered = false;
+    isTimedMetadataRegistered = false;
+    isTemporaryQueueRegistered = false;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -117,6 +123,68 @@ class CallbackSubscriptionManager {
             console.error('[CallbackManager] Failed to register playback progress callback:', error);
         }
     }
+    /**
+     * Subscribe to playNext / upNext changes
+     * @returns Unsubscribe function
+     */
+    subscribeToTemporaryQueueChange(callback) {
+        this.temporaryQueueSubscribers.add(callback);
+        this.ensureTemporaryQueueRegistered();
+        return () => {
+            this.temporaryQueueSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to playlist mutations (tracks added/removed/reordered).
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaylistsChanged(callback) {
+        this.playlistsChangedSubscribers.add(callback);
+        this.ensurePlaylistsChangedRegistered();
+        return () => {
+            this.playlistsChangedSubscribers.delete(callback);
+        };
+    }
+    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.isPlaylistsChangedRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register playlists changed callback:', error);
+        }
+    }
+    ensureTemporaryQueueRegistered() {
+        if (this.isTemporaryQueueRegistered)
+            return;
+        try {
+            TrackPlayer.onTemporaryQueueChange((playNextQueue, upNextQueue) => {
+                this.temporaryQueueSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(playNextQueue, upNextQueue);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in temporary queue subscriber:', error);
+                    }
+                });
+            });
+            this.isTemporaryQueueRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register temporary queue callback:', error);
+        }
+    }
     ensureSeekRegistered() {
         if (this.isSeekRegistered)
             return;
@@ -137,6 +205,37 @@ class CallbackSubscriptionManager {
             console.error('[CallbackManager] Failed to register seek callback:', error);
         }
     }
+    /**
+     * Subscribe to in-stream (timed) metadata events
+     * @returns Unsubscribe function
+     */
+    subscribeToTimedMetadata(callback) {
+        this.timedMetadataSubscribers.add(callback);
+        this.ensureTimedMetadataRegistered();
+        return () => {
+            this.timedMetadataSubscribers.delete(callback);
+        };
+    }
+    ensureTimedMetadataRegistered() {
+        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
 export const callbackManager = new CallbackSubscriptionManager();

package/lib/hooks/index.d.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';

package/lib/hooks/index.js

@@ -2,6 +2,7 @@ export { useOnChangeTrack } from './useOnChangeTrack';
 export { useOnPlaybackStateChange } 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';

package/lib/hooks/useActualQueue.js

@@ -75,24 +75,30 @@ export function useActualQueue() {
             isMounted.current = false;
         };
     }, [updateQueue]);
-    // Update queue on track changes (with slight delay to ensure native side has updated)
+    // Update queue on track changes.
+    //
+    // Deliberately NOT subscribed to playback-state changes: those fire several times
+    // per second while buffering or seeking, and each one used to pull the entire queue
+    // across the bridge. A playback state change never alters queue membership — only
+    // track changes and temporary-queue edits do.
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-            // Small delay to ensure native queue is updated
-            setTimeout(updateQueue, 50);
+        return callbackManager.subscribeToTrackChange(() => {
+            updateQueue();
         });
-        return () => {
-            unsubscribe();
-        };
     }, [updateQueue]);
-    // Update queue on playback state changes
+    // Update queue when playNext / upNext change (native pushes the new lists).
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
+        return callbackManager.subscribeToTemporaryQueueChange(() => {
+            updateQueue();
+        });
+    }, [updateQueue]);
+    // Update queue when the playlist itself is edited (track added / removed / reordered).
+    // Without this, a playlist mutation while paused would leave the queue stale until the
+    // next track change — playback-state changes used to paper over it.
+    useEffect(() => {
+        return callbackManager.subscribeToPlaylistsChanged(() => {
             updateQueue();
         });
-        return () => {
-            unsubscribe();
-        };
     }, [updateQueue]);
     return { queue, refreshQueue, isLoading };
 }

package/lib/hooks/useNowPlaying.js

@@ -80,12 +80,20 @@ export function useNowPlaying() {
             fetchFullState();
         });
     }, [fetchFullState]);
-    // Subscribe to progress changes — lightweight position/duration update
+    // Subscribe to progress changes — lightweight position/duration update.
+    // Bail out when neither value changed at whole-second resolution: the native tick
+    // is sub-second, and a new state object on every tick re-renders every consumer.
     useEffect(() => {
         return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
             if (!isMounted.current)
                 return;
-            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+            setState((prev) => {
+                if (Math.floor(prev.currentPosition) === Math.floor(currentPosition) &&
+                    prev.totalDuration === totalDuration) {
+                    return prev;
+                }
+                return { ...prev, currentPosition, totalDuration };
+            });
         });
     }, []);
     // Subscribe to seek events — lightweight position/duration update

package/lib/hooks/useTimedMetadata.d.ts

@@ -0,0 +1,16 @@
+import type { TimedMetadata } from '../types/PlayerQueue';
+/**
+ * Hook to subscribe to in-stream (timed) metadata — ICY/Shoutcast StreamTitle
+ * updates and ID3 frames emitted while a live stream plays.
+ *
+ * @returns The most recent metadata, or undefined until the first event arrives
+ *
+ * @example
+ * ```tsx
+ * function NowPlayingFromStream() {
+ *   const metadata = useTimedMetadata()
+ *   return <Text>{metadata?.title ?? 'Live'}</Text>
+ * }
+ * ```
+ */
+export declare function useTimedMetadata(): TimedMetadata | undefined;

package/lib/hooks/useTimedMetadata.js

@@ -0,0 +1,21 @@
+import { useEffect, useState } from 'react';
+import { callbackManager } from './callbackManager';
+/**
+ * Hook to subscribe to in-stream (timed) metadata — ICY/Shoutcast StreamTitle
+ * updates and ID3 frames emitted while a live stream plays.
+ *
+ * @returns The most recent metadata, or undefined until the first event arrives
+ *
+ * @example
+ * ```tsx
+ * function NowPlayingFromStream() {
+ *   const metadata = useTimedMetadata()
+ *   return <Text>{metadata?.title ?? 'Live'}</Text>
+ * }
+ * ```
+ */
+export function useTimedMetadata() {
+    const [metadata, setMetadata] = useState(undefined);
+    useEffect(() => callbackManager.subscribeToTimedMetadata(setMetadata), []);
+    return metadata;
+}

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 } from '../types/PlayerQueue';
+import type { QueueOperation, Reason, TrackItem, TrackPlayerState, PlayerState, PlayerConfig, Playlist, TimedMetadata } from '../types/PlayerQueue';
 export interface PlayerQueue extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
@@ -41,6 +41,11 @@ export interface TrackPlayer extends HybridObject<{
     onPlaybackStateChange(callback: (state: TrackPlayerState, reason?: Reason) => void): void;
     onSeek(callback: (position: number, totalDuration: number) => void): void;
     onPlaybackProgressChange(callback: (position: number, totalDuration: number, isManuallySeeked?: boolean) => void): void;
+    /**
+     * Register callback for in-stream (timed) metadata — ICY/Shoutcast StreamTitle
+     * updates and ID3 frames emitted while a live stream plays.
+     */
+    onTimedMetadata(callback: (metadata: TimedMetadata) => void): void;
     onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
     isAndroidAutoConnected(): boolean;
     setVolume(volume: number): Promise<void>;

package/lib/types/PlayerQueue.d.ts

@@ -29,6 +29,13 @@ export interface PlayerState {
     currentIndex: number;
     currentPlayingType: CurrentPlayingType;
 }
+/** In-stream metadata emitted while a stream plays (ICY/Shoutcast StreamTitle, ID3 frames) */
+export interface TimedMetadata {
+    title?: string;
+    artist?: string;
+    album?: string;
+    artworkUrl?: string;
+}
 export interface PlayerConfig {
     androidAutoEnabled?: boolean;
     carPlayEnabled?: boolean;

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -35,6 +35,7 @@
 #include "JFunc_void_TrackPlayerState_std__optional_Reason_.hpp"
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
+#include "JFunc_void_TimedMetadata.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
 #include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
@@ -129,6 +130,7 @@ void registerAllNatives() {
   margelo::nitro::nitroplayer::JFunc_void_TrackPlayerState_std__optional_Reason__cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_double_double_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_double_double_std__optional_bool__cxx::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_TimedMetadata_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__double_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::registerNatives();
 

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

@@ -0,0 +1,79 @@
+///
+/// JFunc_void_TimedMetadata.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 <functional>
+
+#include "TimedMetadata.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTimedMetadata.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(metadata: TimedMetadata) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_TimedMetadata: public jni::JavaClass<JFunc_void_TimedMetadata> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TimedMetadata;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_TimedMetadata` instance holds through JNI.
+     */
+    void invoke(const TimedMetadata& metadata) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTimedMetadata> /* metadata */)>("invoke");
+      method(self(), JTimedMetadata::fromCpp(metadata));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_TimedMetadata that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_TimedMetadata_cxx final: public jni::HybridClass<JFunc_void_TimedMetadata_cxx, JFunc_void_TimedMetadata> {
+  public:
+    static jni::local_ref<JFunc_void_TimedMetadata::javaobject> fromCpp(const std::function<void(const TimedMetadata& /* metadata */)>& func) {
+      return JFunc_void_TimedMetadata_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_TimedMetadata_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTimedMetadata> metadata) {
+      _func(metadata->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const TimedMetadata& /* metadata */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TimedMetadata_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_TimedMetadata_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_TimedMetadata_cxx(const std::function<void(const TimedMetadata& /* metadata */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const TimedMetadata& /* metadata */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -21,6 +21,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 <NitroModules/JPromise.hpp>
@@ -55,6 +57,9 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "JFunc_void_TrackPlayerState_std__optional_Reason_.hpp"
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
+#include "TimedMetadata.hpp"
+#include "JFunc_void_TimedMetadata.hpp"
+#include "JTimedMetadata.hpp"
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
 #include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
@@ -320,6 +325,10 @@ namespace margelo::nitro::nitroplayer {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double_double_std__optional_bool_::javaobject> /* callback */)>("onPlaybackProgressChange_cxx");
     method(_javaPart, JFunc_void_double_double_std__optional_bool__cxx::fromCpp(callback));
   }
+  void JHybridTrackPlayerSpec::onTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TimedMetadata::javaobject> /* callback */)>("onTimedMetadata_cxx");
+    method(_javaPart, JFunc_void_TimedMetadata_cxx::fromCpp(callback));
+  }
   void JHybridTrackPlayerSpec::onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onAndroidAutoConnectionChange_cxx");
     method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));