@clarionhq/recorder 0.0.1 → 0.1.0

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

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

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::clarion::recorder {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(state: 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/clarion/recorder/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& state) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* state */)>("invoke");
+      method(self(), jni::make_jstring(state));
+    }
+  };
+
+  /**
+   * 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& /* state */)>& 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> state) {
+      _func(state->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* state */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/clarion/recorder/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& /* state */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* state */)> _func;
+  };
+
+} // namespace margelo::nitro::clarion::recorder

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

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

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

@@ -0,0 +1,207 @@
+///
+/// JHybridClarionRecorderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridClarionRecorderSpec.hpp"
+
+// Forward declaration of `NativeRecorderResult` to properly resolve imports.
+namespace margelo::nitro::clarion::recorder { struct NativeRecorderResult; }
+// Forward declaration of `NativeRecorderConfig` to properly resolve imports.
+namespace margelo::nitro::clarion::recorder { struct NativeRecorderConfig; }
+// Forward declaration of `NativeRecorderError` to properly resolve imports.
+namespace margelo::nitro::clarion::recorder { struct NativeRecorderError; }
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "NativeRecorderResult.hpp"
+#include "JNativeRecorderResult.hpp"
+#include "NativeRecorderConfig.hpp"
+#include "JNativeRecorderConfig.hpp"
+#include <optional>
+#include <functional>
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_double_double.hpp"
+#include "JFunc_void_std__string_double_double_double.hpp"
+#include "NativeRecorderError.hpp"
+#include "JFunc_void_NativeRecorderError.hpp"
+#include "JNativeRecorderError.hpp"
+
+namespace margelo::nitro::clarion::recorder {
+
+  std::shared_ptr<JHybridClarionRecorderSpec> JHybridClarionRecorderSpec::JavaPart::getJHybridClarionRecorderSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridClarionRecorderSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridClarionRecorderSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridClarionRecorderSpec::CxxPart::jhybriddata> JHybridClarionRecorderSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridClarionRecorderSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridClarionRecorderSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridClarionRecorderSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridClarionRecorderSpec>(castJavaPart);
+  }
+
+  void JHybridClarionRecorderSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridClarionRecorderSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridClarionRecorderSpec::getState() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getState");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridClarionRecorderSpec::prepare(const NativeRecorderConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JNativeRecorderConfig> /* config */)>("prepare");
+    auto __result = method(_javaPart, JNativeRecorderConfig::fromCpp(config));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridClarionRecorderSpec::start() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("start");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridClarionRecorderSpec::pause() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pause");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridClarionRecorderSpec::resume() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("resume");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<NativeRecorderResult>> JHybridClarionRecorderSpec::stop() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("stop");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<NativeRecorderResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JNativeRecorderResult>(__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<void>> JHybridClarionRecorderSpec::discard() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("discard");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridClarionRecorderSpec::release() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("release");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  double JHybridClarionRecorderSpec::addStateListener(const std::function<void(const std::string& /* state */)>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_std__string::javaobject> /* listener */)>("addStateListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__string_cxx::fromCpp(listener));
+    return __result;
+  }
+  double JHybridClarionRecorderSpec::addAudioLevelListener(const std::function<void(double /* rms */, double /* peak */)>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_double_double::javaobject> /* listener */)>("addAudioLevelListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_double_double_cxx::fromCpp(listener));
+    return __result;
+  }
+  double JHybridClarionRecorderSpec::addChunkListener(const std::function<void(const std::string& /* uri */, double /* startMs */, double /* endMs */, double /* sizeBytes */)>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_std__string_double_double_double::javaobject> /* listener */)>("addChunkListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__string_double_double_double_cxx::fromCpp(listener));
+    return __result;
+  }
+  double JHybridClarionRecorderSpec::addErrorListener(const std::function<void(const NativeRecorderError& /* error */)>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_NativeRecorderError::javaobject> /* listener */)>("addErrorListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_NativeRecorderError_cxx::fromCpp(listener));
+    return __result;
+  }
+  void JHybridClarionRecorderSpec::removeListener(double id) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* id */)>("removeListener");
+    method(_javaPart, id);
+  }
+  void JHybridClarionRecorderSpec::removeAllListeners() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("removeAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::clarion::recorder

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

@@ -0,0 +1,75 @@
+///
+/// HybridClarionRecorderSpec.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 "HybridClarionRecorderSpec.hpp"
+
+
+
+
+namespace margelo::nitro::clarion::recorder {
+
+  using namespace facebook;
+
+  class JHybridClarionRecorderSpec: public virtual HybridClarionRecorderSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/clarion/recorder/HybridClarionRecorderSpec;";
+      std::shared_ptr<JHybridClarionRecorderSpec> getJHybridClarionRecorderSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/clarion/recorder/HybridClarionRecorderSpec$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 JHybridClarionRecorderSpec(const jni::local_ref<JHybridClarionRecorderSpec::JavaPart>& javaPart):
+      HybridObject(HybridClarionRecorderSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridClarionRecorderSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridClarionRecorderSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getState() override;
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> prepare(const NativeRecorderConfig& config) override;
+    std::shared_ptr<Promise<void>> start() override;
+    std::shared_ptr<Promise<void>> pause() override;
+    std::shared_ptr<Promise<void>> resume() override;
+    std::shared_ptr<Promise<NativeRecorderResult>> stop() override;
+    std::shared_ptr<Promise<void>> discard() override;
+    std::shared_ptr<Promise<void>> release() override;
+    double addStateListener(const std::function<void(const std::string& /* state */)>& listener) override;
+    double addAudioLevelListener(const std::function<void(double /* rms */, double /* peak */)>& listener) override;
+    double addChunkListener(const std::function<void(const std::string& /* uri */, double /* startMs */, double /* endMs */, double /* sizeBytes */)>& listener) override;
+    double addErrorListener(const std::function<void(const NativeRecorderError& /* error */)>& listener) override;
+    void removeListener(double id) override;
+    void removeAllListeners() override;
+
+  private:
+    jni::global_ref<JHybridClarionRecorderSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::clarion::recorder

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

@@ -0,0 +1,90 @@
+///
+/// JNativeRecorderConfig.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 "NativeRecorderConfig.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::clarion::recorder {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NativeRecorderConfig" and the the Kotlin data class "NativeRecorderConfig".
+   */
+  struct JNativeRecorderConfig final: public jni::JavaClass<JNativeRecorderConfig> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/clarion/recorder/NativeRecorderConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NativeRecorderConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NativeRecorderConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSampleRate = clazz->getField<double>("sampleRate");
+      double sampleRate = this->getFieldValue(fieldSampleRate);
+      static const auto fieldChannels = clazz->getField<double>("channels");
+      double channels = this->getFieldValue(fieldChannels);
+      static const auto fieldBitDepth = clazz->getField<double>("bitDepth");
+      double bitDepth = this->getFieldValue(fieldBitDepth);
+      static const auto fieldOutputDirectory = clazz->getField<jni::JString>("outputDirectory");
+      jni::local_ref<jni::JString> outputDirectory = this->getFieldValue(fieldOutputDirectory);
+      static const auto fieldFilenamePrefix = clazz->getField<jni::JString>("filenamePrefix");
+      jni::local_ref<jni::JString> filenamePrefix = this->getFieldValue(fieldFilenamePrefix);
+      static const auto fieldRotateAfterMs = clazz->getField<jni::JDouble>("rotateAfterMs");
+      jni::local_ref<jni::JDouble> rotateAfterMs = this->getFieldValue(fieldRotateAfterMs);
+      static const auto fieldEmitAudioLevel = clazz->getField<jboolean>("emitAudioLevel");
+      jboolean emitAudioLevel = this->getFieldValue(fieldEmitAudioLevel);
+      static const auto fieldAudioLevelIntervalMs = clazz->getField<double>("audioLevelIntervalMs");
+      double audioLevelIntervalMs = this->getFieldValue(fieldAudioLevelIntervalMs);
+      static const auto fieldAacBitrate = clazz->getField<double>("aacBitrate");
+      double aacBitrate = this->getFieldValue(fieldAacBitrate);
+      return NativeRecorderConfig(
+        sampleRate,
+        channels,
+        bitDepth,
+        outputDirectory != nullptr ? std::make_optional(outputDirectory->toStdString()) : std::nullopt,
+        filenamePrefix != nullptr ? std::make_optional(filenamePrefix->toStdString()) : std::nullopt,
+        rotateAfterMs != nullptr ? std::make_optional(rotateAfterMs->value()) : std::nullopt,
+        static_cast<bool>(emitAudioLevel),
+        audioLevelIntervalMs,
+        aacBitrate
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNativeRecorderConfig::javaobject> fromCpp(const NativeRecorderConfig& value) {
+      using JSignature = JNativeRecorderConfig(double, double, double, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>, jboolean, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.sampleRate,
+        value.channels,
+        value.bitDepth,
+        value.outputDirectory.has_value() ? jni::make_jstring(value.outputDirectory.value()) : nullptr,
+        value.filenamePrefix.has_value() ? jni::make_jstring(value.filenamePrefix.value()) : nullptr,
+        value.rotateAfterMs.has_value() ? jni::JDouble::valueOf(value.rotateAfterMs.value()) : nullptr,
+        value.emitAudioLevel,
+        value.audioLevelIntervalMs,
+        value.aacBitrate
+      );
+    }
+  };
+
+} // namespace margelo::nitro::clarion::recorder

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

@@ -0,0 +1,65 @@
+///
+/// JNativeRecorderError.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 "NativeRecorderError.hpp"
+
+#include <string>
+
+namespace margelo::nitro::clarion::recorder {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NativeRecorderError" and the the Kotlin data class "NativeRecorderError".
+   */
+  struct JNativeRecorderError final: public jni::JavaClass<JNativeRecorderError> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/clarion/recorder/NativeRecorderError;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NativeRecorderError by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NativeRecorderError toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCode = clazz->getField<jni::JString>("code");
+      jni::local_ref<jni::JString> code = this->getFieldValue(fieldCode);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      static const auto fieldRecoverable = clazz->getField<jboolean>("recoverable");
+      jboolean recoverable = this->getFieldValue(fieldRecoverable);
+      return NativeRecorderError(
+        code->toStdString(),
+        message->toStdString(),
+        static_cast<bool>(recoverable)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNativeRecorderError::javaobject> fromCpp(const NativeRecorderError& value) {
+      using JSignature = JNativeRecorderError(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.code),
+        jni::make_jstring(value.message),
+        value.recoverable
+      );
+    }
+  };
+
+} // namespace margelo::nitro::clarion::recorder