munim-ffmpeg 0.1.0

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

@@ -0,0 +1,86 @@
+///
+/// JFFmpegSessionResult.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 "FFmpegSessionResult.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::munimffmpeg {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FFmpegSessionResult" and the Kotlin data class "FFmpegSessionResult".
+   */
+  struct JFFmpegSessionResult final: public jni::JavaClass<JFFmpegSessionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/FFmpegSessionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FFmpegSessionResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FFmpegSessionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSessionId = clazz->getField<double>("sessionId");
+      double sessionId = this->getFieldValue(fieldSessionId);
+      static const auto fieldReturnCode = clazz->getField<double>("returnCode");
+      double returnCode = this->getFieldValue(fieldReturnCode);
+      static const auto fieldSuccess = clazz->getField<jboolean>("success");
+      jboolean success = this->getFieldValue(fieldSuccess);
+      static const auto fieldCancelled = clazz->getField<jboolean>("cancelled");
+      jboolean cancelled = this->getFieldValue(fieldCancelled);
+      static const auto fieldState = clazz->getField<jni::JString>("state");
+      jni::local_ref<jni::JString> state = this->getFieldValue(fieldState);
+      static const auto fieldDurationMs = clazz->getField<double>("durationMs");
+      double durationMs = this->getFieldValue(fieldDurationMs);
+      static const auto fieldOutput = clazz->getField<jni::JString>("output");
+      jni::local_ref<jni::JString> output = this->getFieldValue(fieldOutput);
+      static const auto fieldFailStackTrace = clazz->getField<jni::JString>("failStackTrace");
+      jni::local_ref<jni::JString> failStackTrace = this->getFieldValue(fieldFailStackTrace);
+      return FFmpegSessionResult(
+        sessionId,
+        returnCode,
+        static_cast<bool>(success),
+        static_cast<bool>(cancelled),
+        state->toStdString(),
+        durationMs,
+        output->toStdString(),
+        failStackTrace != nullptr ? std::make_optional(failStackTrace->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFFmpegSessionResult::javaobject> fromCpp(const FFmpegSessionResult& value) {
+      using JSignature = JFFmpegSessionResult(double, double, jboolean, jboolean, jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.sessionId,
+        value.returnCode,
+        value.success,
+        value.cancelled,
+        jni::make_jstring(value.state),
+        value.durationMs,
+        jni::make_jstring(value.output),
+        value.failStackTrace.has_value() ? jni::make_jstring(value.failStackTrace.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::munimffmpeg

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 © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::munimffmpeg {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(sessionId: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double sessionId) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* sessionId */)>("invoke");
+      method(self(), sessionId);
+    }
+  };
+
+  /**
+   * 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 /* sessionId */)>& 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 sessionId) {
+      _func(sessionId);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* sessionId */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/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 /* sessionId */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* sessionId */)> _func;
+  };
+
+} // namespace margelo::nitro::munimffmpeg

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

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

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

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

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

@@ -0,0 +1,138 @@
+///
+/// JHybridMunimFfmpegSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridMunimFfmpegSpec.hpp"
+
+// Forward declaration of `FFmpegSessionResult` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { struct FFmpegSessionResult; }
+
+#include <string>
+#include "FFmpegSessionResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JFFmpegSessionResult.hpp"
+#include <optional>
+#include <vector>
+#include <functional>
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_double_double_double_double_double_double_double.hpp"
+#include "JFunc_void_double.hpp"
+
+namespace margelo::nitro::munimffmpeg {
+
+  std::shared_ptr<JHybridMunimFfmpegSpec> JHybridMunimFfmpegSpec::JavaPart::getJHybridMunimFfmpegSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridMunimFfmpegSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridMunimFfmpegSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridMunimFfmpegSpec::CxxPart::jhybriddata> JHybridMunimFfmpegSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridMunimFfmpegSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridMunimFfmpegSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridMunimFfmpegSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridMunimFfmpegSpec>(castJavaPart);
+  }
+
+  void JHybridMunimFfmpegSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridMunimFfmpegSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridMunimFfmpegSpec::getFfmpegVersion() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFfmpegVersion");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+  // Methods
+  std::shared_ptr<Promise<FFmpegSessionResult>> JHybridMunimFfmpegSpec::execute(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>& onStatistics, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* arguments_ */, jni::alias_ref<JFunc_void_std__string::javaobject> /* onLog */, jni::alias_ref<JFunc_void_double_double_double_double_double_double_double::javaobject> /* onStatistics */, jni::alias_ref<JFunc_void_double::javaobject> /* onSessionCreated */)>("execute_cxx");
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(arguments_), onLog.has_value() ? JFunc_void_std__string_cxx::fromCpp(onLog.value()) : nullptr, onStatistics.has_value() ? JFunc_void_double_double_double_double_double_double_double_cxx::fromCpp(onStatistics.value()) : nullptr, onSessionCreated.has_value() ? JFunc_void_double_cxx::fromCpp(onSessionCreated.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<FFmpegSessionResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JFFmpegSessionResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<FFmpegSessionResult>> JHybridMunimFfmpegSpec::probe(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* arguments_ */, jni::alias_ref<JFunc_void_std__string::javaobject> /* onLog */, jni::alias_ref<JFunc_void_double::javaobject> /* onSessionCreated */)>("probe_cxx");
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(arguments_), onLog.has_value() ? JFunc_void_std__string_cxx::fromCpp(onLog.value()) : nullptr, onSessionCreated.has_value() ? JFunc_void_double_cxx::fromCpp(onSessionCreated.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<FFmpegSessionResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JFFmpegSessionResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::string>> JHybridMunimFfmpegSpec::getMediaInformation(const std::string& path) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* path */)>("getMediaInformation");
+    auto __result = method(_javaPart, jni::make_jstring(path));
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridMunimFfmpegSpec::cancel(std::optional<double> sessionId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* sessionId */)>("cancel");
+    method(_javaPart, sessionId.has_value() ? jni::JDouble::valueOf(sessionId.value()) : nullptr);
+  }
+  void JHybridMunimFfmpegSpec::cancelAll() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("cancelAll");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::munimffmpeg

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

