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

package/ios/playlist/PlaylistManager.swift

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

package/ios/queue/HybridPlayerQueue.swift

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

package/lib/hooks/callbackManager.d.ts

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

package/lib/hooks/callbackManager.js

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

package/lib/index.js

@@ -1,6 +1,10 @@
 // TODO: Export all HybridObjects here for the user
 import { NitroModules } from 'react-native-nitro-modules';
-import { Platform } from 'react-native';
+import { AppRegistry, Platform } from 'react-native';
+// Native runs this while it needs JS without a resumed activity (car, screen off): it keeps JS timers ticking
+if (Platform.OS === 'android') {
+    AppRegistry.registerHeadlessTask('NitroPlayerKeepAlive', () => () => new Promise(() => { }));
+}
 export const PlayerQueue = NitroModules.createHybridObject('PlayerQueue');
 export const TrackPlayer = NitroModules.createHybridObject('TrackPlayer');
 // Android-only: Android Auto Media Library

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

@@ -18,4 +18,16 @@ export interface AndroidAutoMediaLibrary extends HybridObject<{
      * Falls back to showing all playlists
      */
     clearMediaLibrary(): Promise<void>;
+    /** Android Auto opened a folder published with `children: []`; answer with {@link resolveRequest}. */
+    onLoadChildren(callback: (requestId: string, parentId: string) => void): void;
+    /** A car search, or a voice request the loaded playlists cannot match; answer with {@link resolveRequest}. */
+    onSearch(callback: (requestId: string, query: string) => void): void;
+    /** Answers {@link onLoadChildren} / {@link onSearch} with a JSON array of MediaItem. */
+    resolveRequest(requestId: string, itemsJson: string): void;
+    /** Replaces the session buttons with a JSON array of SessionButton. */
+    setSessionButtons(buttonsJson: string): void;
+    /** Called with the button's `action` when a session button is pressed. */
+    onSessionButtonPress(callback: (action: string) => void): void;
+    /** A controller asked to play with nothing loaded (car auto-play, play on connect); load the last queue now. */
+    onPlaybackResumption(callback: () => void): void;
 }

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

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

package/lib/types/AndroidAutoMediaLibrary.d.ts

@@ -28,6 +28,8 @@ export interface MediaItem {
     children?: MediaItem[];
     /** Layout type for folder items (overrides library default) */
     layoutType?: LayoutType;
+    /** Group header; contiguous items sharing one are listed under it */
+    groupTitle?: string;
 }
 /**
  * Media library structure for Android Auto
@@ -42,3 +44,12 @@ export interface MediaLibrary {
     /** Optional app icon URL */
     appIconUrl?: string;
 }
+export type SessionButtonIcon = 'heart' | 'heart_filled' | 'star' | 'star_filled' | 'thumb_up' | 'thumb_up_filled' | 'plus' | 'check';
+/** App-defined button beside the transport controls in Android Auto and the notification */
+export interface SessionButton {
+    /** Passed to the press callback */
+    action: string;
+    /** Accessibility label */
+    title: string;
+    icon: SessionButtonIcon;
+}

package/lib/types/PlayerQueue.d.ts

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

package/lib/utils/androidAutoMediaLibrary.d.ts

@@ -1,4 +1,5 @@
-import type { MediaLibrary } from '../types/AndroidAutoMediaLibrary';
+import type { MediaItem, MediaLibrary, SessionButton } from '../types/AndroidAutoMediaLibrary';
+type ItemsProvider = (argument: string) => Promise<MediaItem[] | null | undefined>;
 /**
  * Helper utilities for Android Auto Media Library
  * Android-only functionality
@@ -40,8 +41,19 @@ export declare const AndroidAutoMediaLibraryHelper: {
      * Falls back to showing all playlists
      */
     clear: () => void;
+    /** Children of folders published with `children: []`; playable ids are `${playlistId}:${trackId}`, empty after 10s. Register at module scope: the car can start the app without UI. */
+    setChildrenLoader: (loader: ItemsProvider) => void;
+    /** Answers car searches and unmatched voice requests (first playable result plays); search shows from the next connection. */
+    setSearchHandler: (handler: ItemsProvider) => void;
+    /** Buttons beside the transport controls in Android Auto and the notification; call again to change their state. */
+    setSessionButtons: (buttons: SessionButton[]) => void;
+    /** Called with the pressed button's `action`. */
+    onSessionButtonPress: (callback: (action: string) => void) => void;
+    /** Car auto-play or play-on-connect found nothing loaded: restore your last queue (playback starts once it is loaded). */
+    onPlaybackResumption: (callback: () => void) => void;
     /**
      * Check if Android Auto Media Library is available (Android only)
      */
     isAvailable: () => boolean;
 };
+export {};

package/lib/utils/androidAutoMediaLibrary.js

@@ -1,4 +1,7 @@
 import { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryModule } from '../index';
+const answer = (requestId, provide) => provide()
+    .catch(() => null)
+    .then((items) => AndroidAutoMediaLibraryModule?.resolveRequest(requestId, JSON.stringify(items ?? [])));
 /**
  * Helper utilities for Android Auto Media Library
  * Android-only functionality
@@ -53,6 +56,26 @@ export const AndroidAutoMediaLibraryHelper = {
         }
         AndroidAutoMediaLibraryModule.clearMediaLibrary();
     },
+    /** Children of folders published with `children: []`; playable ids are `${playlistId}:${trackId}`, empty after 10s. Register at module scope: the car can start the app without UI. */
+    setChildrenLoader: (loader) => {
+        AndroidAutoMediaLibraryModule?.onLoadChildren((requestId, parentId) => answer(requestId, () => loader(parentId)));
+    },
+    /** Answers car searches and unmatched voice requests (first playable result plays); search shows from the next connection. */
+    setSearchHandler: (handler) => {
+        AndroidAutoMediaLibraryModule?.onSearch((requestId, query) => answer(requestId, () => handler(query)));
+    },
+    /** Buttons beside the transport controls in Android Auto and the notification; call again to change their state. */
+    setSessionButtons: (buttons) => {
+        AndroidAutoMediaLibraryModule?.setSessionButtons(JSON.stringify(buttons));
+    },
+    /** Called with the pressed button's `action`. */
+    onSessionButtonPress: (callback) => {
+        AndroidAutoMediaLibraryModule?.onSessionButtonPress(callback);
+    },
+    /** Car auto-play or play-on-connect found nothing loaded: restore your last queue (playback starts once it is loaded). */
+    onPlaybackResumption: (callback) => {
+        AndroidAutoMediaLibraryModule?.onPlaybackResumption(callback);
+    },
     /**
      * Check if Android Auto Media Library is available (Android only)
      */

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -16,6 +16,9 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridAndroidAutoMediaLibrarySpec.hpp"
+#include "JFunc_void_std__string_std__string.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "JFunc_void.hpp"
 #include "JHybridAudioDevicesSpec.hpp"
 #include "JHybridCastSpec.hpp"
 #include "JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__.hpp"
@@ -112,6 +115,9 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::nitroplayer::JHybridAndroidAutoMediaLibrarySpec::CxxPart::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_std__string_std__string_cxx::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_std__string_cxx::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_cxx::registerNatives();
   margelo::nitro::nitroplayer::JHybridAudioDevicesSpec::CxxPart::registerNatives();
   margelo::nitro::nitroplayer::JHybridCastSpec::CxxPart::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx::registerNatives();

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

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

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

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

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

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