@pigeonmal/react-native-video 7.0.0-beta.2

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

@@ -0,0 +1,81 @@
+///
+/// JFunc_void_TimedMetadata.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "TimedMetadata.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTimedMetadata.hpp"
+#include "TimedMetadataObject.hpp"
+#include <vector>
+#include "JTimedMetadataObject.hpp"
+#include <string>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: TimedMetadata) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_TimedMetadata: public jni::JavaClass<JFunc_void_TimedMetadata> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_TimedMetadata;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_TimedMetadata` instance holds through JNI.
+     */
+    void invoke(const TimedMetadata& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTimedMetadata> /* data */)>("invoke");
+      method(self(), JTimedMetadata::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_TimedMetadata that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_TimedMetadata_cxx final: public jni::HybridClass<JFunc_void_TimedMetadata_cxx, JFunc_void_TimedMetadata> {
+  public:
+    static jni::local_ref<JFunc_void_TimedMetadata::javaobject> fromCpp(const std::function<void(const TimedMetadata& /* data */)>& func) {
+      return JFunc_void_TimedMetadata_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_TimedMetadata_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTimedMetadata> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const TimedMetadata& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_TimedMetadata_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_TimedMetadata_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_TimedMetadata_cxx(const std::function<void(const TimedMetadata& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const TimedMetadata& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_VideoPlayerStatus.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "VideoPlayerStatus.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JVideoPlayerStatus.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(status: VideoPlayerStatus) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_VideoPlayerStatus: public jni::JavaClass<JFunc_void_VideoPlayerStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_VideoPlayerStatus;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_VideoPlayerStatus` instance holds through JNI.
+     */
+    void invoke(VideoPlayerStatus status) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVideoPlayerStatus> /* status */)>("invoke");
+      method(self(), JVideoPlayerStatus::fromCpp(status));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_VideoPlayerStatus that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_VideoPlayerStatus_cxx final: public jni::HybridClass<JFunc_void_VideoPlayerStatus_cxx, JFunc_void_VideoPlayerStatus> {
+  public:
+    static jni::local_ref<JFunc_void_VideoPlayerStatus::javaobject> fromCpp(const std::function<void(VideoPlayerStatus /* status */)>& func) {
+      return JFunc_void_VideoPlayerStatus_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_VideoPlayerStatus_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JVideoPlayerStatus> status) {
+      _func(status->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(VideoPlayerStatus /* status */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_VideoPlayerStatus_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_VideoPlayerStatus_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_VideoPlayerStatus_cxx(const std::function<void(VideoPlayerStatus /* status */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(VideoPlayerStatus /* status */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(isInPictureInPicture: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool isInPictureInPicture) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* isInPictureInPicture */)>("invoke");
+      method(self(), isInPictureInPicture);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isInPictureInPicture */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean isInPictureInPicture) {
+      _func(static_cast<bool>(isInPictureInPicture));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* isInPictureInPicture */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* isInPictureInPicture */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* isInPictureInPicture */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(rate: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double rate) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* rate */)>("invoke");
+      method(self(), rate);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* rate */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double rate) {
+      _func(rate);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* rate */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* rate */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* rate */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,88 @@
+///
+/// JFunc_void_onLoadData.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "onLoadData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JonLoadData.hpp"
+#include "VideoOrientation.hpp"
+#include "JVideoOrientation.hpp"
+#include "AllPlayerTracks.hpp"
+#include "JAllPlayerTracks.hpp"
+#include "PlayerTrack.hpp"
+#include <vector>
+#include "JPlayerTrack.hpp"
+#include <string>
+#include <optional>
+#include "VideoPlayerTrack.hpp"
+#include "JVideoPlayerTrack.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: onLoadData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_onLoadData: public jni::JavaClass<JFunc_void_onLoadData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onLoadData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_onLoadData` instance holds through JNI.
+     */
+    void invoke(const onLoadData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JonLoadData> /* data */)>("invoke");
+      method(self(), JonLoadData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_onLoadData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_onLoadData_cxx final: public jni::HybridClass<JFunc_void_onLoadData_cxx, JFunc_void_onLoadData> {
+  public:
+    static jni::local_ref<JFunc_void_onLoadData::javaobject> fromCpp(const std::function<void(const onLoadData& /* data */)>& func) {
+      return JFunc_void_onLoadData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_onLoadData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JonLoadData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const onLoadData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onLoadData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onLoadData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_onLoadData_cxx(const std::function<void(const onLoadData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const onLoadData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,82 @@
+///
+/// JFunc_void_onLoadStartData.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "onLoadStartData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JonLoadStartData.hpp"
+#include "SourceType.hpp"
+#include "JSourceType.hpp"
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "JHybridVideoPlayerSourceSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: onLoadStartData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_onLoadStartData: public jni::JavaClass<JFunc_void_onLoadStartData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onLoadStartData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_onLoadStartData` instance holds through JNI.
+     */
+    void invoke(const onLoadStartData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JonLoadStartData> /* data */)>("invoke");
+      method(self(), JonLoadStartData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_onLoadStartData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_onLoadStartData_cxx final: public jni::HybridClass<JFunc_void_onLoadStartData_cxx, JFunc_void_onLoadStartData> {
+  public:
+    static jni::local_ref<JFunc_void_onLoadStartData::javaobject> fromCpp(const std::function<void(const onLoadStartData& /* data */)>& func) {
+      return JFunc_void_onLoadStartData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_onLoadStartData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JonLoadStartData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const onLoadStartData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onLoadStartData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onLoadStartData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_onLoadStartData_cxx(const std::function<void(const onLoadStartData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const onLoadStartData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_onPlaybackStateChangeData.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "onPlaybackStateChangeData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JonPlaybackStateChangeData.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: onPlaybackStateChangeData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_onPlaybackStateChangeData: public jni::JavaClass<JFunc_void_onPlaybackStateChangeData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onPlaybackStateChangeData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_onPlaybackStateChangeData` instance holds through JNI.
+     */
+    void invoke(const onPlaybackStateChangeData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JonPlaybackStateChangeData> /* data */)>("invoke");
+      method(self(), JonPlaybackStateChangeData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_onPlaybackStateChangeData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_onPlaybackStateChangeData_cxx final: public jni::HybridClass<JFunc_void_onPlaybackStateChangeData_cxx, JFunc_void_onPlaybackStateChangeData> {
+  public:
+    static jni::local_ref<JFunc_void_onPlaybackStateChangeData::javaobject> fromCpp(const std::function<void(const onPlaybackStateChangeData& /* data */)>& func) {
+      return JFunc_void_onPlaybackStateChangeData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_onPlaybackStateChangeData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JonPlaybackStateChangeData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const onPlaybackStateChangeData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onPlaybackStateChangeData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onPlaybackStateChangeData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_onPlaybackStateChangeData_cxx(const std::function<void(const onPlaybackStateChangeData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const onPlaybackStateChangeData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_onProgressData.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "onProgressData.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JonProgressData.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(data: onProgressData) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_onProgressData: public jni::JavaClass<JFunc_void_onProgressData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onProgressData;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_onProgressData` instance holds through JNI.
+     */
+    void invoke(const onProgressData& data) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JonProgressData> /* data */)>("invoke");
+      method(self(), JonProgressData::fromCpp(data));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_onProgressData that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_onProgressData_cxx final: public jni::HybridClass<JFunc_void_onProgressData_cxx, JFunc_void_onProgressData> {
+  public:
+    static jni::local_ref<JFunc_void_onProgressData::javaobject> fromCpp(const std::function<void(const onProgressData& /* data */)>& func) {
+      return JFunc_void_onProgressData_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_onProgressData_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JonProgressData> data) {
+      _func(data->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const onProgressData& /* data */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Func_void_onProgressData_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_onProgressData_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_onProgressData_cxx(const std::function<void(const onProgressData& /* data */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const onProgressData& /* data */)> _func;
+  };
+
+} // namespace margelo::nitro::video