react-native-camera-vision-pixel-colors 0.1.0

package/nitrogen/generated/android/CameraVisionPixelColors+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// CameraVisionPixelColors+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/CameraVisionPixelColors+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 CameraVisionPixelColors is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/CameraVisionPixelColorsOnLoad.cpp

@@ -0,0 +1,44 @@
+///
+/// CameraVisionPixelColorsOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_CAMERAVISIONPIXELCOLORS_WITH_GENERATED_CMAKE_PROJECT
+#error CameraVisionPixelColorsOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "CameraVisionPixelColorsOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridCameraVisionPixelColorsSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::cameravisionpixelcolors;
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    margelo::nitro::cameravisionpixelcolors::JHybridCameraVisionPixelColorsSpec::registerNatives();
+
+    // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "CameraVisionPixelColors",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridCameraVisionPixelColorsSpec::javaobject> object("com/margelo/nitro/cameravisionpixelcolors/HybridCameraVisionPixelColors");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+  });
+}
+
+} // namespace margelo::nitro::cameravisionpixelcolors

package/nitrogen/generated/android/CameraVisionPixelColorsOnLoad.hpp

@@ -0,0 +1,25 @@
+///
+/// CameraVisionPixelColorsOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  /**
+   * Initializes the native (C++) part of CameraVisionPixelColors, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return margelo::nitro::cameravisionpixelcolors::initialize(vm);
+   * }
+   * ```
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,90 @@
+///
+/// JHybridCameraVisionPixelColorsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridCameraVisionPixelColorsSpec.hpp"
+
+// Forward declaration of `PixelColorsResult` to properly resolve imports.
+namespace margelo::nitro::cameravisionpixelcolors { struct PixelColorsResult; }
+// Forward declaration of `RGBColor` to properly resolve imports.
+namespace margelo::nitro::cameravisionpixelcolors { struct RGBColor; }
+// Forward declaration of `MotionResult` to properly resolve imports.
+namespace margelo::nitro::cameravisionpixelcolors { struct MotionResult; }
+// Forward declaration of `ImageData` to properly resolve imports.
+namespace margelo::nitro::cameravisionpixelcolors { struct ImageData; }
+
+#include "PixelColorsResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPixelColorsResult.hpp"
+#include "RGBColor.hpp"
+#include <vector>
+#include "JRGBColor.hpp"
+#include "MotionResult.hpp"
+#include <optional>
+#include "JMotionResult.hpp"
+#include "ImageData.hpp"
+#include "JImageData.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  jni::local_ref<JHybridCameraVisionPixelColorsSpec::jhybriddata> JHybridCameraVisionPixelColorsSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridCameraVisionPixelColorsSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridCameraVisionPixelColorsSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridCameraVisionPixelColorsSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridCameraVisionPixelColorsSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridCameraVisionPixelColorsSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridCameraVisionPixelColorsSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridCameraVisionPixelColorsSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<PixelColorsResult>> JHybridCameraVisionPixelColorsSpec::analyzeImageAsync(const ImageData& image) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JImageData> /* image */)>("analyzeImageAsync");
+    auto __result = method(_javaPart, JImageData::fromCpp(image));
+    return [&]() {
+      auto __promise = Promise<PixelColorsResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPixelColorsResult>(__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;
+    }();
+  }
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,66 @@
+///
+/// HybridCameraVisionPixelColorsSpec.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 "HybridCameraVisionPixelColorsSpec.hpp"
+
+
+
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  using namespace facebook;
+
+  class JHybridCameraVisionPixelColorsSpec: public jni::HybridClass<JHybridCameraVisionPixelColorsSpec, JHybridObject>,
+                                            public virtual HybridCameraVisionPixelColorsSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/cameravisionpixelcolors/HybridCameraVisionPixelColorsSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridCameraVisionPixelColorsSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridCameraVisionPixelColorsSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridCameraVisionPixelColorsSpec() 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<JHybridCameraVisionPixelColorsSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<PixelColorsResult>> analyzeImageAsync(const ImageData& image) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridCameraVisionPixelColorsSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,66 @@
+///
+/// JImageData.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 "ImageData.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ImageData" and the the Kotlin data class "ImageData".
+   */
+  struct JImageData final: public jni::JavaClass<JImageData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/cameravisionpixelcolors/ImageData;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ImageData by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ImageData toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      static const auto fieldData = clazz->getField<JArrayBuffer::javaobject>("data");
+      jni::local_ref<JArrayBuffer::javaobject> data = this->getFieldValue(fieldData);
+      return ImageData(
+        width,
+        height,
+        data->cthis()->getArrayBuffer()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JImageData::javaobject> fromCpp(const ImageData& value) {
+      using JSignature = JImageData(double, double, jni::alias_ref<JArrayBuffer::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.width,
+        value.height,
+        JArrayBuffer::wrap(value.data)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,61 @@
+///
+/// JMotionResult.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 "MotionResult.hpp"
+
+
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MotionResult" and the the Kotlin data class "MotionResult".
+   */
+  struct JMotionResult final: public jni::JavaClass<JMotionResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/cameravisionpixelcolors/MotionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MotionResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MotionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldScore = clazz->getField<double>("score");
+      double score = this->getFieldValue(fieldScore);
+      static const auto fieldHasMotion = clazz->getField<jboolean>("hasMotion");
+      jboolean hasMotion = this->getFieldValue(fieldHasMotion);
+      return MotionResult(
+        score,
+        static_cast<bool>(hasMotion)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMotionResult::javaobject> fromCpp(const MotionResult& value) {
+      using JSignature = JMotionResult(double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.score,
+        value.hasMotion
+      );
+    }
+  };
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,114 @@
+///
+/// JPixelColorsResult.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 "PixelColorsResult.hpp"
+
+#include "JMotionResult.hpp"
+#include "JRGBColor.hpp"
+#include "MotionResult.hpp"
+#include "RGBColor.hpp"
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PixelColorsResult" and the the Kotlin data class "PixelColorsResult".
+   */
+  struct JPixelColorsResult final: public jni::JavaClass<JPixelColorsResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/cameravisionpixelcolors/PixelColorsResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PixelColorsResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PixelColorsResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUniqueColorCount = clazz->getField<double>("uniqueColorCount");
+      double uniqueColorCount = this->getFieldValue(fieldUniqueColorCount);
+      static const auto fieldTopColors = clazz->getField<jni::JArrayClass<JRGBColor>>("topColors");
+      jni::local_ref<jni::JArrayClass<JRGBColor>> topColors = this->getFieldValue(fieldTopColors);
+      static const auto fieldBrightestColors = clazz->getField<jni::JArrayClass<JRGBColor>>("brightestColors");
+      jni::local_ref<jni::JArrayClass<JRGBColor>> brightestColors = this->getFieldValue(fieldBrightestColors);
+      static const auto fieldMotion = clazz->getField<JMotionResult>("motion");
+      jni::local_ref<JMotionResult> motion = this->getFieldValue(fieldMotion);
+      static const auto fieldRoiApplied = clazz->getField<jni::JBoolean>("roiApplied");
+      jni::local_ref<jni::JBoolean> roiApplied = this->getFieldValue(fieldRoiApplied);
+      return PixelColorsResult(
+        uniqueColorCount,
+        [&]() {
+          size_t __size = topColors->size();
+          std::vector<RGBColor> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = topColors->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        [&]() {
+          size_t __size = brightestColors->size();
+          std::vector<RGBColor> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = brightestColors->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        motion != nullptr ? std::make_optional(motion->toCpp()) : std::nullopt,
+        roiApplied != nullptr ? std::make_optional(static_cast<bool>(roiApplied->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<JPixelColorsResult::javaobject> fromCpp(const PixelColorsResult& value) {
+      using JSignature = JPixelColorsResult(double, jni::alias_ref<jni::JArrayClass<JRGBColor>>, jni::alias_ref<jni::JArrayClass<JRGBColor>>, jni::alias_ref<JMotionResult>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.uniqueColorCount,
+        [&]() {
+          size_t __size = value.topColors.size();
+          jni::local_ref<jni::JArrayClass<JRGBColor>> __array = jni::JArrayClass<JRGBColor>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.topColors[__i];
+            auto __elementJni = JRGBColor::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        [&]() {
+          size_t __size = value.brightestColors.size();
+          jni::local_ref<jni::JArrayClass<JRGBColor>> __array = jni::JArrayClass<JRGBColor>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.brightestColors[__i];
+            auto __elementJni = JRGBColor::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.motion.has_value() ? JMotionResult::fromCpp(value.motion.value()) : nullptr,
+        value.roiApplied.has_value() ? jni::JBoolean::valueOf(value.roiApplied.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::cameravisionpixelcolors

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

@@ -0,0 +1,65 @@
+///
+/// JRGBColor.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 "RGBColor.hpp"
+
+
+
+namespace margelo::nitro::cameravisionpixelcolors {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RGBColor" and the the Kotlin data class "RGBColor".
+   */
+  struct JRGBColor final: public jni::JavaClass<JRGBColor> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/cameravisionpixelcolors/RGBColor;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RGBColor by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RGBColor toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldR = clazz->getField<double>("r");
+      double r = this->getFieldValue(fieldR);
+      static const auto fieldG = clazz->getField<double>("g");
+      double g = this->getFieldValue(fieldG);
+      static const auto fieldB = clazz->getField<double>("b");
+      double b = this->getFieldValue(fieldB);
+      return RGBColor(
+        r,
+        g,
+        b
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JRGBColor::javaobject> fromCpp(const RGBColor& value) {
+      using JSignature = JRGBColor(double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.r,
+        value.g,
+        value.b
+      );
+    }
+  };
+
+} // namespace margelo::nitro::cameravisionpixelcolors

package/nitrogen/generated/android/kotlin/com/margelo/nitro/cameravisionpixelcolors/CameraVisionPixelColorsOnLoad.kt

@@ -0,0 +1,35 @@
+///
+/// CameraVisionPixelColorsOnLoad.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.cameravisionpixelcolors
+
+import android.util.Log
+
+internal class CameraVisionPixelColorsOnLoad {
+  companion object {
+    private const val TAG = "CameraVisionPixelColorsOnLoad"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "CameraVisionPixelColors".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading CameraVisionPixelColors C++ library...")
+        System.loadLibrary("CameraVisionPixelColors")
+        Log.i(TAG, "Successfully loaded CameraVisionPixelColors C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load CameraVisionPixelColors C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e)
+        throw e
+      }
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/cameravisionpixelcolors/HybridCameraVisionPixelColorsSpec.kt

@@ -0,0 +1,58 @@
+///
+/// HybridCameraVisionPixelColorsSpec.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.cameravisionpixelcolors
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the CameraVisionPixelColors HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of CameraVisionPixelColors.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridCameraVisionPixelColorsSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject CameraVisionPixelColors]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun analyzeImageAsync(image: ImageData): Promise<PixelColorsResult>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridCameraVisionPixelColorsSpec"
+  }
+}