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

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

@@ -57,6 +57,7 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include "JFunc_void_double_double_std__optional_bool_.hpp"
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__vector_TrackItem__double.hpp"
+#include "JFunc_void_std__vector_TrackItem__std__vector_TrackItem_.hpp"
 
 namespace margelo::nitro::nitroplayer {
 
@@ -91,13 +92,35 @@ namespace margelo::nitro::nitroplayer {
   
 
   // Methods
-  void JHybridTrackPlayerSpec::play() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("play");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::play() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("play");
+    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;
+    }();
   }
-  void JHybridTrackPlayerSpec::pause() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("pause");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::pause() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pause");
+    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;
+    }();
   }
   std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* songId */, jni::alias_ref<jni::JString> /* fromPlaylist */)>("playSong");
@@ -114,9 +137,20 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
-  void JHybridTrackPlayerSpec::skipToNext() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("skipToNext");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::skipToNext() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("skipToNext");
+    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;
+    }();
   }
   std::shared_ptr<Promise<bool>> JHybridTrackPlayerSpec::skipToIndex(double index) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* index */)>("skipToIndex");
@@ -134,13 +168,35 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
-  void JHybridTrackPlayerSpec::skipToPrevious() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("skipToPrevious");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::skipToPrevious() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("skipToPrevious");
+    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;
+    }();
   }
-  void JHybridTrackPlayerSpec::seek(double position) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* position */)>("seek");
-    method(_javaPart, position);
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::seek(double position) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* position */)>("seek");
+    auto __result = method(_javaPart, position);
+    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;
+    }();
   }
   std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::addToUpNext(const std::string& trackId) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("addToUpNext");
@@ -213,19 +269,40 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
-  bool JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");
     auto __result = method(_javaPart, JRepeatMode::fromCpp(mode));
-    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;
+    }();
   }
   RepeatMode JHybridTrackPlayerSpec::getRepeatMode() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JRepeatMode>()>("getRepeatMode");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
-  void JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
-    method(_javaPart, JPlayerConfig::fromCpp(config));
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
+    auto __result = method(_javaPart, JPlayerConfig::fromCpp(config));
+    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 JHybridTrackPlayerSpec::onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_TrackItem_std__optional_Reason_::javaobject> /* callback */)>("onChangeTrack_cxx");
@@ -252,10 +329,20 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
-  bool JHybridTrackPlayerSpec::setVolume(double volume) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(double /* volume */)>("setVolume");
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setVolume(double volume) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* volume */)>("setVolume");
     auto __result = method(_javaPart, volume);
-    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;
+    }();
   }
   std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::updateTracks(const std::vector<TrackItem>& tracks) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */)>("updateTracks");
@@ -416,5 +503,137 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<bool>> JHybridTrackPlayerSpec::removeFromPlayNext(const std::string& trackId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("removeFromPlayNext");
+    auto __result = method(_javaPart, jni::make_jstring(trackId));
+    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::shared_ptr<Promise<bool>> JHybridTrackPlayerSpec::removeFromUpNext(const std::string& trackId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */)>("removeFromUpNext");
+    auto __result = method(_javaPart, jni::make_jstring(trackId));
+    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::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::clearPlayNext() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearPlayNext");
+    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;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::clearUpNext() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearUpNext");
+    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;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridTrackPlayerSpec::reorderTemporaryTrack(const std::string& trackId, double newIndex) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* trackId */, double /* newIndex */)>("reorderTemporaryTrack");
+    auto __result = method(_javaPart, jni::make_jstring(trackId), newIndex);
+    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::shared_ptr<Promise<std::vector<TrackItem>>> JHybridTrackPlayerSpec::getPlayNextQueue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getPlayNextQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<TrackItem>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JTrackItem>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<TrackItem> __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::shared_ptr<Promise<std::vector<TrackItem>>> JHybridTrackPlayerSpec::getUpNextQueue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getUpNextQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<TrackItem>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JTrackItem>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<TrackItem> __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;
+    }();
+  }
+  void JHybridTrackPlayerSpec::onTemporaryQueueChange(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_TrackItem__std__vector_TrackItem_::javaobject> /* callback */)>("onTemporaryQueueChange_cxx");
+    method(_javaPart, JFunc_void_std__vector_TrackItem__std__vector_TrackItem__cxx::fromCpp(callback));
+  }
 
 } // namespace margelo::nitro::nitroplayer

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

