@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_MarkerDragEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "MarkerDragEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JMarkerDragEvent.hpp"
+#include <string>
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: MarkerDragEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_MarkerDragEvent: public jni::JavaClass<JFunc_void_MarkerDragEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_MarkerDragEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_MarkerDragEvent` instance holds through JNI.
+     */
+    void invoke(const MarkerDragEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMarkerDragEvent> /* event */)>("invoke");
+      method(self(), JMarkerDragEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_MarkerDragEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_MarkerDragEvent_cxx final: public jni::HybridClass<JFunc_void_MarkerDragEvent_cxx, JFunc_void_MarkerDragEvent> {
+  public:
+    static jni::local_ref<JFunc_void_MarkerDragEvent::javaobject> fromCpp(const std::function<void(const MarkerDragEvent& /* event */)>& func) {
+      return JFunc_void_MarkerDragEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_MarkerDragEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JMarkerDragEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const MarkerDragEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_MarkerDragEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_MarkerDragEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_MarkerDragEvent_cxx(const std::function<void(const MarkerDragEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const MarkerDragEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_MarkerPressEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "MarkerPressEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JMarkerPressEvent.hpp"
+#include <string>
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: MarkerPressEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_MarkerPressEvent: public jni::JavaClass<JFunc_void_MarkerPressEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_MarkerPressEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_MarkerPressEvent` instance holds through JNI.
+     */
+    void invoke(const MarkerPressEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMarkerPressEvent> /* event */)>("invoke");
+      method(self(), JMarkerPressEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_MarkerPressEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_MarkerPressEvent_cxx final: public jni::HybridClass<JFunc_void_MarkerPressEvent_cxx, JFunc_void_MarkerPressEvent> {
+  public:
+    static jni::local_ref<JFunc_void_MarkerPressEvent::javaobject> fromCpp(const std::function<void(const MarkerPressEvent& /* event */)>& func) {
+      return JFunc_void_MarkerPressEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_MarkerPressEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JMarkerPressEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const MarkerPressEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_MarkerPressEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_MarkerPressEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_MarkerPressEvent_cxx(const std::function<void(const MarkerPressEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const MarkerPressEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,79 @@
+///
+/// JFunc_void_RegionChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "RegionChangeEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JRegionChangeEvent.hpp"
+#include "Region.hpp"
+#include "JRegion.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(region: RegionChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_RegionChangeEvent: public jni::JavaClass<JFunc_void_RegionChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_RegionChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_RegionChangeEvent` instance holds through JNI.
+     */
+    void invoke(const RegionChangeEvent& region) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRegionChangeEvent> /* region */)>("invoke");
+      method(self(), JRegionChangeEvent::fromCpp(region));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_RegionChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_RegionChangeEvent_cxx final: public jni::HybridClass<JFunc_void_RegionChangeEvent_cxx, JFunc_void_RegionChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_RegionChangeEvent::javaobject> fromCpp(const std::function<void(const RegionChangeEvent& /* region */)>& func) {
+      return JFunc_void_RegionChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_RegionChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JRegionChangeEvent> region) {
+      _func(region->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const RegionChangeEvent& /* region */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Func_void_RegionChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_RegionChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_RegionChangeEvent_cxx(const std::function<void(const RegionChangeEvent& /* region */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const RegionChangeEvent& /* region */)> _func;
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,59 @@
+///
+/// JHybridNitroMapConfigSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroMapConfigSpec.hpp"
+
+// Forward declaration of `MapProvider` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapProvider; }
+
+#include <string>
+#include "MapProvider.hpp"
+#include "JMapProvider.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  jni::local_ref<JHybridNitroMapConfigSpec::jhybriddata> JHybridNitroMapConfigSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroMapConfigSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroMapConfigSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroMapConfigSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroMapConfigSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNitroMapConfigSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridNitroMapConfigSpec::NitroMapInitialize(const std::string& apiKey, MapProvider provider) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* apiKey */, jni::alias_ref<JMapProvider> /* provider */)>("NitroMapInitialize");
+    method(_javaPart, jni::make_jstring(apiKey), JMapProvider::fromCpp(provider));
+  }
+  bool JHybridNitroMapConfigSpec::IsNitroMapInitialized() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("IsNitroMapInitialized");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,66 @@
+///
+/// HybridNitroMapConfigSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroMapConfigSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  class JHybridNitroMapConfigSpec: public jni::HybridClass<JHybridNitroMapConfigSpec, JHybridObject>,
+                                   public virtual HybridNitroMapConfigSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/HybridNitroMapConfigSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroMapConfigSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroMapConfigSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroMapConfigSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroMapConfigSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void NitroMapInitialize(const std::string& apiKey, MapProvider provider) override;
+    bool IsNitroMapInitialized() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroMapConfigSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitromap