react-native-nitro-player 0.0.1

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

@@ -0,0 +1,21 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Android Auto Media Library Manager
+ * Android-only HybridObject for managing Android Auto media browser structure
+ */
+export interface AndroidAutoMediaLibrary extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param libraryJson - JSON string of the MediaLibrary structure
+     */
+    setMediaLibrary(libraryJson: string): void;
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clearMediaLibrary(): void;
+}

package/lib/specs/AndroidAutoMediaLibrary.nitro.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export type TAudioDevice = {
+    id: number;
+    name: string;
+    type: number;
+    isActive: boolean;
+};
+export interface AudioDevices extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * Get the list of audio devices
+     *
+     * @returns The list of audio devices
+     */
+    getAudioDevices(): TAudioDevice[];
+    /**
+     * Set the audio device
+     *
+     * @param deviceId - The ID of the audio device
+     * @returns True if the audio device was set successfully, false otherwise
+     */
+    setAudioDevice(deviceId: number): boolean;
+}

package/lib/specs/AudioDevices.nitro.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface AudioRoutePicker extends HybridObject<{
+    ios: 'swift';
+}> {
+    /**
+     * Show the audio route picker view (iOS only)
+     * This presents a native AVRoutePickerView for selecting audio output devices like AirPlay
+     */
+    showRoutePicker(): void;
+}

package/lib/specs/AudioRoutePicker.nitro.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,39 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { QueueOperation, Reason, TrackItem, TrackPlayerState, PlayerState, PlayerConfig, Playlist } from '../types/PlayerQueue';
+export interface PlayerQueue extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createPlaylist(name: string, description?: string, artwork?: string): string;
+    deletePlaylist(playlistId: string): void;
+    updatePlaylist(playlistId: string, name?: string, description?: string, artwork?: string): void;
+    getPlaylist(playlistId: string): Playlist | null;
+    getAllPlaylists(): Playlist[];
+    addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): void;
+    addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): void;
+    removeTrackFromPlaylist(playlistId: string, trackId: string): void;
+    reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): void;
+    loadPlaylist(playlistId: string): void;
+    getCurrentPlaylistId(): string | null;
+    onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;
+    onPlaylistChanged(callback: (playlistId: string, playlist: Playlist, operation?: QueueOperation) => void): void;
+}
+export interface TrackPlayer extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    play(): void;
+    pause(): void;
+    playSong(songId: string, fromPlaylist?: string): void;
+    skipToNext(): void;
+    skipToPrevious(): void;
+    seek(position: number): void;
+    getState(): PlayerState;
+    configure(config: PlayerConfig): void;
+    onChangeTrack(callback: (track: TrackItem, reason?: Reason) => void): void;
+    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;
+    onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
+    isAndroidAutoConnected(): boolean;
+}

package/lib/specs/TrackPlayer.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/types/AndroidAutoMediaLibrary.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Layout type for the Android Auto media browser
+ */
+export type LayoutType = 'grid' | 'list';
+/**
+ * Media type for different kinds of content
+ */
+export type MediaType = 'folder' | 'audio' | 'playlist';
+/**
+ * Media item that can be displayed in Android Auto
+ */
+export interface MediaItem {
+    /** Unique identifier for the media item */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Optional subtitle/description */
+    subtitle?: string;
+    /** Optional icon/artwork URL */
+    iconUrl?: string;
+    /** Whether this item can be played directly */
+    isPlayable: boolean;
+    /** Media type */
+    mediaType: MediaType;
+    /** Reference to playlist ID (for playlist items) - will load tracks from this playlist */
+    playlistId?: string;
+    /** Child items for browsable folders */
+    children?: MediaItem[];
+    /** Layout type for folder items (overrides library default) */
+    layoutType?: LayoutType;
+}
+/**
+ * Media library structure for Android Auto
+ */
+export interface MediaLibrary {
+    /** Layout type for the media browser (applies to all folders by default) */
+    layoutType: LayoutType;
+    /** Root level media items */
+    rootItems: MediaItem[];
+    /** Optional app name to display */
+    appName?: string;
+    /** Optional app icon URL */
+    appIconUrl?: string;
+}

package/lib/types/AndroidAutoMediaLibrary.js

@@ -0,0 +1 @@
+export {};

package/lib/types/PlayerQueue.d.ts

