react-native-nitro-pose-exercises 1.0.2

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

@@ -0,0 +1,311 @@
+///
+/// JHybridNitroPoseExercisesSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroPoseExercisesSpec.hpp"
+
+// Forward declaration of `SessionStatus` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class SessionStatus; }
+// Forward declaration of `RepData` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct RepData; }
+// Forward declaration of `AngleSnapshot` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct AngleSnapshot; }
+// Forward declaration of `ExercisePhase` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class ExercisePhase; }
+// Forward declaration of `FormFeedback` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct FormFeedback; }
+// Forward declaration of `FormSeverity` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class FormSeverity; }
+// Forward declaration of `HoldProgress` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct HoldProgress; }
+// Forward declaration of `SessionResult` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct SessionResult; }
+// Forward declaration of `Landmark` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct Landmark; }
+// Forward declaration of `ExerciseConfig` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct ExerciseConfig; }
+// Forward declaration of `ExerciseType` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class ExerciseType; }
+// Forward declaration of `AngleDefinition` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct AngleDefinition; }
+// Forward declaration of `PhaseThreshold` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct PhaseThreshold; }
+// Forward declaration of `FormRule` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { struct FormRule; }
+// Forward declaration of `HybridFrameSpec` to properly resolve imports.
+namespace margelo::nitro::camera { class HybridFrameSpec; }
+
+#include "SessionStatus.hpp"
+#include "JSessionStatus.hpp"
+#include "RepData.hpp"
+#include <functional>
+#include <optional>
+#include "JFunc_void_RepData.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JRepData.hpp"
+#include "AngleSnapshot.hpp"
+#include <vector>
+#include "JAngleSnapshot.hpp"
+#include <string>
+#include "ExercisePhase.hpp"
+#include "JFunc_void_ExercisePhase.hpp"
+#include "JExercisePhase.hpp"
+#include "FormFeedback.hpp"
+#include "JFunc_void_FormFeedback.hpp"
+#include "JFormFeedback.hpp"
+#include "FormSeverity.hpp"
+#include "JFormSeverity.hpp"
+#include "HoldProgress.hpp"
+#include "JFunc_void_HoldProgress.hpp"
+#include "JHoldProgress.hpp"
+#include "JFunc_void.hpp"
+#include "SessionResult.hpp"
+#include "JFunc_void_SessionResult.hpp"
+#include "JSessionResult.hpp"
+#include "Landmark.hpp"
+#include "JLandmark.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "ExerciseConfig.hpp"
+#include "JExerciseConfig.hpp"
+#include "ExerciseType.hpp"
+#include "JExerciseType.hpp"
+#include "AngleDefinition.hpp"
+#include "JAngleDefinition.hpp"
+#include "PhaseThreshold.hpp"
+#include "JPhaseThreshold.hpp"
+#include "FormRule.hpp"
+#include "JFormRule.hpp"
+#include <memory>
+#include <VisionCamera/HybridFrameSpec.hpp>
+#include <VisionCamera/JHybridFrameSpec.hpp>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  std::shared_ptr<JHybridNitroPoseExercisesSpec> JHybridNitroPoseExercisesSpec::JavaPart::getJHybridNitroPoseExercisesSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroPoseExercisesSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroPoseExercisesSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroPoseExercisesSpec::CxxPart::jhybriddata> JHybridNitroPoseExercisesSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroPoseExercisesSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroPoseExercisesSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroPoseExercisesSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroPoseExercisesSpec>(castJavaPart);
+  }
+
+  void JHybridNitroPoseExercisesSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroPoseExercisesSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  SessionStatus JHybridNitroPoseExercisesSpec::getStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSessionStatus>()>("getStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::optional<std::function<void(const RepData& /* data */)>> JHybridNitroPoseExercisesSpec::getOnRepComplete() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RepData::javaobject>()>("getOnRepComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RepData& /* data */)> {
+      if (__result->isInstanceOf(JFunc_void_RepData_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RepData_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_RepData, void(RepData)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnRepComplete(const std::optional<std::function<void(const RepData& /* data */)>>& onRepComplete) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RepData::javaobject> /* onRepComplete */)>("setOnRepComplete_cxx");
+    method(_javaPart, onRepComplete.has_value() ? JFunc_void_RepData_cxx::fromCpp(onRepComplete.value()) : nullptr);
+  }
+  std::optional<std::function<void(ExercisePhase /* phase */)>> JHybridNitroPoseExercisesSpec::getOnPhaseChange() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_ExercisePhase::javaobject>()>("getOnPhaseChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(ExercisePhase /* phase */)> {
+      if (__result->isInstanceOf(JFunc_void_ExercisePhase_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_ExercisePhase_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_ExercisePhase, void(ExercisePhase)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnPhaseChange(const std::optional<std::function<void(ExercisePhase /* phase */)>>& onPhaseChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ExercisePhase::javaobject> /* onPhaseChange */)>("setOnPhaseChange_cxx");
+    method(_javaPart, onPhaseChange.has_value() ? JFunc_void_ExercisePhase_cxx::fromCpp(onPhaseChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const FormFeedback& /* feedback */)>> JHybridNitroPoseExercisesSpec::getOnFormFeedback() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_FormFeedback::javaobject>()>("getOnFormFeedback_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const FormFeedback& /* feedback */)> {
+      if (__result->isInstanceOf(JFunc_void_FormFeedback_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_FormFeedback_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_FormFeedback, void(FormFeedback)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnFormFeedback(const std::optional<std::function<void(const FormFeedback& /* feedback */)>>& onFormFeedback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_FormFeedback::javaobject> /* onFormFeedback */)>("setOnFormFeedback_cxx");
+    method(_javaPart, onFormFeedback.has_value() ? JFunc_void_FormFeedback_cxx::fromCpp(onFormFeedback.value()) : nullptr);
+  }
+  std::optional<std::function<void(const HoldProgress& /* progress */)>> JHybridNitroPoseExercisesSpec::getOnHoldProgress() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_HoldProgress::javaobject>()>("getOnHoldProgress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const HoldProgress& /* progress */)> {
+      if (__result->isInstanceOf(JFunc_void_HoldProgress_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_HoldProgress_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_HoldProgress, void(HoldProgress)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnHoldProgress(const std::optional<std::function<void(const HoldProgress& /* progress */)>>& onHoldProgress) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_HoldProgress::javaobject> /* onHoldProgress */)>("setOnHoldProgress_cxx");
+    method(_javaPart, onHoldProgress.has_value() ? JFunc_void_HoldProgress_cxx::fromCpp(onHoldProgress.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroPoseExercisesSpec::getOnPoseLost() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPoseLost_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnPoseLost(const std::optional<std::function<void()>>& onPoseLost) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPoseLost */)>("setOnPoseLost_cxx");
+    method(_javaPart, onPoseLost.has_value() ? JFunc_void_cxx::fromCpp(onPoseLost.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroPoseExercisesSpec::getOnPoseRegained() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPoseRegained_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnPoseRegained(const std::optional<std::function<void()>>& onPoseRegained) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPoseRegained */)>("setOnPoseRegained_cxx");
+    method(_javaPart, onPoseRegained.has_value() ? JFunc_void_cxx::fromCpp(onPoseRegained.value()) : nullptr);
+  }
+  std::optional<std::function<void(const SessionResult& /* result */)>> JHybridNitroPoseExercisesSpec::getOnSessionComplete() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_SessionResult::javaobject>()>("getOnSessionComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const SessionResult& /* result */)> {
+      if (__result->isInstanceOf(JFunc_void_SessionResult_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_SessionResult_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_SessionResult, void(SessionResult)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnSessionComplete(const std::optional<std::function<void(const SessionResult& /* result */)>>& onSessionComplete) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_SessionResult::javaobject> /* onSessionComplete */)>("setOnSessionComplete_cxx");
+    method(_javaPart, onSessionComplete.has_value() ? JFunc_void_SessionResult_cxx::fromCpp(onSessionComplete.value()) : nullptr);
+  }
+  ExercisePhase JHybridNitroPoseExercisesSpec::getCurrentPhase() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JExercisePhase>()>("getCurrentPhase");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  double JHybridNitroPoseExercisesSpec::getRepCount() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getRepCount");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  std::vector<Landmark> JHybridNitroPoseExercisesSpec::getLandmarks() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JLandmark>>()>("getLandmarks");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<Landmark> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridNitroPoseExercisesSpec::initialize(const std::string& modelPath) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */)>("initialize");
+    auto __result = method(_javaPart, jni::make_jstring(modelPath));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridNitroPoseExercisesSpec::release() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("release");
+    method(_javaPart);
+  }
+  void JHybridNitroPoseExercisesSpec::loadExercise(const ExerciseConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JExerciseConfig> /* config */)>("loadExercise");
+    method(_javaPart, JExerciseConfig::fromCpp(config));
+  }
+  void JHybridNitroPoseExercisesSpec::processFrame(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("processFrame");
+    method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
+  }
+  void JHybridNitroPoseExercisesSpec::startSession(double targetReps, double countdownSeconds) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* targetReps */, double /* countdownSeconds */)>("startSession");
+    method(_javaPart, targetReps, countdownSeconds);
+  }
+  void JHybridNitroPoseExercisesSpec::pauseSession() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("pauseSession");
+    method(_javaPart);
+  }
+  void JHybridNitroPoseExercisesSpec::resumeSession() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resumeSession");
+    method(_javaPart);
+  }
+  void JHybridNitroPoseExercisesSpec::stopSession() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopSession");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,87 @@
+///
+/// HybridNitroPoseExercisesSpec.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 "HybridNitroPoseExercisesSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  class JHybridNitroPoseExercisesSpec: public virtual HybridNitroPoseExercisesSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/HybridNitroPoseExercisesSpec;";
+      std::shared_ptr<JHybridNitroPoseExercisesSpec> getJHybridNitroPoseExercisesSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/HybridNitroPoseExercisesSpec$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 JHybridNitroPoseExercisesSpec(const jni::local_ref<JHybridNitroPoseExercisesSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroPoseExercisesSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroPoseExercisesSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroPoseExercisesSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    SessionStatus getStatus() override;
+    std::optional<std::function<void(const RepData& /* data */)>> getOnRepComplete() override;
+    void setOnRepComplete(const std::optional<std::function<void(const RepData& /* data */)>>& onRepComplete) override;
+    std::optional<std::function<void(ExercisePhase /* phase */)>> getOnPhaseChange() override;
+    void setOnPhaseChange(const std::optional<std::function<void(ExercisePhase /* phase */)>>& onPhaseChange) override;
+    std::optional<std::function<void(const FormFeedback& /* feedback */)>> getOnFormFeedback() override;
+    void setOnFormFeedback(const std::optional<std::function<void(const FormFeedback& /* feedback */)>>& onFormFeedback) override;
+    std::optional<std::function<void(const HoldProgress& /* progress */)>> getOnHoldProgress() override;
+    void setOnHoldProgress(const std::optional<std::function<void(const HoldProgress& /* progress */)>>& onHoldProgress) override;
+    std::optional<std::function<void()>> getOnPoseLost() override;
+    void setOnPoseLost(const std::optional<std::function<void()>>& onPoseLost) override;
+    std::optional<std::function<void()>> getOnPoseRegained() override;
+    void setOnPoseRegained(const std::optional<std::function<void()>>& onPoseRegained) override;
+    std::optional<std::function<void(const SessionResult& /* result */)>> getOnSessionComplete() override;
+    void setOnSessionComplete(const std::optional<std::function<void(const SessionResult& /* result */)>>& onSessionComplete) override;
+    ExercisePhase getCurrentPhase() override;
+    double getRepCount() override;
+    std::vector<Landmark> getLandmarks() override;
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> initialize(const std::string& modelPath) override;
+    void release() override;
+    void loadExercise(const ExerciseConfig& config) override;
+    void processFrame(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
+    void startSession(double targetReps, double countdownSeconds) override;
+    void pauseSession() override;
+    void resumeSession() override;
+    void stopSession() override;
+
+  private:
+    jni::global_ref<JHybridNitroPoseExercisesSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,69 @@
+///
+/// JLandmark.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 "Landmark.hpp"
+
+
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Landmark" and the the Kotlin data class "Landmark".
+   */
+  struct JLandmark final: public jni::JavaClass<JLandmark> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/Landmark;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Landmark by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Landmark toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldX = clazz->getField<double>("x");
+      double x = this->getFieldValue(fieldX);
+      static const auto fieldY = clazz->getField<double>("y");
+      double y = this->getFieldValue(fieldY);
+      static const auto fieldZ = clazz->getField<double>("z");
+      double z = this->getFieldValue(fieldZ);
+      static const auto fieldVisibility = clazz->getField<double>("visibility");
+      double visibility = this->getFieldValue(fieldVisibility);
+      return Landmark(
+        x,
+        y,
+        z,
+        visibility
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLandmark::javaobject> fromCpp(const Landmark& value) {
+      using JSignature = JLandmark(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.x,
+        value.y,
+        value.z,
+        value.visibility
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,71 @@
+///
+/// JPhaseThreshold.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 "PhaseThreshold.hpp"
+
+#include "ExercisePhase.hpp"
+#include "JExercisePhase.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PhaseThreshold" and the the Kotlin data class "PhaseThreshold".
+   */
+  struct JPhaseThreshold final: public jni::JavaClass<JPhaseThreshold> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/PhaseThreshold;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PhaseThreshold by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PhaseThreshold toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPhase = clazz->getField<JExercisePhase>("phase");
+      jni::local_ref<JExercisePhase> phase = this->getFieldValue(fieldPhase);
+      static const auto fieldAngleName = clazz->getField<jni::JString>("angleName");
+      jni::local_ref<jni::JString> angleName = this->getFieldValue(fieldAngleName);
+      static const auto fieldMinAngle = clazz->getField<double>("minAngle");
+      double minAngle = this->getFieldValue(fieldMinAngle);
+      static const auto fieldMaxAngle = clazz->getField<double>("maxAngle");
+      double maxAngle = this->getFieldValue(fieldMaxAngle);
+      return PhaseThreshold(
+        phase->toCpp(),
+        angleName->toStdString(),
+        minAngle,
+        maxAngle
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPhaseThreshold::javaobject> fromCpp(const PhaseThreshold& value) {
+      using JSignature = JPhaseThreshold(jni::alias_ref<JExercisePhase>, jni::alias_ref<jni::JString>, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JExercisePhase::fromCpp(value.phase),
+        jni::make_jstring(value.angleName),
+        value.minAngle,
+        value.maxAngle
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

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

@@ -0,0 +1,90 @@
+///
+/// JRepData.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 "RepData.hpp"
+
+#include "AngleSnapshot.hpp"
+#include "JAngleSnapshot.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RepData" and the the Kotlin data class "RepData".
+   */
+  struct JRepData final: public jni::JavaClass<JRepData> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/RepData;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RepData by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RepData toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRepNumber = clazz->getField<double>("repNumber");
+      double repNumber = this->getFieldValue(fieldRepNumber);
+      static const auto fieldDurationMs = clazz->getField<double>("durationMs");
+      double durationMs = this->getFieldValue(fieldDurationMs);
+      static const auto fieldFormScore = clazz->getField<double>("formScore");
+      double formScore = this->getFieldValue(fieldFormScore);
+      static const auto fieldAngles = clazz->getField<jni::JArrayClass<JAngleSnapshot>>("angles");
+      jni::local_ref<jni::JArrayClass<JAngleSnapshot>> angles = this->getFieldValue(fieldAngles);
+      return RepData(
+        repNumber,
+        durationMs,
+        formScore,
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<AngleSnapshot> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(angles)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRepData::javaobject> fromCpp(const RepData& value) {
+      using JSignature = JRepData(double, double, double, jni::alias_ref<jni::JArrayClass<JAngleSnapshot>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.repNumber,
+        value.durationMs,
+        value.formScore,
+        [&](auto&& __input) {
+          size_t __size = __input.size();
+          jni::local_ref<jni::JArrayClass<JAngleSnapshot>> __array = jni::JArrayClass<JAngleSnapshot>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = __input[__i];
+            auto __elementJni = JAngleSnapshot::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.angles)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises