react-native-nitro-player 1.4.3 → 1.5.0-alpha.0

package/lib/hooks/useCastState.js

@@ -0,0 +1,49 @@
+import { useEffect, useRef, useState } from 'react';
+import { Cast } from '../index';
+import { castCallbackManager } from './castCallbackManager';
+/**
+ * Hook to subscribe to the full Google Cast connection state.
+ *
+ * Provides the connection {@link CastState}, the connected device name, and a
+ * convenience `isCasting` flag. For a simple boolean prefer {@link useIsCasting}.
+ *
+ * @example
+ * ```tsx
+ * function CastStatus() {
+ *   const { state, deviceName, isCasting } = useCastState()
+ *   if (!isCasting) return null
+ *   return <Text>Casting to {deviceName} ({state})</Text>
+ * }
+ * ```
+ */
+export function useCastState() {
+    const [state, setState] = useState('not_connected');
+    const [deviceName, setDeviceName] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        // Seed from current native state.
+        try {
+            setState(Cast.getCastState());
+            setDeviceName(Cast.getCastDeviceName());
+        }
+        catch (error) {
+            console.error('[useCastState] Failed to read initial cast state:', error);
+        }
+        finally {
+            setIsReady(true);
+        }
+        const unsubscribe = castCallbackManager.subscribeToCastState((newState, newDeviceName) => {
+            if (isMounted.current) {
+                setState(newState);
+                setDeviceName(newDeviceName);
+            }
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribe();
+        };
+    }, []);
+    return { state, deviceName, isCasting: state === 'connected', isReady };
+}

package/lib/hooks/useIsCasting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook that returns whether playback is currently routed to a Google Cast device.
+ *
+ * Updates in real time as Cast sessions start and end. Initializes synchronously
+ * from the native player's current state.
+ *
+ * @returns `true` while connected to a Cast device, otherwise `false`.
+ *
+ * @example
+ * ```tsx
+ * function NowPlaying() {
+ *   const isCasting = useIsCasting()
+ *   return <Text>{isCasting ? 'Casting' : 'Playing locally'}</Text>
+ * }
+ * ```
+ */
+export declare function useIsCasting(): boolean;

package/lib/hooks/useIsCasting.js

@@ -0,0 +1,43 @@
+import { useEffect, useRef, useState } from 'react';
+import { Cast } from '../index';
+import { castCallbackManager } from './castCallbackManager';
+/**
+ * Hook that returns whether playback is currently routed to a Google Cast device.
+ *
+ * Updates in real time as Cast sessions start and end. Initializes synchronously
+ * from the native player's current state.
+ *
+ * @returns `true` while connected to a Cast device, otherwise `false`.
+ *
+ * @example
+ * ```tsx
+ * function NowPlaying() {
+ *   const isCasting = useIsCasting()
+ *   return <Text>{isCasting ? 'Casting' : 'Playing locally'}</Text>
+ * }
+ * ```
+ */
+export function useIsCasting() {
+    const [isCasting, setIsCasting] = useState(() => {
+        try {
+            return Cast.isCasting();
+        }
+        catch {
+            return false;
+        }
+    });
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        const unsubscribe = castCallbackManager.subscribeToCastState((state) => {
+            if (isMounted.current) {
+                setIsCasting(state === 'connected');
+            }
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribe();
+        };
+    }, []);
+    return isCasting;
+}

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import type { PlayerQueue as PlayerQueueType, TrackPlayer as TrackPlayerType } f
 import type { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryType } from './specs/AndroidAutoMediaLibrary.nitro';
 import type { AudioDevices as AudioDevicesType } from './specs/AudioDevices.nitro';
 import type { AudioRoutePicker as AudioRoutePickerType } from './specs/AudioRoutePicker.nitro';
+import type { Cast as CastType } from './specs/Cast.nitro';
 import type { DownloadManager as DownloadManagerType } from './specs/DownloadManager.nitro';
 import type { Equalizer as EqualizerType } from './specs/Equalizer.nitro';
 export declare const PlayerQueue: PlayerQueueType;
