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

package/lib/types/DownloadTypes.d.ts

@@ -0,0 +1,110 @@
+import type { TrackItem, Playlist } from './PlayerQueue';
+/**
+ * Storage location options for downloads
+ */
+export type StorageLocation = 'private' | 'public';
+/**
+ * Current state of a download task
+ */
+export type DownloadState = 'pending' | 'downloading' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Reason for download failure
+ */
+export type DownloadErrorReason = 'network_error' | 'storage_full' | 'file_not_found' | 'permission_denied' | 'invalid_url' | 'timeout' | 'unknown';
+/**
+ * Source preference for playback
+ */
+export type PlaybackSource = 'auto' | 'download' | 'network';
+/**
+ * Progress information for a download
+ */
+export interface DownloadProgress {
+    trackId: string;
+    downloadId: string;
+    bytesDownloaded: number;
+    totalBytes: number;
+    progress: number;
+    state: DownloadState;
+}
+/**
+ * Download error information
+ */
+export interface DownloadError {
+    code: string;
+    message: string;
+    reason: DownloadErrorReason;
+    isRetryable: boolean;
+}
+/**
+ * A downloaded track with local file information
+ */
+export interface DownloadedTrack {
+    trackId: string;
+    originalTrack: TrackItem;
+    localPath: string;
+    localArtworkPath?: string | null;
+    downloadedAt: number;
+    fileSize: number;
+    storageLocation: StorageLocation;
+}
+/**
+ * A playlist with download information
+ */
+export interface DownloadedPlaylist {
+    playlistId: string;
+    originalPlaylist: Playlist;
+    downloadedTracks: DownloadedTrack[];
+    totalSize: number;
+    downloadedAt: number;
+    isComplete: boolean;
+}
+/**
+ * Download task information
+ */
+export interface DownloadTask {
+    downloadId: string;
+    trackId: string;
+    playlistId?: string | null;
+    state: DownloadState;
+    progress: DownloadProgress;
+    createdAt: number;
+    startedAt?: number | null;
+    completedAt?: number | null;
+    error?: DownloadError | null;
+    retryCount: number;
+}
+/**
+ * Configuration for the DownloadManager
+ */
+export interface DownloadConfig {
+    storageLocation?: StorageLocation;
+    maxConcurrentDownloads?: number;
+    autoRetry?: boolean;
+    maxRetryAttempts?: number;
+    backgroundDownloadsEnabled?: boolean;
+    downloadArtwork?: boolean;
+    customDownloadPath?: string | null;
+    wifiOnlyDownloads?: boolean;
+}
+/**
+ * Summary of download storage usage
+ */
+export interface DownloadStorageInfo {
+    totalDownloadedSize: number;
+    trackCount: number;
+    playlistCount: number;
+    availableSpace: number;
+    totalSpace: number;
+}
+/**
+ * Download queue status
+ */
+export interface DownloadQueueStatus {
+    pendingCount: number;
+    activeCount: number;
+    completedCount: number;
+    failedCount: number;
+    totalBytesToDownload: number;
+    totalBytesDownloaded: number;
+    overallProgress: number;
+}

package/lib/types/DownloadTypes.js

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

package/lib/types/EqualizerTypes.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Represents a single equalizer frequency band
+ */
+export interface EqualizerBand {
+    /** Band index (0-4) */
+    index: number;
+    /** Center frequency in Hz */
+    centerFrequency: number;
+    /** Current gain in dB (-12 to +12) */
+    gainDb: number;
+    /** Human-readable frequency label (e.g., "60 Hz", "3.6 kHz") */
+    frequencyLabel: string;
+}
+/**
+ * Preset type identifier
+ */
+export type PresetType = 'built-in' | 'custom';
+/**
+ * Represents an equalizer preset (built-in or custom)
+ */
+export interface EqualizerPreset {
+    /** Unique preset name */
+    name: string;
+    /** Array of 5 gain values in dB for each band */
+    gains: number[];
+    /** Whether this is a built-in or custom preset */
+    type: PresetType;
+}
+/**
+ * Complete equalizer state
+ */
+export interface EqualizerState {
+    /** Whether equalizer is enabled */
+    enabled: boolean;
+    /** Current band settings */
+    bands: EqualizerBand[];
+    /** Currently applied preset name (null if custom values) */
+    currentPreset: string | null;
+}
+/**
+ * Gain range for equalizer bands
+ */
+export interface GainRange {
+    /** Minimum gain in dB */
+    min: number;
+    /** Maximum gain in dB */
+    max: number;
+}
+/**
+ * Built-in preset names
+ */
+export type BuiltInPresetName = 'Flat' | 'Bass Boost' | 'Bass Reducer' | 'Treble Boost' | 'Treble Reducer' | 'Vocal Boost' | 'Rock' | 'Pop' | 'Jazz' | 'Classical' | 'Hip Hop' | 'Electronic' | 'Acoustic' | 'R&B' | 'Loudness';