@@ -54,27 +54,27 @@ namespace margelo::nitro::nitroplayer {
 
   public:
     // Methods
-    void play() override;
-    void pause() override;
+    std::shared_ptr<Promise<void>> play() override;
+    std::shared_ptr<Promise<void>> pause() override;
     std::shared_ptr<Promise<void>> playSong(const std::string& songId, const std::optional<std::string>& fromPlaylist) override;
-    void skipToNext() override;
+    std::shared_ptr<Promise<void>> skipToNext() override;
     std::shared_ptr<Promise<bool>> skipToIndex(double index) override;
-    void skipToPrevious() override;
-    void seek(double position) override;
+    std::shared_ptr<Promise<void>> skipToPrevious() override;
+    std::shared_ptr<Promise<void>> seek(double position) override;
     std::shared_ptr<Promise<void>> addToUpNext(const std::string& trackId) override;
     std::shared_ptr<Promise<void>> playNext(const std::string& trackId) override;
     std::shared_ptr<Promise<std::vector<TrackItem>>> getActualQueue() override;
     std::shared_ptr<Promise<PlayerState>> getState() override;
-    bool setRepeatMode(RepeatMode mode) override;
+    std::shared_ptr<Promise<void>> setRepeatMode(RepeatMode mode) override;
     RepeatMode getRepeatMode() override;
-    void configure(const PlayerConfig& config) override;
+    std::shared_ptr<Promise<void>> configure(const PlayerConfig& config) override;
     void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override;
     void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) override;
     void onSeek(const std::function<void(double /* position */, double /* totalDuration */)>& callback) override;
     void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override;
     void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
     bool isAndroidAutoConnected() override;
-    bool setVolume(double volume) override;
+    std::shared_ptr<Promise<void>> setVolume(double volume) override;
     std::shared_ptr<Promise<void>> updateTracks(const std::vector<TrackItem>& tracks) override;
     std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksById(const std::vector<std::string>& trackIds) override;
     std::shared_ptr<Promise<std::vector<TrackItem>>> getTracksNeedingUrls() override;
@@ -83,6 +83,14 @@ namespace margelo::nitro::nitroplayer {
     void onTracksNeedUpdate(const std::function<void(const std::vector<TrackItem>& /* tracks */, double /* lookahead */)>& callback) override;
     std::shared_ptr<Promise<void>> setPlaybackSpeed(double speed) override;
     std::shared_ptr<Promise<double>> getPlaybackSpeed() override;
+    std::shared_ptr<Promise<bool>> removeFromPlayNext(const std::string& trackId) override;
+    std::shared_ptr<Promise<bool>> removeFromUpNext(const std::string& trackId) override;
+    std::shared_ptr<Promise<void>> clearPlayNext() override;
+    std::shared_ptr<Promise<void>> clearUpNext() override;
+    std::shared_ptr<Promise<bool>> reorderTemporaryTrack(const std::string& trackId, double newIndex) override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getPlayNextQueue() override;
+    std::shared_ptr<Promise<std::vector<TrackItem>>> getUpNextQueue() override;
+    void onTemporaryQueueChange(const std::function<void(const std::vector<TrackItem>& /* playNextQueue */, const std::vector<TrackItem>& /* upNextQueue */)>& callback) override;
 
   private:
     jni::global_ref<JHybridTrackPlayerSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/Func_void_std__vector_TrackItem__std__vector_TrackItem_.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_std__vector_TrackItem__std__vector_TrackItem_.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(playNextQueue: array, upNextQueue: array) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__vector_TrackItem__std__vector_TrackItem_: (Array<TrackItem>, Array<TrackItem>) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(playNextQueue: array, upNextQueue: array) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__vector_TrackItem__std__vector_TrackItem__cxx: Func_void_std__vector_TrackItem__std__vector_TrackItem_ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>): Unit