@@ -9,9 +10,13 @@ export declare const TrackPlayer: TrackPlayerType;
 export declare const AndroidAutoMediaLibrary: AndroidAutoMediaLibraryType | null;
 export declare const AudioDevices: AudioDevicesType | null;
 export declare const AudioRoutePicker: AudioRoutePickerType | null;
+export declare const Cast: CastType;
 export declare const DownloadManager: DownloadManagerType;
 export declare const Equalizer: EqualizerType;
 export * from './hooks';
+export { CastButton } from './components/CastButton';
+export type { CastButtonProps } from './components/CastButton';
+export type { CastState } from './specs/Cast.nitro';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
 export * from './types/DownloadTypes';

package/lib/index.js

@@ -15,13 +15,16 @@ export const AudioDevices = Platform.OS === 'android'
 export const AudioRoutePicker = Platform.OS === 'ios'
     ? NitroModules.createHybridObject('AudioRoutePicker')
     : null;
+// Google Cast (iOS + Android)
+export const Cast = NitroModules.createHybridObject('Cast');
 // Download Manager
 export const DownloadManager = NitroModules.createHybridObject('DownloadManager');
 // Equalizer
 export const Equalizer = NitroModules.createHybridObject('Equalizer');
 // Export hooks
 export * from './hooks';
-// Export types
+// Export components
+export { CastButton } from './components/CastButton';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
 export * from './types/DownloadTypes';

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

@@ -0,0 +1,58 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * The current Google Cast connection state.
+ *
+ * - `no_devices_available`: No Cast devices are discoverable on the network.
+ *   The Cast button is typically hidden in this state.
+ * - `not_connected`: Cast devices are available but none is connected.
+ * - `connecting`: A session is being established with a device.
+ * - `connected`: A session is active and playback is routed to the device.
+ */
+export type CastState = 'no_devices_available' | 'not_connected' | 'connecting' | 'connected';
+/**
+ * Google Cast control surface.
+ *
+ * Casting is implemented as an internal playback backend swap inside the native
+ * player core: when a session is `connected`, every playback operation (play,
+ * pause, seek, skip, queue) is routed to the remote Cast device and local audio
+ * is suppressed automatically. The existing {@link TrackPlayer} API keeps
+ * working unchanged — this object only exposes the Cast-specific surface.
+ */
+export interface Cast extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    /**
+     * Initialize the Cast framework. Must be called once early in app startup
+     * (before the first Cast interaction). Safe to call multiple times.
+     *
+     * @param receiverApplicationId Optional Web Receiver application ID registered
+     *   in the Google Cast Developer Console. When omitted, the platform Default
+     *   Media Receiver (`CC1AD845`) is used, which supports audio playback,
+     *   metadata and queues out of the box.
+     */
+    configure(receiverApplicationId?: string): Promise<void>;
+    /**
+     * Whether playback is currently routed to a Cast device.
+     * Equivalent to `getCastState() === 'connected'`.
+     */
+    isCasting(): boolean;
+    /** The current Cast connection state. */
+    getCastState(): CastState;
+    /** The friendly name of the connected device, or `null` when not connected. */
+    getCastDeviceName(): string | null;
+    /**
+     * Present the native Cast dialog. Shows the device chooser when not connected,
+     * or the cast controls / disconnect dialog when already connected. Mirrors the
+     * behaviour of the standard platform Cast button.
+     */
+    showCastPicker(): void;
+    /** End the current Cast session and resume local playback. No-op when not connected. */
+    endCastSession(): Promise<void>;
+    /**
+     * Register a callback fired whenever the Cast connection state changes.
+     * The callback receives the new {@link CastState} and the connected device
+     * name (or `null`).
+     */
+    onCastStateChange(callback: (state: CastState, deviceName: string | null) => void): void;
+}

package/lib/specs/Cast.nitro.js

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

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
+}