package/lib/types/EqualizerTypes.js

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

package/lib/types/PlayerQueue.d.ts

@@ -1,3 +1,5 @@
+import type { AnyMap } from 'react-native-nitro-modules';
+export type CurrentPlayingType = 'playlist' | 'up-next' | 'play-next' | 'not-playing';
 export interface TrackItem {
     id: string;
     title: string;
@@ -6,6 +8,7 @@ export interface TrackItem {
     duration: number;
     url: string;
     artwork?: string | null;
+    extraPayload?: AnyMap;
 }
 export interface Playlist {
     id: string;
@@ -24,6 +27,7 @@ export interface PlayerState {
     currentState: TrackPlayerState;
     currentPlaylistId: string | null;
     currentIndex: number;
+    currentPlayingType: CurrentPlayingType;
 }
 export interface PlayerConfig {
     androidAutoEnabled?: boolean;

package/nitro.json

@@ -25,6 +25,14 @@
     },
     "AudioRoutePicker": {
       "swift": "HybridAudioRoutePicker"
+    },
+    "DownloadManager": {
+      "swift": "HybridDownloadManager",
+      "kotlin": "HybridDownloadManager"
+    },
+    "Equalizer": {
+      "swift": "HybridEqualizer",
+      "kotlin": "HybridEqualizer"
     }
   },
   "ignorePaths": ["**/node_modules"]

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

@@ -36,14 +36,23 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridAndroidAutoMediaLibrarySpec.cpp
   ../nitrogen/generated/shared/c++/HybridAudioDevicesSpec.cpp
   ../nitrogen/generated/shared/c++/HybridAudioRoutePickerSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridDownloadManagerSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridEqualizerSpec.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++/JHybridDownloadManagerSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_String.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_DownloadTask.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_Double.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_DownloadError.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_DownloadedTrack.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_DownloadedPlaylist.cpp
+  ../nitrogen/generated/android/c++/JHybridEqualizerSpec.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
 )

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -17,6 +17,14 @@
 
 #include "JHybridAndroidAutoMediaLibrarySpec.hpp"
 #include "JHybridAudioDevicesSpec.hpp"
+#include "JHybridDownloadManagerSpec.hpp"
+#include "JFunc_void_DownloadProgress.hpp"
+#include "JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_.hpp"
+#include "JFunc_void_DownloadedTrack.hpp"
+#include "JHybridEqualizerSpec.hpp"
+#include "JFunc_void_bool.hpp"
+#include "JFunc_void_std__vector_EqualizerBand_.hpp"
+#include "JFunc_void_std__optional_std__variant_nitro__NullType__std__string__.hpp"
 #include "JHybridPlayerQueueSpec.hpp"
 #include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"
 #include "JFunc_void_std__string_Playlist_std__optional_QueueOperation_.hpp"
@@ -25,7 +33,6 @@
 #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 {