@@ -0,0 +1,32 @@
+export interface TrackItem {
+    id: string;
+    title: string;
+    artist: string;
+    album: string;
+    duration: number;
+    url: string;
+    artwork?: string | null;
+}
+export interface Playlist {
+    id: string;
+    name: string;
+    description?: string | null;
+    artwork?: string | null;
+    tracks: TrackItem[];
+}
+export type QueueOperation = 'add' | 'remove' | 'clear' | 'update';
+export type TrackPlayerState = 'playing' | 'paused' | 'stopped';
+export type Reason = 'user_action' | 'skip' | 'end' | 'error';
+export interface PlayerState {
+    currentTrack: TrackItem | null;
+    currentPosition: number;
+    totalDuration: number;
+    currentState: TrackPlayerState;
+    currentPlaylistId: string | null;
+    currentIndex: number;
+}
+export interface PlayerConfig {
+    androidAutoEnabled?: boolean;
+    carPlayEnabled?: boolean;
+    showInNotification?: boolean;
+}

package/lib/types/PlayerQueue.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/androidAutoMediaLibrary.d.ts

@@ -0,0 +1,47 @@
+import type { MediaLibrary } from '../types/AndroidAutoMediaLibrary';
+/**
+ * Helper utilities for Android Auto Media Library
+ * Android-only functionality
+ */
+export declare const AndroidAutoMediaLibraryHelper: {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param library - The media library structure
+     *
+     * @example
+     * ```ts
+     * AndroidAutoMediaLibraryHelper.set({
+     *   layoutType: 'grid',
+     *   rootItems: [
+     *     {
+     *       id: 'my_music',
+     *       title: 'My Music',
+     *       mediaType: 'folder',
+     *       isPlayable: false,
+     *       children: [
+     *         {
+     *           id: 'favorites',
+     *           title: 'Favorites',
+     *           mediaType: 'playlist',
+     *           playlistId: 'favorites-playlist-id', // References a playlist created with PlayerQueue
+     *           isPlayable: false,
+     *         },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    set: (library: MediaLibrary) => void;
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clear: () => void;
+    /**
+     * Check if Android Auto Media Library is available (Android only)
+     */
+    isAvailable: () => boolean;
+};

package/lib/utils/androidAutoMediaLibrary.js

@@ -0,0 +1,62 @@
+import { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryModule } from '../index';
+/**
+ * Helper utilities for Android Auto Media Library
+ * Android-only functionality
+ */
+export const AndroidAutoMediaLibraryHelper = {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param library - The media library structure
+     *
+     * @example
+     * ```ts
+     * AndroidAutoMediaLibraryHelper.set({
+     *   layoutType: 'grid',
+     *   rootItems: [
+     *     {
+     *       id: 'my_music',
+     *       title: 'My Music',
+     *       mediaType: 'folder',
+     *       isPlayable: false,
+     *       children: [
+     *         {
+     *           id: 'favorites',
+     *           title: 'Favorites',
+     *           mediaType: 'playlist',
+     *           playlistId: 'favorites-playlist-id', // References a playlist created with PlayerQueue
+     *           isPlayable: false,
+     *         },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    set: (library) => {
+        if (!AndroidAutoMediaLibraryModule) {
+            console.warn('AndroidAutoMediaLibrary is only available on Android');
+            return;
+        }
+        const json = JSON.stringify(library);
+        AndroidAutoMediaLibraryModule.setMediaLibrary(json);
+    },
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clear: () => {
+        if (!AndroidAutoMediaLibraryModule) {
+            console.warn('AndroidAutoMediaLibrary is only available on Android');
+            return;
+        }
+        AndroidAutoMediaLibraryModule.clearMediaLibrary();
+    },
+    /**
+     * Check if Android Auto Media Library is available (Android only)
+     */
+    isAvailable: () => {
+        return AndroidAutoMediaLibraryModule !== null;
+    },
+};

package/nitro.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["nitroplayer"],
+  "ios": {
+    "iosModuleName": "NitroPlayer"
+  },
+  "android": {
+    "androidNamespace": ["nitroplayer"],
+    "androidCxxLibName": "NitroPlayer"
+  },
+  "autolinking": {
+    "PlayerQueue": {
+      "swift": "HybridPlayerQueue",
+      "kotlin": "HybridPlayerQueue"
+    },
+    "TrackPlayer": {
+      "swift": "HybridTrackPlayer",
+      "kotlin": "HybridTrackPlayer"
+    },
+    "AndroidAutoMediaLibrary": {
+      "kotlin": "HybridAndroidAutoMediaLibrary"
+    },
+    "AudioDevices": {
+      "kotlin": "HybridAudioDevices"
+    },
+    "AudioRoutePicker": {
+      "swift": "HybridAudioRoutePicker"
+    }
+  },
+  "ignorePaths": ["**/node_modules"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/NitroPlayer+autolinking.cmake

@@ -0,0 +1,91 @@
+#
+# NitroPlayer+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2026 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroPlayer+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROPLAYER_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroPlayer PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroPlayerOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAndroidAutoMediaLibrarySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAudioDevicesSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAudioRoutePickerSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPlayerQueueSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridAndroidAutoMediaLibrarySpec.cpp
+  ../nitrogen/generated/android/c++/JHybridAudioDevicesSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridPlayerQueueSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_Playlist.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_String.cpp
+  ../nitrogen/generated/android/c++/JHybridTrackPlayerSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_TrackItem.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NitroPlayer PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroPlayer
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroPlayer
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroPlayer
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroPlayer+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroPlayer+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroPlayer+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroPlayer is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -0,0 +1,88 @@
+///
+/// NitroPlayerOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROPLAYER_WITH_GENERATED_CMAKE_PROJECT
+#error NitroPlayerOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroPlayerOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridAndroidAutoMediaLibrarySpec.hpp"
+#include "JHybridAudioDevicesSpec.hpp"
+#include "JHybridPlayerQueueSpec.hpp"
+#include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"
+#include "JFunc_void_std__string_Playlist_std__optional_QueueOperation_.hpp"
+#include "JHybridTrackPlayerSpec.hpp"
+#include "JFunc_void_TrackItem_std__optional_Reason_.hpp"
+#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_bool.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitroplayer;
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    margelo::nitro::nitroplayer::JHybridAndroidAutoMediaLibrarySpec::registerNatives();
+    margelo::nitro::nitroplayer::JHybridAudioDevicesSpec::registerNatives();
+    margelo::nitro::nitroplayer::JHybridPlayerQueueSpec::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__vector_Playlist__std__optional_QueueOperation__cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__string_Playlist_std__optional_QueueOperation__cxx::registerNatives();
+    margelo::nitro::nitroplayer::JHybridTrackPlayerSpec::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_TrackItem_std__optional_Reason__cxx::registerNatives();
+    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_bool_cxx::registerNatives();
+
+    // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "PlayerQueue",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridPlayerQueueSpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridPlayerQueue");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "TrackPlayer",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridTrackPlayerSpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridTrackPlayer");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AndroidAutoMediaLibrary",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAndroidAutoMediaLibrarySpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrary");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AudioDevices",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAudioDevicesSpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridAudioDevices");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+  });
+}
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/NitroPlayerOnLoad.hpp

@@ -0,0 +1,25 @@
+///
+/// NitroPlayerOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * Initializes the native (C++) part of NitroPlayer, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return margelo::nitro::nitroplayer::initialize(vm);
+   * }
+   * ```
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,85 @@
+///
+/// JFunc_void_TrackItem_std__optional_Reason_.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "TrackItem.hpp"
+#include "Reason.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTrackItem.hpp"
+#include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JReason.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(track: TrackItem, reason: Reason?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_TrackItem_std__optional_Reason_: public jni::JavaClass<JFunc_void_TrackItem_std__optional_Reason_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TrackItem_std__optional_Reason_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_TrackItem_std__optional_Reason_` instance holds through JNI.
+     */
+    void invoke(const TrackItem& track, std::optional<Reason> reason) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTrackItem> /* track */, jni::alias_ref<JReason> /* reason */)>("invoke");
+      method(self(), JTrackItem::fromCpp(track), reason.has_value() ? JReason::fromCpp(reason.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_TrackItem_std__optional_Reason_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_TrackItem_std__optional_Reason__cxx final: public jni::HybridClass<JFunc_void_TrackItem_std__optional_Reason__cxx, JFunc_void_TrackItem_std__optional_Reason_> {
+  public:
+    static jni::local_ref<JFunc_void_TrackItem_std__optional_Reason_::javaobject> fromCpp(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& func) {
+      return JFunc_void_TrackItem_std__optional_Reason__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_TrackItem_std__optional_Reason__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTrackItem> track, jni::alias_ref<JReason> reason) {
+      _func(track->toCpp(), reason != nullptr ? std::make_optional(reason->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_TrackItem_std__optional_Reason__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_TrackItem_std__optional_Reason__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_TrackItem_std__optional_Reason__cxx(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer