diff --git a/docs/docs/events/events.md b/docs/docs/events/events.md index e29dfc8e..05f1d93f 100644 --- a/docs/docs/events/events.md +++ b/docs/docs/events/events.md @@ -41,30 +41,31 @@ const MyVideoComponent = () => { The `VideoPlayer` class, through `VideoPlayerEvents`, supports the following events. You can subscribe to these by assigning a callback function to the corresponding property on the `VideoPlayer` instance. -| Event | Description | Callback Data Example | -|----------------------------|------------------------------------------------------------------------------------------------------------|-------------------------------------------------------| -| `onAudioBecomingNoisy` | Fired when audio is about to become noisy (e.g., headphones unplugged). | | -| `onAudioFocusChange` | Fired when the audio focus changes (e.g., another app starts playing audio). | | -| `onBandwidthUpdate` | Fired with an estimate of the available bandwidth. | | -| `onBuffer` | Fired when the player starts or stops buffering data. | `{ isBuffering: boolean }` | -| `onControlsVisibleChange` | Fired when the visibility of native controls changes. | | -| `onEnd` | Fired when the video playback reaches the end. | | -| `onExternalPlaybackChange` | Fired when the external playback status changes (e.g., AirPlay). | | -| `onLoad` | Fired when the video has loaded and is ready to play. | [Video metadata (duration, naturalSize, etc.)](../api-reference/interfaces/onLoadData.md) | -| `onLoadStart` | Fired when the video starts loading. | | -| `onPlaybackRateChange` | Fired when the playback rate changes. | `{ rate: number }` | -| `onPlaybackStateChange` | Fired when the playback state changes (e.g., playing, paused, stopped). | `{ status: VideoPlayerStatus }` | -| `onProgress` | Fired periodically during playback with the current time. | `{ currentTime: number, playableDuration: number, seekableDuration: number }` | -| `onReadyToDisplay` | Fired when the player is ready to display the first frame of the video. | | -| `onSeek` | Fired when a seek operation has completed. | `{ seekTime: number }` | -| `onStatusChange` | Fired when the player status changes (detailed status updates). | | -| `onTextTrackDataChanged` | Fired when text track data (e.g., subtitles) changes. | | -| `onTimedMetadata` | Fired when timed metadata is encountered in the video stream. | | -| `onVolumeChange` | Fired when the volume changes. | `{ volume: number }` | +| Event | Callback Signature | Description | +|----------------------------|--------------------------------------------------------|---------------------------------------------------------------------------------------------| +| `onAudioBecomingNoisy` | () => void | Fired when audio is about to become noisy (e.g., headphones unplugged). | +| `onAudioFocusChange` | (hasAudioFocus: boolean) => void | Fired when the audio focus changes (e.g., another app starts playing audio). | +| `onBandwidthUpdate` | (data: [BandwidthData](../api-reference/interfaces/BandwidthData.md)) => void | Fired with an estimate of the available bandwidth. | +| `onBuffer` | (buffering: boolean) => void | Fired when the player starts or stops buffering data. | +| `onControlsVisibleChange` | (visible: boolean) => void | Fired when the visibility of native controls changes. | +| `onEnd` | () => void | Fired when the video playback reaches the end. | +| `onExternalPlaybackChange` | (externalPlaybackActive: boolean) => void | Fired when the external playback status changes (e.g., AirPlay). | +| `onLoad` | (data: [onLoadData](../api-reference/interfaces/onLoadData.md)) => void | Fired when the video has loaded and is ready to play. | +| `onLoadStart` | (data: [onLoadStartData](../api-reference/interfaces/onLoadStartData.md)) => void | Fired when the video starts loading. | +| `onPlaybackRateChange` | (rate: number) => void | Fired when the playback rate changes. | +| `onPlaybackStateChange` | (data: [onPlaybackStateChangeData](../api-reference/interfaces/onPlaybackStateChangeData.md)) => void | Fired when the playback state changes (e.g., playing, paused, stopped). | +| `onProgress` | (data: [onProgressData](../api-reference/interfaces/onProgressData.md)) => void | Fired periodically during playback with the current time. | +| `onReadyToDisplay` | () => void | Fired when the player is ready to display the first frame of the video. | +| `onSeek` | (seekTime: number) => void | Fired when a seek operation has completed. | +| `onStatusChange` | (status: [VideoPlayerStatus](../api-reference/type-aliases/VideoPlayerStatus.md)) => void | Fired when the player status changes (detailed status updates). | +| `onTextTrackDataChanged` | (texts: string[]) => void | Fired when text track data (e.g., subtitles) changes. | +| `onTimedMetadata` | (metadata: [TimedMetadata](../api-reference/interfaces/TimedMetadata.md)) => void | Fired when timed metadata is encountered in the video stream. | +| `onTrackChange` | (track: [TextTrack](../api-reference/interfaces/TextTrack.md) \| null) => void | Fired when the selected text track changes. | +| `onVolumeChange` | (data: [onVolumeChangeData](../api-reference/interfaces/onVolumeChangeData.md)) => void | Fired when the volume changes. | Additionally, the `VideoPlayer` instance itself has an `onError` property: -- `onError`: Fired when a error occurs. The callback receives the `VideoRuntimeError` object. +- `onError: (error: ` [VideoRuntimeError](../api-reference/classes/VideoRuntimeError.md) `) => void` — Fired when an error occurs. The callback receives the `VideoRuntimeError` object. **Benefits of `useEvent`**: diff --git a/docs/versioned_docs/version-6.x/component/events.mdx b/docs/versioned_docs/version-6.x/component/events.mdx index 9d389a78..fb575a53 100644 --- a/docs/versioned_docs/version-6.x/component/events.mdx +++ b/docs/versioned_docs/version-6.x/component/events.mdx @@ -665,6 +665,7 @@ Triggered when the player volume changes. | Property | Type | Description | |----------|--------|---------------------------------| | volume | number | Volume level (0 to 1) | +| muted | boolean | Whether the player is muted | **Example:** diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock index d30a26b0..8c963b2f 100644 --- a/example/ios/Podfile.lock +++ b/example/ios/Podfile.lock @@ -1565,7 +1565,7 @@ PODS: - React-logger (= 0.77.2) - React-perflogger (= 0.77.2) - React-utils (= 0.77.2) - - ReactNativeVideo (7.0.0-alpha.1): + - ReactNativeVideo (7.0.0-alpha.2): - DoubleConversion - glog - hermes-engine @@ -1876,7 +1876,7 @@ SPEC CHECKSUMS: ReactAppDependencyProvider: f334cebc0beed0a72490492e978007082c03d533 ReactCodegen: 474fbb3e4bb0f1ee6c255d1955db76e13d509269 ReactCommon: 7763e59534d58e15f8f22121cdfe319040e08888 - ReactNativeVideo: ccaea22f81a6b60376e8bdb024368a2b5df400f6 + ReactNativeVideo: db800650d21aab71c457ea1408c4f46e853b5886 SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748 Yoga: 31a098f74c16780569aebd614a0f37a907de0189 diff --git a/example/src/App.tsx b/example/src/App.tsx index 671682b5..00697ece 100644 --- a/example/src/App.tsx +++ b/example/src/App.tsx @@ -19,6 +19,7 @@ import { type MixAudioMode, type onLoadData, type onProgressData, + type onVolumeChangeData, type ResizeMode, type TextTrack, type VideoConfig, @@ -153,6 +154,13 @@ const VideoDemo = () => { [addEvent] ); + const handleVolumeChange = React.useCallback( + ({ muted, volume }: onVolumeChangeData) => { + addEvent(`Player: onVolumeChange ${volume.toFixed(2)} isMuted=${muted}`); + }, + [addEvent] + ); + // Setup player const player = useVideoPlayer( { @@ -176,6 +184,7 @@ const VideoDemo = () => { useEvent(player, 'onStatusChange', handlePlayerStatusChange); useEvent(player, 'onSeek', handlePlayerSeek); useEvent(player, 'onPlaybackStateChange', handlePlayerStateChange); + useEvent(player, 'onVolumeChange', handleVolumeChange); // Sync settings with player React.useEffect(() => { diff --git a/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayer/HybridVideoPlayer.kt b/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayer/HybridVideoPlayer.kt index bc2d3eb2..79284d23 100644 --- a/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayer/HybridVideoPlayer.kt +++ b/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayer/HybridVideoPlayer.kt @@ -167,6 +167,10 @@ class HybridVideoPlayer() : HybridVideoPlayerSpec() { } else { playerPointer.volume = userVolume.toFloat() } + eventEmitter.onVolumeChange(onVolumeChangeData( + volume = playerPointer.volume.toDouble(), + muted = muted + )) } ) @@ -514,7 +518,10 @@ class HybridVideoPlayer() : HybridVideoPlayerSpec() { } VideoManager.audioFocusManager.requestAudioFocusUpdate() - eventEmitter.onVolumeChange(volume.toDouble()) + eventEmitter.onVolumeChange(onVolumeChangeData( + volume = volume.toDouble(), + muted = muted + )) } override fun onCues(cueGroup: CueGroup) { diff --git a/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayereventemitter/HybridVideoPlayerEventEmitter.kt b/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayereventemitter/HybridVideoPlayerEventEmitter.kt index 64b4c7f4..56aa61de 100644 --- a/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayereventemitter/HybridVideoPlayerEventEmitter.kt +++ b/packages/react-native-video/android/src/main/java/com/video/hybrids/videoplayereventemitter/HybridVideoPlayerEventEmitter.kt @@ -35,7 +35,7 @@ class HybridVideoPlayerEventEmitter(): HybridVideoPlayerEventEmitterSpec() { override var onTrackChange: (TextTrack?) -> Unit = {} - override var onVolumeChange: (Double) -> Unit = {} + override var onVolumeChange: (onVolumeChangeData) -> Unit = {} override var onStatusChange: (VideoPlayerStatus) -> Unit = {} } diff --git a/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer+Events.swift b/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer+Events.swift index 3314c429..f1681fda 100644 --- a/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer+Events.swift +++ b/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer+Events.swift @@ -26,7 +26,10 @@ extension HybridVideoPlayer: VideoPlayerObserverDelegate { } func onVolumeChanged(volume: Float) { - eventEmitter.onVolumeChange(Double(volume)) + eventEmitter.onVolumeChange(onVolumeChangeData( + volume: Double(volume), + muted: muted + )) } func onPlaybackBufferEmpty() { diff --git a/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer.swift b/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer.swift index 5ee0f556..f6a985ce 100644 --- a/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer.swift +++ b/packages/react-native-video/ios/hybrids/VideoPlayer/HybridVideoPlayer.swift @@ -106,6 +106,10 @@ class HybridVideoPlayer: HybridVideoPlayerSpec { var muted: Bool { set { playerPointer.isMuted = newValue + eventEmitter.onVolumeChange(onVolumeChangeData( + volume: Double(playerPointer.volume), + muted: muted + )) } get { return playerPointer.isMuted diff --git a/packages/react-native-video/ios/hybrids/VideoPlayerEmitter/HybridVideoPlayerEventEmitter.swift b/packages/react-native-video/ios/hybrids/VideoPlayerEmitter/HybridVideoPlayerEventEmitter.swift index e1516783..622f0e78 100644 --- a/packages/react-native-video/ios/hybrids/VideoPlayerEmitter/HybridVideoPlayerEventEmitter.swift +++ b/packages/react-native-video/ios/hybrids/VideoPlayerEmitter/HybridVideoPlayerEventEmitter.swift @@ -45,5 +45,5 @@ class HybridVideoPlayerEventEmitter: HybridVideoPlayerEventEmitterSpec { var onTrackChange: ((TextTrack?) -> Void) = { _ in } - var onVolumeChange: ((Double) -> Void) = { _ in } + var onVolumeChange: ((onVolumeChangeData) -> Void) = { _ in } } diff --git a/packages/react-native-video/nitrogen/generated/android/ReactNativeVideoOnLoad.cpp b/packages/react-native-video/nitrogen/generated/android/ReactNativeVideoOnLoad.cpp index 59a7fcbd..ab0d614d 100644 --- a/packages/react-native-video/nitrogen/generated/android/ReactNativeVideoOnLoad.cpp +++ b/packages/react-native-video/nitrogen/generated/android/ReactNativeVideoOnLoad.cpp @@ -29,6 +29,7 @@ #include "JFunc_void_TimedMetadata.hpp" #include "JFunc_void_std__vector_std__string_.hpp" #include "JFunc_void_std__optional_TextTrack_.hpp" +#include "JFunc_void_onVolumeChangeData.hpp" #include "JFunc_void_VideoPlayerStatus.hpp" #include "JHybridVideoPlayerSourceSpec.hpp" #include "JHybridVideoPlayerSourceFactorySpec.hpp" @@ -60,6 +61,7 @@ int initialize(JavaVM* vm) { margelo::nitro::video::JFunc_void_TimedMetadata_cxx::registerNatives(); margelo::nitro::video::JFunc_void_std__vector_std__string__cxx::registerNatives(); margelo::nitro::video::JFunc_void_std__optional_TextTrack__cxx::registerNatives(); + margelo::nitro::video::JFunc_void_onVolumeChangeData_cxx::registerNatives(); margelo::nitro::video::JFunc_void_VideoPlayerStatus_cxx::registerNatives(); margelo::nitro::video::JHybridVideoPlayerSourceSpec::registerNatives(); margelo::nitro::video::JHybridVideoPlayerSourceFactorySpec::registerNatives(); diff --git a/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_double.hpp b/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_double.hpp index 566110a6..a0d071ad 100644 --- a/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_double.hpp +++ b/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_double.hpp @@ -17,7 +17,7 @@ namespace margelo::nitro::video { using namespace facebook; /** - * Represents the Java/Kotlin callback `(volume: Double) -> Unit`. + * Represents the Java/Kotlin callback `(seekTime: Double) -> Unit`. * This can be passed around between C++ and Java/Kotlin. */ struct JFunc_void_double: public jni::JavaClass { @@ -28,9 +28,9 @@ namespace margelo::nitro::video { /** * Invokes the function this `JFunc_void_double` instance holds through JNI. */ - void invoke(double volume) const { - static const auto method = javaClassStatic()->getMethod("invoke"); - method(self(), volume); + void invoke(double seekTime) const { + static const auto method = javaClassStatic()->getMethod("invoke"); + method(self(), seekTime); } }; @@ -39,7 +39,7 @@ namespace margelo::nitro::video { */ struct JFunc_void_double_cxx final: public jni::HybridClass { public: - static jni::local_ref fromCpp(const std::function& func) { + static jni::local_ref fromCpp(const std::function& func) { return JFunc_void_double_cxx::newObjectCxxArgs(func); } @@ -47,13 +47,13 @@ namespace margelo::nitro::video { /** * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds. */ - void invoke_cxx(double volume) { - _func(volume); + void invoke_cxx(double seekTime) { + _func(seekTime); } public: [[nodiscard]] - inline const std::function& getFunction() const { + inline const std::function& getFunction() const { return _func; } @@ -64,11 +64,11 @@ namespace margelo::nitro::video { } private: - explicit JFunc_void_double_cxx(const std::function& func): _func(func) { } + explicit JFunc_void_double_cxx(const std::function& func): _func(func) { } private: friend HybridBase; - std::function _func; + std::function _func; }; } // namespace margelo::nitro::video diff --git a/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_onVolumeChangeData.hpp b/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_onVolumeChangeData.hpp new file mode 100644 index 00000000..4fb79ae2 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/android/c++/JFunc_void_onVolumeChangeData.hpp @@ -0,0 +1,76 @@ +/// +/// JFunc_void_onVolumeChangeData.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "onVolumeChangeData.hpp" +#include "JonVolumeChangeData.hpp" + +namespace margelo::nitro::video { + + using namespace facebook; + + /** + * Represents the Java/Kotlin callback `(data: onVolumeChangeData) -> Unit`. + * This can be passed around between C++ and Java/Kotlin. + */ + struct JFunc_void_onVolumeChangeData: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onVolumeChangeData;"; + + public: + /** + * Invokes the function this `JFunc_void_onVolumeChangeData` instance holds through JNI. + */ + void invoke(const onVolumeChangeData& data) const { + static const auto method = javaClassStatic()->getMethod /* data */)>("invoke"); + method(self(), JonVolumeChangeData::fromCpp(data)); + } + }; + + /** + * An implementation of Func_void_onVolumeChangeData that is backed by a C++ implementation (using `std::function<...>`) + */ + struct JFunc_void_onVolumeChangeData_cxx final: public jni::HybridClass { + public: + static jni::local_ref fromCpp(const std::function& func) { + return JFunc_void_onVolumeChangeData_cxx::newObjectCxxArgs(func); + } + + public: + /** + * Invokes the C++ `std::function<...>` this `JFunc_void_onVolumeChangeData_cxx` instance holds. + */ + void invoke_cxx(jni::alias_ref data) { + _func(data->toCpp()); + } + + public: + [[nodiscard]] + inline const std::function& getFunction() const { + return _func; + } + + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onVolumeChangeData_cxx;"; + static void registerNatives() { + registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onVolumeChangeData_cxx::invoke_cxx)}); + } + + private: + explicit JFunc_void_onVolumeChangeData_cxx(const std::function& func): _func(func) { } + + private: + friend HybridBase; + std::function _func; + }; + +} // namespace margelo::nitro::video diff --git a/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.cpp b/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.cpp index b181c930..c607479b 100644 --- a/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.cpp +++ b/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.cpp @@ -29,6 +29,8 @@ namespace margelo::nitro::video { struct TimedMetadata; } namespace margelo::nitro::video { struct TimedMetadataObject; } // Forward declaration of `TextTrack` to properly resolve imports. namespace margelo::nitro::video { struct TextTrack; } +// Forward declaration of `onVolumeChangeData` to properly resolve imports. +namespace margelo::nitro::video { struct onVolumeChangeData; } // Forward declaration of `VideoPlayerStatus` to properly resolve imports. namespace margelo::nitro::video { enum class VideoPlayerStatus; } @@ -71,6 +73,9 @@ namespace margelo::nitro::video { enum class VideoPlayerStatus; } #include "TextTrack.hpp" #include "JFunc_void_std__optional_TextTrack_.hpp" #include "JTextTrack.hpp" +#include "onVolumeChangeData.hpp" +#include "JFunc_void_onVolumeChangeData.hpp" +#include "JonVolumeChangeData.hpp" #include "VideoPlayerStatus.hpp" #include "JFunc_void_VideoPlayerStatus.hpp" #include "JVideoPlayerStatus.hpp" @@ -416,24 +421,24 @@ namespace margelo::nitro::video { static const auto method = javaClassStatic()->getMethod /* onTrackChange */)>("setOnTrackChange_cxx"); method(_javaPart, JFunc_void_std__optional_TextTrack__cxx::fromCpp(onTrackChange)); } - std::function JHybridVideoPlayerEventEmitterSpec::getOnVolumeChange() { - static const auto method = javaClassStatic()->getMethod()>("getOnVolumeChange_cxx"); + std::function JHybridVideoPlayerEventEmitterSpec::getOnVolumeChange() { + static const auto method = javaClassStatic()->getMethod()>("getOnVolumeChange_cxx"); auto __result = method(_javaPart); - return [&]() -> std::function { - if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] { - auto downcast = jni::static_ref_cast(__result); + return [&]() -> std::function { + if (__result->isInstanceOf(JFunc_void_onVolumeChangeData_cxx::javaClassStatic())) [[likely]] { + auto downcast = jni::static_ref_cast(__result); return downcast->cthis()->getFunction(); } else { auto __resultRef = jni::make_global(__result); - return [__resultRef](double volume) -> void { - return __resultRef->invoke(volume); + return [__resultRef](onVolumeChangeData data) -> void { + return __resultRef->invoke(data); }; } }(); } - void JHybridVideoPlayerEventEmitterSpec::setOnVolumeChange(const std::function& onVolumeChange) { - static const auto method = javaClassStatic()->getMethod /* onVolumeChange */)>("setOnVolumeChange_cxx"); - method(_javaPart, JFunc_void_double_cxx::fromCpp(onVolumeChange)); + void JHybridVideoPlayerEventEmitterSpec::setOnVolumeChange(const std::function& onVolumeChange) { + static const auto method = javaClassStatic()->getMethod /* onVolumeChange */)>("setOnVolumeChange_cxx"); + method(_javaPart, JFunc_void_onVolumeChangeData_cxx::fromCpp(onVolumeChange)); } std::function JHybridVideoPlayerEventEmitterSpec::getOnStatusChange() { static const auto method = javaClassStatic()->getMethod()>("getOnStatusChange_cxx"); diff --git a/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.hpp b/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.hpp index a8debce6..53852de3 100644 --- a/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.hpp +++ b/packages/react-native-video/nitrogen/generated/android/c++/JHybridVideoPlayerEventEmitterSpec.hpp @@ -81,8 +81,8 @@ namespace margelo::nitro::video { void setOnTextTrackDataChanged(const std::function& /* texts */)>& onTextTrackDataChanged) override; std::function& /* track */)> getOnTrackChange() override; void setOnTrackChange(const std::function& /* track */)>& onTrackChange) override; - std::function getOnVolumeChange() override; - void setOnVolumeChange(const std::function& onVolumeChange) override; + std::function getOnVolumeChange() override; + void setOnVolumeChange(const std::function& onVolumeChange) override; std::function getOnStatusChange() override; void setOnStatusChange(const std::function& onStatusChange) override; diff --git a/packages/react-native-video/nitrogen/generated/android/c++/JonVolumeChangeData.hpp b/packages/react-native-video/nitrogen/generated/android/c++/JonVolumeChangeData.hpp new file mode 100644 index 00000000..81247dff --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/android/c++/JonVolumeChangeData.hpp @@ -0,0 +1,57 @@ +/// +/// JonVolumeChangeData.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "onVolumeChangeData.hpp" + + + +namespace margelo::nitro::video { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "onVolumeChangeData" and the the Kotlin data class "onVolumeChangeData". + */ + struct JonVolumeChangeData final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/onVolumeChangeData;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct onVolumeChangeData by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + onVolumeChangeData toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldVolume = clazz->getField("volume"); + double volume = this->getFieldValue(fieldVolume); + static const auto fieldMuted = clazz->getField("muted"); + jboolean muted = this->getFieldValue(fieldMuted); + return onVolumeChangeData( + volume, + static_cast(muted) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const onVolumeChangeData& value) { + return newInstance( + value.volume, + value.muted + ); + } + }; + +} // namespace margelo::nitro::video diff --git a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_double.kt b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_double.kt index 6d70fbe3..cfbd7f7d 100644 --- a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_double.kt +++ b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_double.kt @@ -14,7 +14,7 @@ import com.margelo.nitro.core.* import dalvik.annotation.optimization.FastNative /** - * Represents the JavaScript callback `(volume: number) => void`. + * Represents the JavaScript callback `(seekTime: number) => 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). */ @@ -28,11 +28,11 @@ fun interface Func_void_double: (Double) -> Unit { */ @DoNotStrip @Keep - override fun invoke(volume: Double): Unit + override fun invoke(seekTime: Double): Unit } /** - * Represents the JavaScript callback `(volume: number) => void`. + * Represents the JavaScript callback `(seekTime: number) => void`. * This is implemented in C++, via a `std::function<...>`. * The callback might be coming from JS. */ @@ -56,15 +56,15 @@ class Func_void_double_cxx: Func_void_double { @DoNotStrip @Keep - override fun invoke(volume: Double): Unit - = invoke_cxx(volume) + override fun invoke(seekTime: Double): Unit + = invoke_cxx(seekTime) @FastNative - private external fun invoke_cxx(volume: Double): Unit + private external fun invoke_cxx(seekTime: Double): Unit } /** - * Represents the JavaScript callback `(volume: number) => void`. + * Represents the JavaScript callback `(seekTime: number) => void`. * This is implemented in Java/Kotlin, via a `(Double) -> Unit`. * The callback is always coming from native. */ @@ -74,7 +74,7 @@ class Func_void_double_cxx: Func_void_double { class Func_void_double_java(private val function: (Double) -> Unit): Func_void_double { @DoNotStrip @Keep - override fun invoke(volume: Double): Unit { - return this.function(volume) + override fun invoke(seekTime: Double): Unit { + return this.function(seekTime) } } diff --git a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_onVolumeChangeData.kt b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_onVolumeChangeData.kt new file mode 100644 index 00000000..48e9e112 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/Func_void_onVolumeChangeData.kt @@ -0,0 +1,80 @@ +/// +/// Func_void_onVolumeChangeData.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.video + +import androidx.annotation.Keep +import com.facebook.jni.HybridData +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.* +import dalvik.annotation.optimization.FastNative + +/** + * Represents the JavaScript callback `(data: struct) => 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_onVolumeChangeData: (onVolumeChangeData) -> 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(data: onVolumeChangeData): Unit +} + +/** + * Represents the JavaScript callback `(data: struct) => 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_onVolumeChangeData_cxx: Func_void_onVolumeChangeData { + @DoNotStrip + @Keep + private val mHybridData: HybridData + + @DoNotStrip + @Keep + private constructor(hybridData: HybridData) { + mHybridData = hybridData + } + + @DoNotStrip + @Keep + override fun invoke(data: onVolumeChangeData): Unit + = invoke_cxx(data) + + @FastNative + private external fun invoke_cxx(data: onVolumeChangeData): Unit +} + +/** + * Represents the JavaScript callback `(data: struct) => void`. + * This is implemented in Java/Kotlin, via a `(onVolumeChangeData) -> Unit`. + * The callback is always coming from native. + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType", "unused") +class Func_void_onVolumeChangeData_java(private val function: (onVolumeChangeData) -> Unit): Func_void_onVolumeChangeData { + @DoNotStrip + @Keep + override fun invoke(data: onVolumeChangeData): Unit { + return this.function(data) + } +} diff --git a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/HybridVideoPlayerEventEmitterSpec.kt b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/HybridVideoPlayerEventEmitterSpec.kt index f21dfa01..6ba28f19 100644 --- a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/HybridVideoPlayerEventEmitterSpec.kt +++ b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/HybridVideoPlayerEventEmitterSpec.kt @@ -275,13 +275,13 @@ abstract class HybridVideoPlayerEventEmitterSpec: HybridObject() { onTrackChange = value } - abstract var onVolumeChange: (volume: Double) -> Unit + abstract var onVolumeChange: (data: onVolumeChangeData) -> Unit - private var onVolumeChange_cxx: Func_void_double + private var onVolumeChange_cxx: Func_void_onVolumeChangeData @Keep @DoNotStrip get() { - return Func_void_double_java(onVolumeChange) + return Func_void_onVolumeChangeData_java(onVolumeChange) } @Keep @DoNotStrip diff --git a/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/onVolumeChangeData.kt b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/onVolumeChangeData.kt new file mode 100644 index 00000000..cdb5d380 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/android/kotlin/com/margelo/nitro/video/onVolumeChangeData.kt @@ -0,0 +1,27 @@ +/// +/// onVolumeChangeData.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.video + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.* + +/** + * Represents the JavaScript object/struct "onVolumeChangeData". + */ +@DoNotStrip +@Keep +data class onVolumeChangeData + @DoNotStrip + @Keep + constructor( + val volume: Double, + val muted: Boolean + ) { + /* main constructor */ +} diff --git a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.cpp b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.cpp index c0680c7c..fba8982c 100644 --- a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.cpp +++ b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.cpp @@ -179,6 +179,14 @@ namespace margelo::nitro::video::bridge::swift { }; } + // pragma MARK: std::function + Func_void_onVolumeChangeData create_Func_void_onVolumeChangeData(void* _Nonnull swiftClosureWrapper) { + auto swiftClosure = ReactNativeVideo::Func_void_onVolumeChangeData::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const onVolumeChangeData& data) mutable -> void { + swiftClosure.call(data); + }; + } + // pragma MARK: std::function Func_void_VideoPlayerStatus create_Func_void_VideoPlayerStatus(void* _Nonnull swiftClosureWrapper) { auto swiftClosure = ReactNativeVideo::Func_void_VideoPlayerStatus::fromUnsafe(swiftClosureWrapper); diff --git a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.hpp b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.hpp index bef8f82c..501d9e45 100644 --- a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Bridge.hpp @@ -50,6 +50,8 @@ namespace margelo::nitro::video { struct onLoadStartData; } namespace margelo::nitro::video { struct onPlaybackStateChangeData; } // Forward declaration of `onProgressData` to properly resolve imports. namespace margelo::nitro::video { struct onProgressData; } +// Forward declaration of `onVolumeChangeData` to properly resolve imports. +namespace margelo::nitro::video { struct onVolumeChangeData; } // Forward declarations of Swift defined types // Forward declaration of `HybridVideoPlayerEventEmitterSpec_cxx` to properly resolve imports. @@ -89,6 +91,7 @@ namespace ReactNativeVideo { class HybridVideoViewViewManagerSpec_cxx; } #include "onLoadStartData.hpp" #include "onPlaybackStateChangeData.hpp" #include "onProgressData.hpp" +#include "onVolumeChangeData.hpp" #include #include #include @@ -535,6 +538,28 @@ namespace margelo::nitro::video::bridge::swift { return Func_void_std__optional_TextTrack__Wrapper(std::move(value)); } + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_onVolumeChangeData = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_onVolumeChangeData_Wrapper final { + public: + explicit Func_void_onVolumeChangeData_Wrapper(std::function&& func): _function(std::make_shared>(std::move(func))) {} + inline void call(onVolumeChangeData data) const { + _function->operator()(data); + } + private: + std::shared_ptr> _function; + }; + Func_void_onVolumeChangeData create_Func_void_onVolumeChangeData(void* _Nonnull swiftClosureWrapper); + inline Func_void_onVolumeChangeData_Wrapper wrap_Func_void_onVolumeChangeData(Func_void_onVolumeChangeData value) { + return Func_void_onVolumeChangeData_Wrapper(std::move(value)); + } + // pragma MARK: std::function /** * Specialized version of `std::function`. diff --git a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Umbrella.hpp b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Umbrella.hpp index 30857f78..8b1d7035 100644 --- a/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Umbrella.hpp +++ b/packages/react-native-video/nitrogen/generated/ios/ReactNativeVideo-Swift-Cxx-Umbrella.hpp @@ -58,6 +58,8 @@ namespace margelo::nitro::video { struct onLoadStartData; } namespace margelo::nitro::video { struct onPlaybackStateChangeData; } // Forward declaration of `onProgressData` to properly resolve imports. namespace margelo::nitro::video { struct onProgressData; } +// Forward declaration of `onVolumeChangeData` to properly resolve imports. +namespace margelo::nitro::video { struct onVolumeChangeData; } // Include C++ defined types #include "BandwidthData.hpp" @@ -85,6 +87,7 @@ namespace margelo::nitro::video { struct onProgressData; } #include "onLoadStartData.hpp" #include "onPlaybackStateChangeData.hpp" #include "onProgressData.hpp" +#include "onVolumeChangeData.hpp" #include #include #include diff --git a/packages/react-native-video/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.hpp b/packages/react-native-video/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.hpp index be901458..5d30240b 100644 --- a/packages/react-native-video/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.hpp +++ b/packages/react-native-video/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.hpp @@ -34,6 +34,8 @@ namespace margelo::nitro::video { struct TimedMetadata; } namespace margelo::nitro::video { struct TimedMetadataObject; } // Forward declaration of `TextTrack` to properly resolve imports. namespace margelo::nitro::video { struct TextTrack; } +// Forward declaration of `onVolumeChangeData` to properly resolve imports. +namespace margelo::nitro::video { struct onVolumeChangeData; } // Forward declaration of `VideoPlayerStatus` to properly resolve imports. namespace margelo::nitro::video { enum class VideoPlayerStatus; } @@ -53,6 +55,7 @@ namespace margelo::nitro::video { enum class VideoPlayerStatus; } #include "TimedMetadataObject.hpp" #include #include "TextTrack.hpp" +#include "onVolumeChangeData.hpp" #include "VideoPlayerStatus.hpp" #include "ReactNativeVideo-Swift-Cxx-Umbrella.hpp" @@ -209,11 +212,11 @@ namespace margelo::nitro::video { inline void setOnTrackChange(const std::function& /* track */)>& onTrackChange) noexcept override { _swiftPart.setOnTrackChange(onTrackChange); } - inline std::function getOnVolumeChange() noexcept override { + inline std::function getOnVolumeChange() noexcept override { auto __result = _swiftPart.getOnVolumeChange(); return __result; } - inline void setOnVolumeChange(const std::function& onVolumeChange) noexcept override { + inline void setOnVolumeChange(const std::function& onVolumeChange) noexcept override { _swiftPart.setOnVolumeChange(onVolumeChange); } inline std::function getOnStatusChange() noexcept override { diff --git a/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_double.swift b/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_double.swift index 6676bcb0..92e53bec 100644 --- a/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_double.swift +++ b/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_double.swift @@ -8,21 +8,21 @@ import NitroModules /** - * Wraps a Swift `(_ volume: Double) -> Void` as a class. + * Wraps a Swift `(_ seekTime: Double) -> Void` as a class. * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. */ public final class Func_void_double { public typealias bridge = margelo.nitro.video.bridge.swift - private let closure: (_ volume: Double) -> Void + private let closure: (_ seekTime: Double) -> Void - public init(_ closure: @escaping (_ volume: Double) -> Void) { + public init(_ closure: @escaping (_ seekTime: Double) -> Void) { self.closure = closure } @inline(__always) - public func call(volume: Double) -> Void { - self.closure(volume) + public func call(seekTime: Double) -> Void { + self.closure(seekTime) } /** diff --git a/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_onVolumeChangeData.swift b/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_onVolumeChangeData.swift new file mode 100644 index 00000000..430f29a0 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/ios/swift/Func_void_onVolumeChangeData.swift @@ -0,0 +1,46 @@ +/// +/// Func_void_onVolumeChangeData.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * Wraps a Swift `(_ data: onVolumeChangeData) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_onVolumeChangeData { + public typealias bridge = margelo.nitro.video.bridge.swift + + private let closure: (_ data: onVolumeChangeData) -> Void + + public init(_ closure: @escaping (_ data: onVolumeChangeData) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(data: onVolumeChangeData) -> Void { + self.closure(data) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_onVolumeChangeData`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_onVolumeChangeData { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec.swift b/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec.swift index 458c1f95..97ede6b8 100644 --- a/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec.swift +++ b/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec.swift @@ -28,7 +28,7 @@ public protocol HybridVideoPlayerEventEmitterSpec_protocol: HybridObject { var onTimedMetadata: (_ metadata: TimedMetadata) -> Void { get set } var onTextTrackDataChanged: (_ texts: [String]) -> Void { get set } var onTrackChange: (_ track: TextTrack?) -> Void { get set } - var onVolumeChange: (_ volume: Double) -> Void { get set } + var onVolumeChange: (_ data: onVolumeChangeData) -> Void { get set } var onStatusChange: (_ status: VideoPlayerStatus) -> Void { get set } // Methods diff --git a/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec_cxx.swift b/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec_cxx.swift index dfb2c817..7ec7b3e4 100644 --- a/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec_cxx.swift +++ b/packages/react-native-video/nitrogen/generated/ios/swift/HybridVideoPlayerEventEmitterSpec_cxx.swift @@ -432,20 +432,20 @@ public class HybridVideoPlayerEventEmitterSpec_cxx { } } - public final var onVolumeChange: bridge.Func_void_double { + public final var onVolumeChange: bridge.Func_void_onVolumeChangeData { @inline(__always) get { - return { () -> bridge.Func_void_double in - let __closureWrapper = Func_void_double(self.__implementation.onVolumeChange) - return bridge.create_Func_void_double(__closureWrapper.toUnsafe()) + return { () -> bridge.Func_void_onVolumeChangeData in + let __closureWrapper = Func_void_onVolumeChangeData(self.__implementation.onVolumeChange) + return bridge.create_Func_void_onVolumeChangeData(__closureWrapper.toUnsafe()) }() } @inline(__always) set { - self.__implementation.onVolumeChange = { () -> (Double) -> Void in - let __wrappedFunction = bridge.wrap_Func_void_double(newValue) - return { (__volume: Double) -> Void in - __wrappedFunction.call(__volume) + self.__implementation.onVolumeChange = { () -> (onVolumeChangeData) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_onVolumeChangeData(newValue) + return { (__data: onVolumeChangeData) -> Void in + __wrappedFunction.call(__data) } }() } diff --git a/packages/react-native-video/nitrogen/generated/ios/swift/onVolumeChangeData.swift b/packages/react-native-video/nitrogen/generated/ios/swift/onVolumeChangeData.swift new file mode 100644 index 00000000..ab9b5410 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/ios/swift/onVolumeChangeData.swift @@ -0,0 +1,46 @@ +/// +/// onVolumeChangeData.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * Represents an instance of `onVolumeChangeData`, backed by a C++ struct. + */ +public typealias onVolumeChangeData = margelo.nitro.video.onVolumeChangeData + +public extension onVolumeChangeData { + private typealias bridge = margelo.nitro.video.bridge.swift + + /** + * Create a new instance of `onVolumeChangeData`. + */ + init(volume: Double, muted: Bool) { + self.init(volume, muted) + } + + var volume: Double { + @inline(__always) + get { + return self.__volume + } + @inline(__always) + set { + self.__volume = newValue + } + } + + var muted: Bool { + @inline(__always) + get { + return self.__muted + } + @inline(__always) + set { + self.__muted = newValue + } + } +} diff --git a/packages/react-native-video/nitrogen/generated/shared/c++/HybridVideoPlayerEventEmitterSpec.hpp b/packages/react-native-video/nitrogen/generated/shared/c++/HybridVideoPlayerEventEmitterSpec.hpp index abde50fc..fb716979 100644 --- a/packages/react-native-video/nitrogen/generated/shared/c++/HybridVideoPlayerEventEmitterSpec.hpp +++ b/packages/react-native-video/nitrogen/generated/shared/c++/HybridVideoPlayerEventEmitterSpec.hpp @@ -27,6 +27,8 @@ namespace margelo::nitro::video { struct onProgressData; } namespace margelo::nitro::video { struct TimedMetadata; } // Forward declaration of `TextTrack` to properly resolve imports. namespace margelo::nitro::video { struct TextTrack; } +// Forward declaration of `onVolumeChangeData` to properly resolve imports. +namespace margelo::nitro::video { struct onVolumeChangeData; } // Forward declaration of `VideoPlayerStatus` to properly resolve imports. namespace margelo::nitro::video { enum class VideoPlayerStatus; } @@ -41,6 +43,7 @@ namespace margelo::nitro::video { enum class VideoPlayerStatus; } #include #include #include "TextTrack.hpp" +#include "onVolumeChangeData.hpp" #include "VideoPlayerStatus.hpp" namespace margelo::nitro::video { @@ -104,8 +107,8 @@ namespace margelo::nitro::video { virtual void setOnTextTrackDataChanged(const std::function& /* texts */)>& onTextTrackDataChanged) = 0; virtual std::function& /* track */)> getOnTrackChange() = 0; virtual void setOnTrackChange(const std::function& /* track */)>& onTrackChange) = 0; - virtual std::function getOnVolumeChange() = 0; - virtual void setOnVolumeChange(const std::function& onVolumeChange) = 0; + virtual std::function getOnVolumeChange() = 0; + virtual void setOnVolumeChange(const std::function& onVolumeChange) = 0; virtual std::function getOnStatusChange() = 0; virtual void setOnStatusChange(const std::function& onStatusChange) = 0; diff --git a/packages/react-native-video/nitrogen/generated/shared/c++/onVolumeChangeData.hpp b/packages/react-native-video/nitrogen/generated/shared/c++/onVolumeChangeData.hpp new file mode 100644 index 00000000..45222876 --- /dev/null +++ b/packages/react-native-video/nitrogen/generated/shared/c++/onVolumeChangeData.hpp @@ -0,0 +1,73 @@ +/// +/// onVolumeChangeData.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2025 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + + + +namespace margelo::nitro::video { + + /** + * A struct which can be represented as a JavaScript object (onVolumeChangeData). + */ + struct onVolumeChangeData { + public: + double volume SWIFT_PRIVATE; + bool muted SWIFT_PRIVATE; + + public: + onVolumeChangeData() = default; + explicit onVolumeChangeData(double volume, bool muted): volume(volume), muted(muted) {} + }; + +} // namespace margelo::nitro::video + +namespace margelo::nitro { + + using namespace margelo::nitro::video; + + // C++ onVolumeChangeData <> JS onVolumeChangeData (object) + template <> + struct JSIConverter final { + static inline onVolumeChangeData fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return onVolumeChangeData( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "volume")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "muted")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const onVolumeChangeData& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "volume", JSIConverter::toJSI(runtime, arg.volume)); + obj.setProperty(runtime, "muted", JSIConverter::toJSI(runtime, arg.muted)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "volume"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "muted"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/packages/react-native-video/src/core/types/Events.ts b/packages/react-native-video/src/core/types/Events.ts index ad75db64..abf2cf48 100644 --- a/packages/react-native-video/src/core/types/Events.ts +++ b/packages/react-native-video/src/core/types/Events.ts @@ -85,7 +85,7 @@ export interface VideoPlayerEvents { /** * Called when the volume of the player changes. */ - onVolumeChange: (volume: number) => void; + onVolumeChange: (data: onVolumeChangeData) => void; /** * Called when the player status changes. */ @@ -209,3 +209,14 @@ export interface TimedMetadata { */ metadata: Array; } + +export interface onVolumeChangeData { + /** + * The volume of the player (0.0 = 0%, 1.0 = 100%). + */ + volume: number; + /** + * Whether the player is muted. + */ + muted: boolean; +}