react-native-nitro-player 1.4.4-alpha.0 → 1.5.0-alpha.1

package/nitro.json

@@ -47,6 +47,16 @@
         "implementationClassName": "HybridAudioRoutePicker"
       }
     },
+    "Cast": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridCast"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridCast"
+      }
+    },
     "DownloadManager": {
       "ios": {
         "language": "swift",

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

@@ -36,6 +36,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridAndroidAutoMediaLibrarySpec.cpp
   ../nitrogen/generated/shared/c++/HybridAudioDevicesSpec.cpp
   ../nitrogen/generated/shared/c++/HybridAudioRoutePickerSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridCastSpec.cpp
   ../nitrogen/generated/shared/c++/HybridDownloadManagerSpec.cpp
   ../nitrogen/generated/shared/c++/HybridEqualizerSpec.cpp
   ../nitrogen/generated/shared/c++/HybridPlayerQueueSpec.cpp
@@ -43,8 +44,9 @@ target_sources(
   # 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++/JHybridCastSpec.cpp
   ../nitrogen/generated/android/c++/JVariant_NullType_String.cpp
+  ../nitrogen/generated/android/c++/JHybridDownloadManagerSpec.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

package/nitrogen/generated/android/NitroPlayerOnLoad.cpp

@@ -17,6 +17,8 @@
 
 #include "JHybridAndroidAutoMediaLibrarySpec.hpp"
 #include "JHybridAudioDevicesSpec.hpp"
+#include "JHybridCastSpec.hpp"
+#include "JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__.hpp"
 #include "JHybridDownloadManagerSpec.hpp"
 #include "JFunc_void_DownloadProgress.hpp"
 #include "JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_.hpp"
@@ -77,6 +79,14 @@ struct JHybridAudioDevicesSpecImpl: public jni::JavaClass<JHybridAudioDevicesSpe
     return javaPart->getJHybridAudioDevicesSpec();
   }
 };
+struct JHybridCastSpecImpl: public jni::JavaClass<JHybridCastSpecImpl, JHybridCastSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridCast;";
+  static std::shared_ptr<JHybridCastSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridCastSpecImpl::javaobject()>();
+    jni::local_ref<JHybridCastSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridCastSpec();
+  }
+};
 struct JHybridDownloadManagerSpecImpl: public jni::JavaClass<JHybridDownloadManagerSpecImpl, JHybridDownloadManagerSpec::JavaPart> {
   static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridDownloadManager;";
   static std::shared_ptr<JHybridDownloadManagerSpec> create() {
@@ -101,6 +111,8 @@ void registerAllNatives() {
   // Register native JNI methods
   margelo::nitro::nitroplayer::JHybridAndroidAutoMediaLibrarySpec::CxxPart::registerNatives();
   margelo::nitro::nitroplayer::JHybridAudioDevicesSpec::CxxPart::registerNatives();
+  margelo::nitro::nitroplayer::JHybridCastSpec::CxxPart::registerNatives();
+  margelo::nitro::nitroplayer::JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx::registerNatives();
   margelo::nitro::nitroplayer::JHybridDownloadManagerSpec::CxxPart::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_DownloadProgress_cxx::registerNatives();
   margelo::nitro::nitroplayer::JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx::registerNatives();
@@ -145,6 +157,12 @@ void registerAllNatives() {
       return JHybridAudioDevicesSpecImpl::create();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cast",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridCastSpecImpl::create();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "DownloadManager",
     []() -> std::shared_ptr<HybridObject> {

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

@@ -0,0 +1,64 @@
+///
+/// JCastState.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 "CastState.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CastState" and the the Kotlin enum "CastState".
+   */
+  struct JCastState final: public jni::JavaClass<JCastState> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/CastState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CastState.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CastState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CastState>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCastState> fromCpp(CastState value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CastState::NO_DEVICES_AVAILABLE:
+          static const auto fieldNO_DEVICES_AVAILABLE = clazz->getStaticField<JCastState>("NO_DEVICES_AVAILABLE");
+          return clazz->getStaticFieldValue(fieldNO_DEVICES_AVAILABLE);
+        case CastState::NOT_CONNECTED:
+          static const auto fieldNOT_CONNECTED = clazz->getStaticField<JCastState>("NOT_CONNECTED");
+          return clazz->getStaticFieldValue(fieldNOT_CONNECTED);
+        case CastState::CONNECTING:
+          static const auto fieldCONNECTING = clazz->getStaticField<JCastState>("CONNECTING");
+          return clazz->getStaticFieldValue(fieldCONNECTING);
+        case CastState::CONNECTED:
+          static const auto fieldCONNECTED = clazz->getStaticField<JCastState>("CONNECTED");
+          return clazz->getStaticFieldValue(fieldCONNECTED);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,83 @@
+///
+/// JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "CastState.hpp"
+#include <NitroModules/Null.hpp>
+#include <string>
+#include <variant>
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JCastState.hpp"
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(state: CastState, deviceName: Variant_NullType_String?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__: public jni::JavaClass<JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__` instance holds through JNI.
+     */
+    void invoke(CastState state, const std::optional<std::variant<nitro::NullType, std::string>>& deviceName) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCastState> /* state */, jni::alias_ref<JVariant_NullType_String> /* deviceName */)>("invoke");
+      method(self(), JCastState::fromCpp(state), deviceName.has_value() ? JVariant_NullType_String::fromCpp(deviceName.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx final: public jni::HybridClass<JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx, JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__> {
+  public:
+    static jni::local_ref<JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__::javaobject> fromCpp(const std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)>& func) {
+      return JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCastState> state, jni::alias_ref<JVariant_NullType_String> deviceName) {
+      _func(state->toCpp(), deviceName != nullptr ? std::make_optional(deviceName->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx(const std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,115 @@
+///
+/// JHybridCastSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridCastSpec.hpp"
+
+// Forward declaration of `CastState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class CastState; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "CastState.hpp"
+#include "JCastState.hpp"
+#include <NitroModules/Null.hpp>
+#include <string>
+#include <variant>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <optional>
+#include <functional>
+#include "JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__.hpp"
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  std::shared_ptr<JHybridCastSpec> JHybridCastSpec::JavaPart::getJHybridCastSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridCastSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridCastSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridCastSpec::CxxPart::jhybriddata> JHybridCastSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridCastSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridCastSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridCastSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridCastSpec>(castJavaPart);
+  }
+
+  void JHybridCastSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridCastSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridCastSpec::configure(const std::optional<std::string>& receiverApplicationId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* receiverApplicationId */)>("configure");
+    auto __result = method(_javaPart, receiverApplicationId.has_value() ? jni::make_jstring(receiverApplicationId.value()) : nullptr);
+    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;
+    }();
+  }
+  bool JHybridCastSpec::isCasting() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isCasting");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  CastState JHybridCastSpec::getCastState() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JCastState>()>("getCastState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::variant<nitro::NullType, std::string> JHybridCastSpec::getCastDeviceName() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_String>()>("getCastDeviceName");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridCastSpec::showCastPicker() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("showCastPicker");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<void>> JHybridCastSpec::endCastSession() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("endCastSession");
+    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 JHybridCastSpec::onCastStateChange(const std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string__::javaobject> /* callback */)>("onCastStateChange_cxx");
+    method(_javaPart, JFunc_void_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx::fromCpp(callback));
+  }
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,69 @@
+///
+/// HybridCastSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridCastSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  class JHybridCastSpec: public virtual HybridCastSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridCastSpec;";
+      std::shared_ptr<JHybridCastSpec> getJHybridCastSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/HybridCastSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridCastSpec(const jni::local_ref<JHybridCastSpec::JavaPart>& javaPart):
+      HybridObject(HybridCastSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridCastSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridCastSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> configure(const std::optional<std::string>& receiverApplicationId) override;
+    bool isCasting() override;
+    CastState getCastState() override;
+    std::variant<nitro::NullType, std::string> getCastDeviceName() override;
+    void showCastPicker() override;
+    std::shared_ptr<Promise<void>> endCastSession() override;
+    void onCastStateChange(const std::function<void(CastState /* state */, const std::optional<std::variant<nitro::NullType, std::string>>& /* deviceName */)>& callback) override;
+
+  private:
+    jni::global_ref<JHybridCastSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,25 @@
+///
+/// CastState.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.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "CastState".
+ */
+@DoNotStrip
+@Keep
+enum class CastState(@DoNotStrip @Keep val value: Int) {
+  NO_DEVICES_AVAILABLE(0),
+  NOT_CONNECTED(1),
+  CONNECTING(2),
+  CONNECTED(3);
+
+  companion object
+}

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

@@ -0,0 +1,80 @@
+///
+/// Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__.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
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the JavaScript callback `(state: enum, deviceName: optional) => 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_CastState_std__optional_std__variant_nitro__NullType__std__string__: (CastState, Variant_NullType_String?) -> 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(state: CastState, deviceName: Variant_NullType_String?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(state: enum, deviceName: optional) => 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_CastState_std__optional_std__variant_nitro__NullType__std__string___cxx: Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(state: CastState, deviceName: Variant_NullType_String?): Unit
+    = invoke_cxx(state,deviceName)
+
+  @FastNative
+  private external fun invoke_cxx(state: CastState, deviceName: Variant_NullType_String?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(state: enum, deviceName: optional) => void`.
+ * This is implemented in Java/Kotlin, via a `(CastState, Variant_NullType_String?) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string___java(private val function: (CastState, Variant_NullType_String?) -> Unit): Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__ {
+  @DoNotStrip
+  @Keep
+  override fun invoke(state: CastState, deviceName: Variant_NullType_String?): Unit {
+    return this.function(state, deviceName)
+  }
+}

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

@@ -0,0 +1,85 @@
+///
+/// HybridCastSpec.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 com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the Cast HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of Cast.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridCastSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun configure(receiverApplicationId: String?): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isCasting(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCastState(): CastState
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCastDeviceName(): Variant_NullType_String
+  
+  @DoNotStrip
+  @Keep
+  abstract fun showCastPicker(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun endCastSession(): Promise<Unit>
+  
+  abstract fun onCastStateChange(callback: (state: CastState, deviceName: Variant_NullType_String?) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun onCastStateChange_cxx(callback: Func_void_CastState_std__optional_std__variant_nitro__NullType__std__string__): Unit {
+    val __result = onCastStateChange(callback)
+    return __result
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject Cast]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridCastSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridCastSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridCastSpec"
+  }
+}