react-native-nitro-player 0.7.0 → 0.7.1-alpha.1

package/lib/types/EqualizerTypes.d.ts

@@ -2,7 +2,7 @@
  * Represents a single equalizer frequency band
  */
 export interface EqualizerBand {
-    /** Band index (0-4) */
+    /** Band index (0-9) */
     index: number;
     /** Center frequency in Hz */
     centerFrequency: number;
@@ -21,7 +21,7 @@ export type PresetType = 'built-in' | 'custom';
 export interface EqualizerPreset {
     /** Unique preset name */
     name: string;
-    /** Array of 5 gain values in dB for each band */
+    /** Array of 10 gain values in dB for each band */
     gains: number[];
     /** Whether this is a built-in or custom preset */
     type: PresetType;
@@ -49,4 +49,4 @@ export interface GainRange {
 /**
  * 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';
+export type BuiltInPresetName = 'Flat' | 'Rock' | 'Pop' | 'Classical' | 'Dance' | 'Techno' | 'Club' | 'Live' | 'Reggae' | 'Full Bass' | 'Full Treble' | 'Full Bass & Treble' | 'Large Hall' | 'Party' | 'Ska' | 'Soft' | 'Soft Rock' | 'Headphones' | 'Laptop Speakers';

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -34,6 +34,7 @@
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
+#include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::nitroplayer {
@@ -117,6 +118,7 @@ void registerAllNatives() {
   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_std__vector_TrackItem__double_cxx::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -0,0 +1,122 @@
+///
+/// JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.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 "TrackItem.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTrackItem.hpp"
+#include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_TrackItem__std__vector_TrackItem_: public jni::JavaClass<JFunc_void_std__vector_TrackItem__std__vector_TrackItem_> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__std__vector_TrackItem_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_TrackItem__std__vector_TrackItem_` instance holds through JNI.
+     */
+    void invoke(const std::vector<TrackItem>& playNextQueue, const std::vector<TrackItem>& upNextQueue) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* playNextQueue */, jni::alias_ref<jni::JArrayClass<JTrackItem>> /* upNextQueue */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = playNextQueue.size();
+        jni::local_ref<jni::JArrayClass<JTrackItem>> __array = jni::JArrayClass<JTrackItem>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = playNextQueue[__i];
+          auto __elementJni = JTrackItem::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }(), [&]() {
+        size_t __size = upNextQueue.size();
+        jni::local_ref<jni::JArrayClass<JTrackItem>> __array = jni::JArrayClass<JTrackItem>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = upNextQueue[__i];
+          auto __elementJni = JTrackItem::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_TrackItem__std__vector_TrackItem_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx final: public jni::HybridClass<JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx, JFunc_void_std__vector_TrackItem__std__vector_TrackItem_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_TrackItem__std__vector_TrackItem_::javaobject> fromCpp(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& func) {
+      return JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JTrackItem>> playNextQueue, jni::alias_ref<jni::JArrayClass<JTrackItem>> upNextQueue) {
+      _func([&]() {
+              size_t __size = playNextQueue->size();
+              std::vector<TrackItem> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = playNextQueue->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }(), [&]() {
+              size_t __size = upNextQueue->size();
+              std::vector<TrackItem> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = upNextQueue->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__std__vector_TrackItem__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -9,6 +9,9 @@
 
 
 
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
 #include <string>
 
 namespace margelo::nitro::nitroplayer {
@@ -44,13 +47,35 @@ namespace margelo::nitro::nitroplayer {
   
 
   // Methods
-  void JHybridAndroidAutoMediaLibrarySpec::setMediaLibrary(const std::string& libraryJson) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* libraryJson */)>("setMediaLibrary");
-    method(_javaPart, jni::make_jstring(libraryJson));
+  std::shared_ptr<Promise<void>> JHybridAndroidAutoMediaLibrarySpec::setMediaLibrary(const std::string& libraryJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* libraryJson */)>("setMediaLibrary");
+    auto __result = method(_javaPart, jni::make_jstring(libraryJson));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  void JHybridAndroidAutoMediaLibrarySpec::clearMediaLibrary() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("clearMediaLibrary");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridAndroidAutoMediaLibrarySpec::clearMediaLibrary() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearMediaLibrary");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
 
 } // namespace margelo::nitro::nitroplayer

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

@@ -54,8 +54,8 @@ namespace margelo::nitro::nitroplayer {
 
   public:
     // Methods
-    void setMediaLibrary(const std::string& libraryJson) override;
-    void clearMediaLibrary() override;
+    std::shared_ptr<Promise<void>> setMediaLibrary(const std::string& libraryJson) override;
+    std::shared_ptr<Promise<void>> clearMediaLibrary() override;
 
   private:
     jni::global_ref<JHybridAndroidAutoMediaLibrarySpec::JavaPart> _javaPart;

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

@@ -14,6 +14,9 @@ namespace margelo::nitro::nitroplayer { struct TAudioDevice; }
 #include <vector>
 #include "JTAudioDevice.hpp"
 #include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
 
 namespace margelo::nitro::nitroplayer {
 
@@ -62,10 +65,20 @@ namespace margelo::nitro::nitroplayer {
       return __vector;
     }();
   }
-  bool JHybridAudioDevicesSpec::setAudioDevice(double deviceId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(double /* deviceId */)>("setAudioDevice");
+  std::shared_ptr<Promise<void>> JHybridAudioDevicesSpec::setAudioDevice(double deviceId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* deviceId */)>("setAudioDevice");
     auto __result = method(_javaPart, deviceId);
-    return static_cast<bool>(__result);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
 
 } // namespace margelo::nitro::nitroplayer

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

@@ -55,7 +55,7 @@ namespace margelo::nitro::nitroplayer {
   public:
     // Methods
     std::vector<TAudioDevice> getAudioDevices() override;
-    bool setAudioDevice(double deviceId) override;
+    std::shared_ptr<Promise<void>> setAudioDevice(double deviceId) override;
 
   private:
     jni::global_ref<JHybridAudioDevicesSpec::JavaPart> _javaPart;

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

@@ -318,63 +318,151 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart, jni::make_jstring(trackId));
     return __result->toCpp();
   }
-  bool JHybridDownloadManagerSpec::isTrackDownloaded(const std::string& trackId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* trackId */)>("isTrackDownloaded");
+  std::shared_ptr<Promise<bool>> JHybridDownloadManagerSpec::isTrackDownloaded(const std::string& trackId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("isTrackDownloaded");
     auto __result = method(_javaPart, jni::make_jstring(trackId));
-    return static_cast<bool>(__result);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  bool JHybridDownloadManagerSpec::isPlaylistDownloaded(const std::string& playlistId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* playlistId */)>("isPlaylistDownloaded");
+  std::shared_ptr<Promise<bool>> JHybridDownloadManagerSpec::isPlaylistDownloaded(const std::string& playlistId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */)>("isPlaylistDownloaded");
     auto __result = method(_javaPart, jni::make_jstring(playlistId));
-    return static_cast<bool>(__result);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  bool JHybridDownloadManagerSpec::isPlaylistPartiallyDownloaded(const std::string& playlistId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* playlistId */)>("isPlaylistPartiallyDownloaded");
+  std::shared_ptr<Promise<bool>> JHybridDownloadManagerSpec::isPlaylistPartiallyDownloaded(const std::string& playlistId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */)>("isPlaylistPartiallyDownloaded");
     auto __result = method(_javaPart, jni::make_jstring(playlistId));
-    return static_cast<bool>(__result);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::variant<nitro::NullType, DownloadedTrack> JHybridDownloadManagerSpec::getDownloadedTrack(const std::string& trackId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_DownloadedTrack>(jni::alias_ref<jni::JString> /* trackId */)>("getDownloadedTrack");
+  std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedTrack>>> JHybridDownloadManagerSpec::getDownloadedTrack(const std::string& trackId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("getDownloadedTrack");
     auto __result = method(_javaPart, jni::make_jstring(trackId));
-    return __result->toCpp();
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, DownloadedTrack>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_DownloadedTrack>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::vector<DownloadedTrack> JHybridDownloadManagerSpec::getAllDownloadedTracks() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDownloadedTrack>>()>("getAllDownloadedTracks");
+  std::shared_ptr<Promise<std::vector<DownloadedTrack>>> JHybridDownloadManagerSpec::getAllDownloadedTracks() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAllDownloadedTracks");
     auto __result = method(_javaPart);
     return [&]() {
-      size_t __size = __result->size();
-      std::vector<DownloadedTrack> __vector;
-      __vector.reserve(__size);
-      for (size_t __i = 0; __i < __size; __i++) {
-        auto __element = __result->getElement(__i);
-        __vector.push_back(__element->toCpp());
-      }
-      return __vector;
+      auto __promise = Promise<std::vector<DownloadedTrack>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JDownloadedTrack>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<DownloadedTrack> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
     }();
   }
-  std::variant<nitro::NullType, DownloadedPlaylist> JHybridDownloadManagerSpec::getDownloadedPlaylist(const std::string& playlistId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_DownloadedPlaylist>(jni::alias_ref<jni::JString> /* playlistId */)>("getDownloadedPlaylist");
+  std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedPlaylist>>> JHybridDownloadManagerSpec::getDownloadedPlaylist(const std::string& playlistId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */)>("getDownloadedPlaylist");
     auto __result = method(_javaPart, jni::make_jstring(playlistId));
-    return __result->toCpp();
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, DownloadedPlaylist>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_DownloadedPlaylist>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
-  std::vector<DownloadedPlaylist> JHybridDownloadManagerSpec::getAllDownloadedPlaylists() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDownloadedPlaylist>>()>("getAllDownloadedPlaylists");
+  std::shared_ptr<Promise<std::vector<DownloadedPlaylist>>> JHybridDownloadManagerSpec::getAllDownloadedPlaylists() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAllDownloadedPlaylists");
     auto __result = method(_javaPart);
     return [&]() {
-      size_t __size = __result->size();
-      std::vector<DownloadedPlaylist> __vector;
-      __vector.reserve(__size);
-      for (size_t __i = 0; __i < __size; __i++) {
-        auto __element = __result->getElement(__i);
-        __vector.push_back(__element->toCpp());
-      }
-      return __vector;
+      auto __promise = Promise<std::vector<DownloadedPlaylist>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JDownloadedPlaylist>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<DownloadedPlaylist> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
     }();
   }
-  std::variant<nitro::NullType, std::string> JHybridDownloadManagerSpec::getLocalPath(const std::string& trackId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_String>(jni::alias_ref<jni::JString> /* trackId */)>("getLocalPath");
+  std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> JHybridDownloadManagerSpec::getLocalPath(const std::string& trackId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("getLocalPath");
     auto __result = method(_javaPart, jni::make_jstring(trackId));
-    return __result->toCpp();
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, std::string>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_String>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   std::shared_ptr<Promise<void>> JHybridDownloadManagerSpec::deleteDownloadedTrack(const std::string& trackId) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("deleteDownloadedTrack");
@@ -437,10 +525,21 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
-  double JHybridDownloadManagerSpec::syncDownloads() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("syncDownloads");
+  std::shared_ptr<Promise<double>> JHybridDownloadManagerSpec::syncDownloads() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("syncDownloads");
     auto __result = method(_javaPart);
-    return __result;
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   void JHybridDownloadManagerSpec::setPlaybackSourcePreference(PlaybackSource preference) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JPlaybackSource> /* preference */)>("setPlaybackSourcePreference");
@@ -451,10 +550,21 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
-  std::string JHybridDownloadManagerSpec::getEffectiveUrl(const TrackItem& track) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JTrackItem> /* track */)>("getEffectiveUrl");
+  std::shared_ptr<Promise<std::string>> JHybridDownloadManagerSpec::getEffectiveUrl(const TrackItem& track) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTrackItem> /* track */)>("getEffectiveUrl");
     auto __result = method(_javaPart, JTrackItem::fromCpp(track));
-    return __result->toStdString();
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   void JHybridDownloadManagerSpec::onDownloadProgress(const std::function<void(const DownloadProgress& /* progress */)>& callback) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_DownloadProgress::javaobject> /* callback */)>("onDownloadProgress_cxx");

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

@@ -70,22 +70,22 @@ namespace margelo::nitro::nitroplayer {
     DownloadQueueStatus getQueueStatus() override;
     bool isDownloading(const std::string& trackId) override;
     DownloadState getDownloadState(const std::string& trackId) override;
-    bool isTrackDownloaded(const std::string& trackId) override;
-    bool isPlaylistDownloaded(const std::string& playlistId) override;
-    bool isPlaylistPartiallyDownloaded(const std::string& playlistId) override;
-    std::variant<nitro::NullType, DownloadedTrack> getDownloadedTrack(const std::string& trackId) override;
-    std::vector<DownloadedTrack> getAllDownloadedTracks() override;
-    std::variant<nitro::NullType, DownloadedPlaylist> getDownloadedPlaylist(const std::string& playlistId) override;
-    std::vector<DownloadedPlaylist> getAllDownloadedPlaylists() override;
-    std::variant<nitro::NullType, std::string> getLocalPath(const std::string& trackId) override;
+    std::shared_ptr<Promise<bool>> isTrackDownloaded(const std::string& trackId) override;
+    std::shared_ptr<Promise<bool>> isPlaylistDownloaded(const std::string& playlistId) override;
+    std::shared_ptr<Promise<bool>> isPlaylistPartiallyDownloaded(const std::string& playlistId) override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedTrack>>> getDownloadedTrack(const std::string& trackId) override;
+    std::shared_ptr<Promise<std::vector<DownloadedTrack>>> getAllDownloadedTracks() override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, DownloadedPlaylist>>> getDownloadedPlaylist(const std::string& playlistId) override;
+    std::shared_ptr<Promise<std::vector<DownloadedPlaylist>>> getAllDownloadedPlaylists() override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getLocalPath(const std::string& trackId) override;
     std::shared_ptr<Promise<void>> deleteDownloadedTrack(const std::string& trackId) override;
     std::shared_ptr<Promise<void>> deleteDownloadedPlaylist(const std::string& playlistId) override;
     std::shared_ptr<Promise<void>> deleteAllDownloads() override;
     std::shared_ptr<Promise<DownloadStorageInfo>> getStorageInfo() override;
-    double syncDownloads() override;
+    std::shared_ptr<Promise<double>> syncDownloads() override;
     void setPlaybackSourcePreference(PlaybackSource preference) override;
     PlaybackSource getPlaybackSourcePreference() override;
-    std::string getEffectiveUrl(const TrackItem& track) override;
+    std::shared_ptr<Promise<std::string>> getEffectiveUrl(const TrackItem& track) override;
     void onDownloadProgress(const std::function<void(const DownloadProgress& /* progress */)>& callback) override;
     void onDownloadStateChange(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& callback) override;
     void onDownloadComplete(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& callback) override;