@renegades/react-native-tickle 0.1.0

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

@@ -0,0 +1,94 @@
+///
+/// JHapticEvent.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 "HapticEvent.hpp"
+
+#include "HapticEventParameter.hpp"
+#include "HapticEventType.hpp"
+#include "HapticParameterType.hpp"
+#include "JHapticEventParameter.hpp"
+#include "JHapticEventType.hpp"
+#include "JHapticParameterType.hpp"
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HapticEvent" and the the Kotlin data class "HapticEvent".
+   */
+  struct JHapticEvent final: public jni::JavaClass<JHapticEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HapticEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JHapticEventType>("type");
+      jni::local_ref<JHapticEventType> type = this->getFieldValue(fieldType);
+      static const auto fieldParameters = clazz->getField<jni::JArrayClass<JHapticEventParameter>>("parameters");
+      jni::local_ref<jni::JArrayClass<JHapticEventParameter>> parameters = this->getFieldValue(fieldParameters);
+      static const auto fieldRelativeTime = clazz->getField<double>("relativeTime");
+      double relativeTime = this->getFieldValue(fieldRelativeTime);
+      static const auto fieldDuration = clazz->getField<jni::JDouble>("duration");
+      jni::local_ref<jni::JDouble> duration = this->getFieldValue(fieldDuration);
+      return HapticEvent(
+        type->toCpp(),
+        [&]() {
+          size_t __size = parameters->size();
+          std::vector<HapticEventParameter> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = parameters->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        relativeTime,
+        duration != nullptr ? std::make_optional(duration->value()) : 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<JHapticEvent::javaobject> fromCpp(const HapticEvent& value) {
+      using JSignature = JHapticEvent(jni::alias_ref<JHapticEventType>, jni::alias_ref<jni::JArrayClass<JHapticEventParameter>>, double, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JHapticEventType::fromCpp(value.type),
+        [&]() {
+          size_t __size = value.parameters.size();
+          jni::local_ref<jni::JArrayClass<JHapticEventParameter>> __array = jni::JArrayClass<JHapticEventParameter>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.parameters[__i];
+            auto __elementJni = JHapticEventParameter::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.relativeTime,
+        value.duration.has_value() ? jni::JDouble::valueOf(value.duration.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,62 @@
+///
+/// JHapticEventParameter.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 "HapticEventParameter.hpp"
+
+#include "HapticParameterType.hpp"
+#include "JHapticParameterType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HapticEventParameter" and the the Kotlin data class "HapticEventParameter".
+   */
+  struct JHapticEventParameter final: public jni::JavaClass<JHapticEventParameter> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticEventParameter;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HapticEventParameter by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticEventParameter toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JHapticParameterType>("type");
+      jni::local_ref<JHapticParameterType> type = this->getFieldValue(fieldType);
+      static const auto fieldValue = clazz->getField<double>("value");
+      double value = this->getFieldValue(fieldValue);
+      return HapticEventParameter(
+        type->toCpp(),
+        value
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHapticEventParameter::javaobject> fromCpp(const HapticEventParameter& value) {
+      using JSignature = JHapticEventParameter(jni::alias_ref<JHapticParameterType>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JHapticParameterType::fromCpp(value.type),
+        value.value
+      );
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,58 @@
+///
+/// JHapticEventType.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 "HapticEventType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HapticEventType" and the the Kotlin enum "HapticEventType".
+   */
+  struct JHapticEventType final: public jni::JavaClass<JHapticEventType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticEventType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HapticEventType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticEventType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HapticEventType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHapticEventType> fromCpp(HapticEventType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HapticEventType::TRANSIENT:
+          static const auto fieldTRANSIENT = clazz->getStaticField<JHapticEventType>("TRANSIENT");
+          return clazz->getStaticFieldValue(fieldTRANSIENT);
+        case HapticEventType::CONTINUOUS:
+          static const auto fieldCONTINUOUS = clazz->getStaticField<JHapticEventType>("CONTINUOUS");
+          return clazz->getStaticFieldValue(fieldCONTINUOUS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,67 @@
+///
+/// JHapticImpactStyle.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 "HapticImpactStyle.hpp"
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HapticImpactStyle" and the the Kotlin enum "HapticImpactStyle".
+   */
+  struct JHapticImpactStyle final: public jni::JavaClass<JHapticImpactStyle> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticImpactStyle;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HapticImpactStyle.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticImpactStyle toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HapticImpactStyle>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHapticImpactStyle> fromCpp(HapticImpactStyle value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HapticImpactStyle::RIGID:
+          static const auto fieldRIGID = clazz->getStaticField<JHapticImpactStyle>("RIGID");
+          return clazz->getStaticFieldValue(fieldRIGID);
+        case HapticImpactStyle::HEAVY:
+          static const auto fieldHEAVY = clazz->getStaticField<JHapticImpactStyle>("HEAVY");
+          return clazz->getStaticFieldValue(fieldHEAVY);
+        case HapticImpactStyle::MEDIUM:
+          static const auto fieldMEDIUM = clazz->getStaticField<JHapticImpactStyle>("MEDIUM");
+          return clazz->getStaticFieldValue(fieldMEDIUM);
+        case HapticImpactStyle::LIGHT:
+          static const auto fieldLIGHT = clazz->getStaticField<JHapticImpactStyle>("LIGHT");
+          return clazz->getStaticFieldValue(fieldLIGHT);
+        case HapticImpactStyle::SOFT:
+          static const auto fieldSOFT = clazz->getStaticField<JHapticImpactStyle>("SOFT");
+          return clazz->getStaticFieldValue(fieldSOFT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,61 @@
+///
+/// JHapticNotificationType.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 "HapticNotificationType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HapticNotificationType" and the the Kotlin enum "HapticNotificationType".
+   */
+  struct JHapticNotificationType final: public jni::JavaClass<JHapticNotificationType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticNotificationType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HapticNotificationType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticNotificationType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HapticNotificationType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHapticNotificationType> fromCpp(HapticNotificationType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HapticNotificationType::ERROR:
+          static const auto fieldERROR = clazz->getStaticField<JHapticNotificationType>("ERROR");
+          return clazz->getStaticFieldValue(fieldERROR);
+        case HapticNotificationType::SUCCESS:
+          static const auto fieldSUCCESS = clazz->getStaticField<JHapticNotificationType>("SUCCESS");
+          return clazz->getStaticFieldValue(fieldSUCCESS);
+        case HapticNotificationType::WARNING:
+          static const auto fieldWARNING = clazz->getStaticField<JHapticNotificationType>("WARNING");
+          return clazz->getStaticFieldValue(fieldWARNING);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,58 @@
+///
+/// JHapticParameterType.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 "HapticParameterType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "HapticParameterType" and the the Kotlin enum "HapticParameterType".
+   */
+  struct JHapticParameterType final: public jni::JavaClass<JHapticParameterType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticParameterType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum HapticParameterType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticParameterType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<HapticParameterType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JHapticParameterType> fromCpp(HapticParameterType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case HapticParameterType::INTENSITY:
+          static const auto fieldINTENSITY = clazz->getStaticField<JHapticParameterType>("INTENSITY");
+          return clazz->getStaticFieldValue(fieldINTENSITY);
+        case HapticParameterType::SHARPNESS:
+          static const auto fieldSHARPNESS = clazz->getStaticField<JHapticParameterType>("SHARPNESS");
+          return clazz->getStaticFieldValue(fieldSHARPNESS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,162 @@
+///
+/// JHybridTickleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridTickleSpec.hpp"
+
+// Forward declaration of `HapticEvent` to properly resolve imports.
+namespace margelo::nitro::tickle { struct HapticEvent; }
+// Forward declaration of `HapticEventType` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticEventType; }
+// Forward declaration of `HapticEventParameter` to properly resolve imports.
+namespace margelo::nitro::tickle { struct HapticEventParameter; }
+// Forward declaration of `HapticParameterType` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticParameterType; }
+// Forward declaration of `HapticCurve` to properly resolve imports.
+namespace margelo::nitro::tickle { struct HapticCurve; }
+// Forward declaration of `HapticCurveControlPoint` to properly resolve imports.
+namespace margelo::nitro::tickle { struct HapticCurveControlPoint; }
+// Forward declaration of `HapticImpactStyle` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticImpactStyle; }
+// Forward declaration of `HapticNotificationType` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticNotificationType; }
+
+#include "HapticEvent.hpp"
+#include <vector>
+#include "JHapticEvent.hpp"
+#include "HapticEventType.hpp"
+#include "JHapticEventType.hpp"
+#include "HapticEventParameter.hpp"
+#include "JHapticEventParameter.hpp"
+#include "HapticParameterType.hpp"
+#include "JHapticParameterType.hpp"
+#include <optional>
+#include "HapticCurve.hpp"
+#include "JHapticCurve.hpp"
+#include "HapticCurveControlPoint.hpp"
+#include "JHapticCurveControlPoint.hpp"
+#include <string>
+#include "HapticImpactStyle.hpp"
+#include "JHapticImpactStyle.hpp"
+#include "HapticNotificationType.hpp"
+#include "JHapticNotificationType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  jni::local_ref<JHybridTickleSpec::jhybriddata> JHybridTickleSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridTickleSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridTickleSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridTickleSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridTickleSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridTickleSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridTickleSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridTickleSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridTickleSpec::startHaptic(const std::vector<HapticEvent>& events, const std::vector<HapticCurve>& curves) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JHapticEvent>> /* events */, jni::alias_ref<jni::JArrayClass<JHapticCurve>> /* curves */)>("startHaptic");
+    method(_javaPart, [&]() {
+      size_t __size = events.size();
+      jni::local_ref<jni::JArrayClass<JHapticEvent>> __array = jni::JArrayClass<JHapticEvent>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = events[__i];
+        auto __elementJni = JHapticEvent::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), [&]() {
+      size_t __size = curves.size();
+      jni::local_ref<jni::JArrayClass<JHapticCurve>> __array = jni::JArrayClass<JHapticCurve>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = curves[__i];
+        auto __elementJni = JHapticCurve::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+  }
+  void JHybridTickleSpec::stopAllHaptics() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopAllHaptics");
+    method(_javaPart);
+  }
+  void JHybridTickleSpec::initializeEngine() {
+    static const auto method = javaClassStatic()->getMethod<void()>("initializeEngine");
+    method(_javaPart);
+  }
+  void JHybridTickleSpec::destroyEngine() {
+    static const auto method = javaClassStatic()->getMethod<void()>("destroyEngine");
+    method(_javaPart);
+  }
+  void JHybridTickleSpec::createContinuousPlayer(const std::string& playerId, double initialIntensity, double initialSharpness) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playerId */, double /* initialIntensity */, double /* initialSharpness */)>("createContinuousPlayer");
+    method(_javaPart, jni::make_jstring(playerId), initialIntensity, initialSharpness);
+  }
+  void JHybridTickleSpec::startContinuousPlayer(const std::string& playerId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playerId */)>("startContinuousPlayer");
+    method(_javaPart, jni::make_jstring(playerId));
+  }
+  void JHybridTickleSpec::updateContinuousPlayer(const std::string& playerId, double intensityControl, double sharpnessControl) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playerId */, double /* intensityControl */, double /* sharpnessControl */)>("updateContinuousPlayer");
+    method(_javaPart, jni::make_jstring(playerId), intensityControl, sharpnessControl);
+  }
+  void JHybridTickleSpec::stopContinuousPlayer(const std::string& playerId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playerId */)>("stopContinuousPlayer");
+    method(_javaPart, jni::make_jstring(playerId));
+  }
+  void JHybridTickleSpec::destroyContinuousPlayer(const std::string& playerId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* playerId */)>("destroyContinuousPlayer");
+    method(_javaPart, jni::make_jstring(playerId));
+  }
+  void JHybridTickleSpec::setHapticsEnabled(bool enabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setHapticsEnabled");
+    method(_javaPart, enabled);
+  }
+  bool JHybridTickleSpec::getHapticsEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getHapticsEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridTickleSpec::triggerImpact(HapticImpactStyle style) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHapticImpactStyle> /* style */)>("triggerImpact");
+    method(_javaPart, JHapticImpactStyle::fromCpp(style));
+  }
+  void JHybridTickleSpec::triggerNotification(HapticNotificationType type) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHapticNotificationType> /* type */)>("triggerNotification");
+    method(_javaPart, JHapticNotificationType::fromCpp(type));
+  }
+  void JHybridTickleSpec::triggerSelection() {
+    static const auto method = javaClassStatic()->getMethod<void()>("triggerSelection");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::tickle

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

@@ -0,0 +1,79 @@
+///
+/// HybridTickleSpec.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 "HybridTickleSpec.hpp"
+
+
+
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  class JHybridTickleSpec: public jni::HybridClass<JHybridTickleSpec, JHybridObject>,
+                           public virtual HybridTickleSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HybridTickleSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridTickleSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridTickleSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridTickleSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridTickleSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void startHaptic(const std::vector<HapticEvent>& events, const std::vector<HapticCurve>& curves) override;
+    void stopAllHaptics() override;
+    void initializeEngine() override;
+    void destroyEngine() override;
+    void createContinuousPlayer(const std::string& playerId, double initialIntensity, double initialSharpness) override;
+    void startContinuousPlayer(const std::string& playerId) override;
+    void updateContinuousPlayer(const std::string& playerId, double intensityControl, double sharpnessControl) override;
+    void stopContinuousPlayer(const std::string& playerId) override;
+    void destroyContinuousPlayer(const std::string& playerId) override;
+    void setHapticsEnabled(bool enabled) override;
+    bool getHapticsEnabled() override;
+    void triggerImpact(HapticImpactStyle style) override;
+    void triggerNotification(HapticNotificationType type) override;
+    void triggerSelection() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridTickleSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::tickle