+    = invoke_cxx(playNextQueue,upNextQueue)
+
+  @FastNative
+  private external fun invoke_cxx(playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(playNextQueue: array, upNextQueue: array) => void`.
+ * This is implemented in Java/Kotlin, via a `(Array<TrackItem>, Array<TrackItem>) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__vector_TrackItem__std__vector_TrackItem__java(private val function: (Array<TrackItem>, Array<TrackItem>) -> Unit): Func_void_std__vector_TrackItem__std__vector_TrackItem_ {
+  @DoNotStrip
+  @Keep
+  override fun invoke(playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>): Unit {
+    return this.function(playNextQueue, upNextQueue)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrarySpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.nitroplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -30,11 +31,11 @@ abstract class HybridAndroidAutoMediaLibrarySpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun setMediaLibrary(libraryJson: String): Unit
+  abstract fun setMediaLibrary(libraryJson: String): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  abstract fun clearMediaLibrary(): Unit
+  abstract fun clearMediaLibrary(): Promise<Unit>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridAudioDevicesSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.nitroplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -34,7 +35,7 @@ abstract class HybridAudioDevicesSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun setAudioDevice(deviceId: Double): Boolean
+  abstract fun setAudioDevice(deviceId: Double): Promise<Unit>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridDownloadManagerSpec.kt

@@ -96,35 +96,35 @@ abstract class HybridDownloadManagerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun isTrackDownloaded(trackId: String): Boolean
+  abstract fun isTrackDownloaded(trackId: String): Promise<Boolean>
   
   @DoNotStrip
   @Keep
-  abstract fun isPlaylistDownloaded(playlistId: String): Boolean
+  abstract fun isPlaylistDownloaded(playlistId: String): Promise<Boolean>
   
   @DoNotStrip
   @Keep
-  abstract fun isPlaylistPartiallyDownloaded(playlistId: String): Boolean
+  abstract fun isPlaylistPartiallyDownloaded(playlistId: String): Promise<Boolean>
   
   @DoNotStrip
   @Keep
-  abstract fun getDownloadedTrack(trackId: String): Variant_NullType_DownloadedTrack
+  abstract fun getDownloadedTrack(trackId: String): Promise<Variant_NullType_DownloadedTrack>
   
   @DoNotStrip
   @Keep
-  abstract fun getAllDownloadedTracks(): Array<DownloadedTrack>
+  abstract fun getAllDownloadedTracks(): Promise<Array<DownloadedTrack>>
   
   @DoNotStrip
   @Keep
-  abstract fun getDownloadedPlaylist(playlistId: String): Variant_NullType_DownloadedPlaylist
+  abstract fun getDownloadedPlaylist(playlistId: String): Promise<Variant_NullType_DownloadedPlaylist>
   
   @DoNotStrip
   @Keep
-  abstract fun getAllDownloadedPlaylists(): Array<DownloadedPlaylist>
+  abstract fun getAllDownloadedPlaylists(): Promise<Array<DownloadedPlaylist>>
   
   @DoNotStrip
   @Keep
-  abstract fun getLocalPath(trackId: String): Variant_NullType_String
+  abstract fun getLocalPath(trackId: String): Promise<Variant_NullType_String>
   
   @DoNotStrip
   @Keep
@@ -144,7 +144,7 @@ abstract class HybridDownloadManagerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun syncDownloads(): Double
+  abstract fun syncDownloads(): Promise<Double>
   
   @DoNotStrip
   @Keep
@@ -156,7 +156,7 @@ abstract class HybridDownloadManagerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getEffectiveUrl(track: TrackItem): String
+  abstract fun getEffectiveUrl(track: TrackItem): Promise<String>
   
   abstract fun onDownloadProgress(callback: (progress: DownloadProgress) -> Unit): Unit
   

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridEqualizerSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.nitroplayer
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.HybridObject
 
@@ -31,7 +32,7 @@ abstract class HybridEqualizerSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun setEnabled(enabled: Boolean): Boolean
+  abstract fun setEnabled(enabled: Boolean): Promise<Unit>
   
   @DoNotStrip
   @Keep
@@ -39,15 +40,15 @@ abstract class HybridEqualizerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getBands(): Array<EqualizerBand>
+  abstract fun getBands(): Promise<Array<EqualizerBand>>
   
   @DoNotStrip
   @Keep
-  abstract fun setBandGain(bandIndex: Double, gainDb: Double): Boolean
+  abstract fun setBandGain(bandIndex: Double, gainDb: Double): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  abstract fun setAllBandGains(gains: DoubleArray): Boolean
+  abstract fun setAllBandGains(gains: DoubleArray): Promise<Unit>
   
   @DoNotStrip
   @Keep
@@ -67,7 +68,7 @@ abstract class HybridEqualizerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun applyPreset(presetName: String): Boolean
+  abstract fun applyPreset(presetName: String): Promise<Unit>
   
   @DoNotStrip
   @Keep
@@ -75,19 +76,19 @@ abstract class HybridEqualizerSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun saveCustomPreset(name: String): Boolean
+  abstract fun saveCustomPreset(name: String): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  abstract fun deleteCustomPreset(name: String): Boolean
+  abstract fun deleteCustomPreset(name: String): Promise<Unit>
   
   @DoNotStrip
   @Keep
-  abstract fun getState(): EqualizerState
+  abstract fun getState(): Promise<EqualizerState>
   
   @DoNotStrip
   @Keep
-  abstract fun reset(): Unit
+  abstract fun reset(): Promise<Unit>
   
   abstract fun onEnabledChange(callback: (enabled: Boolean) -> Unit): Unit