@@ -0,0 +1,67 @@
+///
+/// HybridMunimFfmpegSpec.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 "HybridMunimFfmpegSpec.hpp"
+
+
+
+
+namespace margelo::nitro::munimffmpeg {
+
+  using namespace facebook;
+
+  class JHybridMunimFfmpegSpec: public virtual HybridMunimFfmpegSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/HybridMunimFfmpegSpec;";
+      std::shared_ptr<JHybridMunimFfmpegSpec> getJHybridMunimFfmpegSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/HybridMunimFfmpegSpec$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 JHybridMunimFfmpegSpec(const jni::local_ref<JHybridMunimFfmpegSpec::JavaPart>& javaPart):
+      HybridObject(HybridMunimFfmpegSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridMunimFfmpegSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridMunimFfmpegSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getFfmpegVersion() override;
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<FFmpegSessionResult>> execute(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>& onStatistics, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) override;
+    std::shared_ptr<Promise<FFmpegSessionResult>> probe(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) override;
+    std::shared_ptr<Promise<std::string>> getMediaInformation(const std::string& path) override;
+    void cancel(std::optional<double> sessionId) override;
+    void cancelAll() override;
+
+  private:
+    jni::global_ref<JHybridMunimFfmpegSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::munimffmpeg

package/nitrogen/generated/android/kotlin/com/margelo/nitro/munimffmpeg/FFmpegSessionResult.kt

@@ -0,0 +1,86 @@
+///
+/// FFmpegSessionResult.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.munimffmpeg
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "FFmpegSessionResult".
+ */
+@DoNotStrip
+@Keep
+data class FFmpegSessionResult(
+  @DoNotStrip
+  @Keep
+  val sessionId: Double,
+  @DoNotStrip
+  @Keep
+  val returnCode: Double,
+  @DoNotStrip
+  @Keep
+  val success: Boolean,
+  @DoNotStrip
+  @Keep
+  val cancelled: Boolean,
+  @DoNotStrip
+  @Keep
+  val state: String,
+  @DoNotStrip
+  @Keep
+  val durationMs: Double,
+  @DoNotStrip
+  @Keep
+  val output: String,
+  @DoNotStrip
+  @Keep
+  val failStackTrace: String?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is FFmpegSessionResult) return false
+    return Objects.deepEquals(this.sessionId, other.sessionId)
+      && Objects.deepEquals(this.returnCode, other.returnCode)
+      && Objects.deepEquals(this.success, other.success)
+      && Objects.deepEquals(this.cancelled, other.cancelled)
+      && Objects.deepEquals(this.state, other.state)
+      && Objects.deepEquals(this.durationMs, other.durationMs)
+      && Objects.deepEquals(this.output, other.output)
+      && Objects.deepEquals(this.failStackTrace, other.failStackTrace)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      sessionId,
+      returnCode,
+      success,
+      cancelled,
+      state,
+      durationMs,
+      output,
+      failStackTrace
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(sessionId: Double, returnCode: Double, success: Boolean, cancelled: Boolean, state: String, durationMs: Double, output: String, failStackTrace: String?): FFmpegSessionResult {
+      return FFmpegSessionResult(sessionId, returnCode, success, cancelled, state, durationMs, output, failStackTrace)
+    }
+  }
+}