@@ -39,6 +46,14 @@ int initialize(JavaVM* vm) {
     // Register native JNI methods
     margelo::nitro::nitroplayer::JHybridAndroidAutoMediaLibrarySpec::registerNatives();
     margelo::nitro::nitroplayer::JHybridAudioDevicesSpec::registerNatives();
+    margelo::nitro::nitroplayer::JHybridDownloadManagerSpec::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_DownloadProgress_cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_DownloadedTrack_cxx::registerNatives();
+    margelo::nitro::nitroplayer::JHybridEqualizerSpec::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_bool_cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__vector_EqualizerBand__cxx::registerNatives();
+    margelo::nitro::nitroplayer::JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx::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();
@@ -47,7 +62,6 @@ int initialize(JavaVM* vm) {
     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(
@@ -82,6 +96,22 @@ int initialize(JavaVM* vm) {
         return instance->cthis()->shared();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "DownloadManager",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridDownloadManagerSpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridDownloadManager");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Equalizer",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridEqualizerSpec::javaobject> object("com/margelo/nitro/nitroplayer/HybridEqualizer");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
   });
 }
 

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

@@ -0,0 +1,65 @@
+///
+/// JCurrentPlayingType.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 "CurrentPlayingType.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CurrentPlayingType" and the the Kotlin enum "CurrentPlayingType".
+   */
+  struct JCurrentPlayingType final: public jni::JavaClass<JCurrentPlayingType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/CurrentPlayingType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CurrentPlayingType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CurrentPlayingType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CurrentPlayingType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCurrentPlayingType> fromCpp(CurrentPlayingType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPLAYLIST = clazz->getStaticField<JCurrentPlayingType>("PLAYLIST");
+      static const auto fieldUP_NEXT = clazz->getStaticField<JCurrentPlayingType>("UP_NEXT");
+      static const auto fieldPLAY_NEXT = clazz->getStaticField<JCurrentPlayingType>("PLAY_NEXT");
+      static const auto fieldNOT_PLAYING = clazz->getStaticField<JCurrentPlayingType>("NOT_PLAYING");
+      
+      switch (value) {
+        case CurrentPlayingType::PLAYLIST:
+          return clazz->getStaticFieldValue(fieldPLAYLIST);
+        case CurrentPlayingType::UP_NEXT:
+          return clazz->getStaticFieldValue(fieldUP_NEXT);
+        case CurrentPlayingType::PLAY_NEXT:
+          return clazz->getStaticFieldValue(fieldPLAY_NEXT);
+        case CurrentPlayingType::NOT_PLAYING:
+          return clazz->getStaticFieldValue(fieldNOT_PLAYING);
+        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++/JDownloadConfig.hpp

@@ -0,0 +1,92 @@
+///
+/// JDownloadConfig.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 "DownloadConfig.hpp"
+
+#include "JStorageLocation.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "StorageLocation.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DownloadConfig" and the the Kotlin data class "DownloadConfig".
+   */
+  struct JDownloadConfig final: public jni::JavaClass<JDownloadConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/DownloadConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DownloadConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldStorageLocation = clazz->getField<JStorageLocation>("storageLocation");
+      jni::local_ref<JStorageLocation> storageLocation = this->getFieldValue(fieldStorageLocation);
+      static const auto fieldMaxConcurrentDownloads = clazz->getField<jni::JDouble>("maxConcurrentDownloads");
+      jni::local_ref<jni::JDouble> maxConcurrentDownloads = this->getFieldValue(fieldMaxConcurrentDownloads);
+      static const auto fieldAutoRetry = clazz->getField<jni::JBoolean>("autoRetry");
+      jni::local_ref<jni::JBoolean> autoRetry = this->getFieldValue(fieldAutoRetry);
+      static const auto fieldMaxRetryAttempts = clazz->getField<jni::JDouble>("maxRetryAttempts");
+      jni::local_ref<jni::JDouble> maxRetryAttempts = this->getFieldValue(fieldMaxRetryAttempts);
+      static const auto fieldBackgroundDownloadsEnabled = clazz->getField<jni::JBoolean>("backgroundDownloadsEnabled");
+      jni::local_ref<jni::JBoolean> backgroundDownloadsEnabled = this->getFieldValue(fieldBackgroundDownloadsEnabled);
+      static const auto fieldDownloadArtwork = clazz->getField<jni::JBoolean>("downloadArtwork");
+      jni::local_ref<jni::JBoolean> downloadArtwork = this->getFieldValue(fieldDownloadArtwork);
+      static const auto fieldCustomDownloadPath = clazz->getField<JVariant_NullType_String>("customDownloadPath");
+      jni::local_ref<JVariant_NullType_String> customDownloadPath = this->getFieldValue(fieldCustomDownloadPath);
+      static const auto fieldWifiOnlyDownloads = clazz->getField<jni::JBoolean>("wifiOnlyDownloads");
+      jni::local_ref<jni::JBoolean> wifiOnlyDownloads = this->getFieldValue(fieldWifiOnlyDownloads);
+      return DownloadConfig(
+        storageLocation != nullptr ? std::make_optional(storageLocation->toCpp()) : std::nullopt,
+        maxConcurrentDownloads != nullptr ? std::make_optional(maxConcurrentDownloads->value()) : std::nullopt,
+        autoRetry != nullptr ? std::make_optional(static_cast<bool>(autoRetry->value())) : std::nullopt,
+        maxRetryAttempts != nullptr ? std::make_optional(maxRetryAttempts->value()) : std::nullopt,
+        backgroundDownloadsEnabled != nullptr ? std::make_optional(static_cast<bool>(backgroundDownloadsEnabled->value())) : std::nullopt,
+        downloadArtwork != nullptr ? std::make_optional(static_cast<bool>(downloadArtwork->value())) : std::nullopt,
+        customDownloadPath != nullptr ? std::make_optional(customDownloadPath->toCpp()) : std::nullopt,
+        wifiOnlyDownloads != nullptr ? std::make_optional(static_cast<bool>(wifiOnlyDownloads->value())) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDownloadConfig::javaobject> fromCpp(const DownloadConfig& value) {
+      using JSignature = JDownloadConfig(jni::alias_ref<JStorageLocation>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JVariant_NullType_String>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.storageLocation.has_value() ? JStorageLocation::fromCpp(value.storageLocation.value()) : nullptr,
+        value.maxConcurrentDownloads.has_value() ? jni::JDouble::valueOf(value.maxConcurrentDownloads.value()) : nullptr,
+        value.autoRetry.has_value() ? jni::JBoolean::valueOf(value.autoRetry.value()) : nullptr,
+        value.maxRetryAttempts.has_value() ? jni::JDouble::valueOf(value.maxRetryAttempts.value()) : nullptr,
+        value.backgroundDownloadsEnabled.has_value() ? jni::JBoolean::valueOf(value.backgroundDownloadsEnabled.value()) : nullptr,
+        value.downloadArtwork.has_value() ? jni::JBoolean::valueOf(value.downloadArtwork.value()) : nullptr,
+        value.customDownloadPath.has_value() ? JVariant_NullType_String::fromCpp(value.customDownloadPath.value()) : nullptr,
+        value.wifiOnlyDownloads.has_value() ? jni::JBoolean::valueOf(value.wifiOnlyDownloads.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,71 @@
+///
+/// JDownloadError.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 "DownloadError.hpp"
+
+#include "DownloadErrorReason.hpp"
+#include "JDownloadErrorReason.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DownloadError" and the the Kotlin data class "DownloadError".
+   */
+  struct JDownloadError final: public jni::JavaClass<JDownloadError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/DownloadError;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DownloadError by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadError toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCode = clazz->getField<jni::JString>("code");
+      jni::local_ref<jni::JString> code = this->getFieldValue(fieldCode);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      static const auto fieldReason = clazz->getField<JDownloadErrorReason>("reason");
+      jni::local_ref<JDownloadErrorReason> reason = this->getFieldValue(fieldReason);
+      static const auto fieldIsRetryable = clazz->getField<jboolean>("isRetryable");
+      jboolean isRetryable = this->getFieldValue(fieldIsRetryable);
+      return DownloadError(
+        code->toStdString(),
+        message->toStdString(),
+        reason->toCpp(),
+        static_cast<bool>(isRetryable)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDownloadError::javaobject> fromCpp(const DownloadError& value) {
+      using JSignature = JDownloadError(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JDownloadErrorReason>, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.code),
+        jni::make_jstring(value.message),
+        JDownloadErrorReason::fromCpp(value.reason),
+        value.isRetryable
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,74 @@
+///
+/// JDownloadErrorReason.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 "DownloadErrorReason.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "DownloadErrorReason" and the the Kotlin enum "DownloadErrorReason".
+   */
+  struct JDownloadErrorReason final: public jni::JavaClass<JDownloadErrorReason> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/DownloadErrorReason;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum DownloadErrorReason.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadErrorReason toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<DownloadErrorReason>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JDownloadErrorReason> fromCpp(DownloadErrorReason value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNETWORK_ERROR = clazz->getStaticField<JDownloadErrorReason>("NETWORK_ERROR");
+      static const auto fieldSTORAGE_FULL = clazz->getStaticField<JDownloadErrorReason>("STORAGE_FULL");
+      static const auto fieldFILE_NOT_FOUND = clazz->getStaticField<JDownloadErrorReason>("FILE_NOT_FOUND");
+      static const auto fieldPERMISSION_DENIED = clazz->getStaticField<JDownloadErrorReason>("PERMISSION_DENIED");
+      static const auto fieldINVALID_URL = clazz->getStaticField<JDownloadErrorReason>("INVALID_URL");
+      static const auto fieldTIMEOUT = clazz->getStaticField<JDownloadErrorReason>("TIMEOUT");
+      static const auto fieldUNKNOWN = clazz->getStaticField<JDownloadErrorReason>("UNKNOWN");
+      
+      switch (value) {
+        case DownloadErrorReason::NETWORK_ERROR:
+          return clazz->getStaticFieldValue(fieldNETWORK_ERROR);
+        case DownloadErrorReason::STORAGE_FULL:
+          return clazz->getStaticFieldValue(fieldSTORAGE_FULL);
+        case DownloadErrorReason::FILE_NOT_FOUND:
+          return clazz->getStaticFieldValue(fieldFILE_NOT_FOUND);
+        case DownloadErrorReason::PERMISSION_DENIED:
+          return clazz->getStaticFieldValue(fieldPERMISSION_DENIED);
+        case DownloadErrorReason::INVALID_URL:
+          return clazz->getStaticFieldValue(fieldINVALID_URL);
+        case DownloadErrorReason::TIMEOUT:
+          return clazz->getStaticFieldValue(fieldTIMEOUT);
+        case DownloadErrorReason::UNKNOWN:
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer