react-native-google-maps-plus 0.1.0 → 1.0.1

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

@@ -0,0 +1,485 @@
+///
+/// JHybridGoogleMapsNitroViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridGoogleMapsNitroViewSpec.hpp"
+
+// Forward declaration of `RNCamera` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNCamera; }
+// Forward declaration of `RNLatLng` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNLatLng; }
+// Forward declaration of `RNUserInterfaceStyle` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNUserInterfaceStyle; }
+// Forward declaration of `RNMapPadding` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNMapPadding; }
+// Forward declaration of `RNMarker` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNMarker; }
+// Forward declaration of `RNPosition` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNPosition; }
+// Forward declaration of `RNPolygon` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNPolygon; }
+// Forward declaration of `RNPolyline` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNPolyline; }
+// Forward declaration of `RNLineCapType` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNLineCapType; }
+// Forward declaration of `RNLineJoinType` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNLineJoinType; }
+// Forward declaration of `RNMapErrorCode` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNMapErrorCode; }
+// Forward declaration of `RNLocation` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNLocation; }
+// Forward declaration of `RNLocationErrorCode` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNLocationErrorCode; }
+// Forward declaration of `RNRegion` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNRegion; }
+// Forward declaration of `RNLocationPermissionResult` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNLocationPermissionResult; }
+// Forward declaration of `RNAndroidLocationPermissionResult` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNAndroidLocationPermissionResult; }
+// Forward declaration of `RNIOSPermissionResult` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { enum class RNIOSPermissionResult; }
+
+#include <string>
+#include "RNCamera.hpp"
+#include "JRNCamera.hpp"
+#include "RNLatLng.hpp"
+#include <optional>
+#include "JRNLatLng.hpp"
+#include "RNUserInterfaceStyle.hpp"
+#include "JRNUserInterfaceStyle.hpp"
+#include "RNMapPadding.hpp"
+#include "JRNMapPadding.hpp"
+#include "RNMarker.hpp"
+#include <vector>
+#include "JRNMarker.hpp"
+#include "RNPosition.hpp"
+#include "JRNPosition.hpp"
+#include "RNPolygon.hpp"
+#include "JRNPolygon.hpp"
+#include "RNPolyline.hpp"
+#include "JRNPolyline.hpp"
+#include "RNLineCapType.hpp"
+#include "JRNLineCapType.hpp"
+#include "RNLineJoinType.hpp"
+#include "JRNLineJoinType.hpp"
+#include "RNMapErrorCode.hpp"
+#include <functional>
+#include "JFunc_void_RNMapErrorCode.hpp"
+#include "JRNMapErrorCode.hpp"
+#include "JFunc_void_bool.hpp"
+#include "RNLocation.hpp"
+#include "JFunc_void_RNLocation.hpp"
+#include "JRNLocation.hpp"
+#include "RNLocationErrorCode.hpp"
+#include "JFunc_void_RNLocationErrorCode.hpp"
+#include "JRNLocationErrorCode.hpp"
+#include "JFunc_void_RNLatLng.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "RNRegion.hpp"
+#include "JFunc_void_RNRegion_RNCamera_bool.hpp"
+#include "JRNRegion.hpp"
+#include "RNLocationPermissionResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JRNLocationPermissionResult.hpp"
+#include "RNAndroidLocationPermissionResult.hpp"
+#include "JRNAndroidLocationPermissionResult.hpp"
+#include "RNIOSPermissionResult.hpp"
+#include "JRNIOSPermissionResult.hpp"
+
+namespace margelo::nitro::googlemapsnitro {
+
+  jni::local_ref<JHybridGoogleMapsNitroViewSpec::jhybriddata> JHybridGoogleMapsNitroViewSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridGoogleMapsNitroViewSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridGoogleMapsNitroViewSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridGoogleMapsNitroViewSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridGoogleMapsNitroViewSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  bool JHybridGoogleMapsNitroViewSpec::getBuildingEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getBuildingEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridGoogleMapsNitroViewSpec::setBuildingEnabled(bool buildingEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* buildingEnabled */)>("setBuildingEnabled");
+    method(_javaPart, buildingEnabled);
+  }
+  bool JHybridGoogleMapsNitroViewSpec::getTrafficEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getTrafficEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridGoogleMapsNitroViewSpec::setTrafficEnabled(bool trafficEnabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* trafficEnabled */)>("setTrafficEnabled");
+    method(_javaPart, trafficEnabled);
+  }
+  std::string JHybridGoogleMapsNitroViewSpec::getCustomMapStyle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCustomMapStyle");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setCustomMapStyle(const std::string& customMapStyle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* customMapStyle */)>("setCustomMapStyle");
+    method(_javaPart, jni::make_jstring(customMapStyle));
+  }
+  RNCamera JHybridGoogleMapsNitroViewSpec::getInitialCamera() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNCamera>()>("getInitialCamera");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setInitialCamera(const RNCamera& initialCamera) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNCamera> /* initialCamera */)>("setInitialCamera");
+    method(_javaPart, JRNCamera::fromCpp(initialCamera));
+  }
+  RNUserInterfaceStyle JHybridGoogleMapsNitroViewSpec::getUserInterfaceStyle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNUserInterfaceStyle>()>("getUserInterfaceStyle");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setUserInterfaceStyle(RNUserInterfaceStyle userInterfaceStyle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNUserInterfaceStyle> /* userInterfaceStyle */)>("setUserInterfaceStyle");
+    method(_javaPart, JRNUserInterfaceStyle::fromCpp(userInterfaceStyle));
+  }
+  double JHybridGoogleMapsNitroViewSpec::getMinZoomLevel() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMinZoomLevel");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setMinZoomLevel(double minZoomLevel) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* minZoomLevel */)>("setMinZoomLevel");
+    method(_javaPart, minZoomLevel);
+  }
+  double JHybridGoogleMapsNitroViewSpec::getMaxZoomLevel() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMaxZoomLevel");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setMaxZoomLevel(double maxZoomLevel) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* maxZoomLevel */)>("setMaxZoomLevel");
+    method(_javaPart, maxZoomLevel);
+  }
+  RNMapPadding JHybridGoogleMapsNitroViewSpec::getMapPadding() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRNMapPadding>()>("getMapPadding");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setMapPadding(const RNMapPadding& mapPadding) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNMapPadding> /* mapPadding */)>("setMapPadding");
+    method(_javaPart, JRNMapPadding::fromCpp(mapPadding));
+  }
+  std::vector<RNMarker> JHybridGoogleMapsNitroViewSpec::getMarkers() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNMarker>>()>("getMarkers");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<RNMarker> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setMarkers(const std::vector<RNMarker>& markers) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNMarker>> /* markers */)>("setMarkers");
+    method(_javaPart, [&]() {
+      size_t __size = markers.size();
+      jni::local_ref<jni::JArrayClass<JRNMarker>> __array = jni::JArrayClass<JRNMarker>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = markers[__i];
+        __array->setElement(__i, *JRNMarker::fromCpp(__element));
+      }
+      return __array;
+    }());
+  }
+  std::vector<RNPolygon> JHybridGoogleMapsNitroViewSpec::getPolygons() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNPolygon>>()>("getPolygons");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<RNPolygon> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setPolygons(const std::vector<RNPolygon>& polygons) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNPolygon>> /* polygons */)>("setPolygons");
+    method(_javaPart, [&]() {
+      size_t __size = polygons.size();
+      jni::local_ref<jni::JArrayClass<JRNPolygon>> __array = jni::JArrayClass<JRNPolygon>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = polygons[__i];
+        __array->setElement(__i, *JRNPolygon::fromCpp(__element));
+      }
+      return __array;
+    }());
+  }
+  std::vector<RNPolyline> JHybridGoogleMapsNitroViewSpec::getPolylines() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRNPolyline>>()>("getPolylines");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<RNPolyline> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridGoogleMapsNitroViewSpec::setPolylines(const std::vector<RNPolyline>& polylines) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNPolyline>> /* polylines */)>("setPolylines");
+    method(_javaPart, [&]() {
+      size_t __size = polylines.size();
+      jni::local_ref<jni::JArrayClass<JRNPolyline>> __array = jni::JArrayClass<JRNPolyline>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = polylines[__i];
+        __array->setElement(__i, *JRNPolyline::fromCpp(__element));
+      }
+      return __array;
+    }());
+  }
+  std::optional<std::function<void(RNMapErrorCode /* error */)>> JHybridGoogleMapsNitroViewSpec::getOnMapError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNMapErrorCode::javaobject>()>("getOnMapError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(RNMapErrorCode /* error */)> {
+      if (__result->isInstanceOf(JFunc_void_RNMapErrorCode_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNMapErrorCode_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNMapErrorCode error) -> void {
+          return __resultRef->invoke(error);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnMapError(const std::optional<std::function<void(RNMapErrorCode /* error */)>>& onMapError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNMapErrorCode::javaobject> /* onMapError */)>("setOnMapError_cxx");
+    method(_javaPart, onMapError.has_value() ? JFunc_void_RNMapErrorCode_cxx::fromCpp(onMapError.value()) : nullptr);
+  }
+  std::optional<std::function<void(bool /* ready */)>> JHybridGoogleMapsNitroViewSpec::getOnMapReady() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_bool::javaobject>()>("getOnMapReady_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(bool /* ready */)> {
+      if (__result->isInstanceOf(JFunc_void_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](bool ready) -> void {
+          return __resultRef->invoke(ready);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnMapReady(const std::optional<std::function<void(bool /* ready */)>>& onMapReady) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* onMapReady */)>("setOnMapReady_cxx");
+    method(_javaPart, onMapReady.has_value() ? JFunc_void_bool_cxx::fromCpp(onMapReady.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNLocation& /* location */)>> JHybridGoogleMapsNitroViewSpec::getOnLocationUpdate() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNLocation::javaobject>()>("getOnLocationUpdate_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNLocation& /* location */)> {
+      if (__result->isInstanceOf(JFunc_void_RNLocation_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNLocation_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNLocation location) -> void {
+          return __resultRef->invoke(location);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnLocationUpdate(const std::optional<std::function<void(const RNLocation& /* location */)>>& onLocationUpdate) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNLocation::javaobject> /* onLocationUpdate */)>("setOnLocationUpdate_cxx");
+    method(_javaPart, onLocationUpdate.has_value() ? JFunc_void_RNLocation_cxx::fromCpp(onLocationUpdate.value()) : nullptr);
+  }
+  std::optional<std::function<void(RNLocationErrorCode /* error */)>> JHybridGoogleMapsNitroViewSpec::getOnLocationError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNLocationErrorCode::javaobject>()>("getOnLocationError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(RNLocationErrorCode /* error */)> {
+      if (__result->isInstanceOf(JFunc_void_RNLocationErrorCode_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNLocationErrorCode_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNLocationErrorCode error) -> void {
+          return __resultRef->invoke(error);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnLocationError(const std::optional<std::function<void(RNLocationErrorCode /* error */)>>& onLocationError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNLocationErrorCode::javaobject> /* onLocationError */)>("setOnLocationError_cxx");
+    method(_javaPart, onLocationError.has_value() ? JFunc_void_RNLocationErrorCode_cxx::fromCpp(onLocationError.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNLatLng& /* coordinate */)>> JHybridGoogleMapsNitroViewSpec::getOnMapPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNLatLng::javaobject>()>("getOnMapPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNLatLng& /* coordinate */)> {
+      if (__result->isInstanceOf(JFunc_void_RNLatLng_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNLatLng_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNLatLng coordinate) -> void {
+          return __resultRef->invoke(coordinate);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnMapPress(const std::optional<std::function<void(const RNLatLng& /* coordinate */)>>& onMapPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNLatLng::javaobject> /* onMapPress */)>("setOnMapPress_cxx");
+    method(_javaPart, onMapPress.has_value() ? JFunc_void_RNLatLng_cxx::fromCpp(onMapPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridGoogleMapsNitroViewSpec::getOnMarkerPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnMarkerPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* id */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](std::string id) -> void {
+          return __resultRef->invoke(id);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnMarkerPress(const std::optional<std::function<void(const std::string& /* id */)>>& onMarkerPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onMarkerPress */)>("setOnMarkerPress_cxx");
+    method(_javaPart, onMarkerPress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onMarkerPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> JHybridGoogleMapsNitroViewSpec::getOnCameraChangeStart() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject>()>("getOnCameraChangeStart_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)> {
+      if (__result->isInstanceOf(JFunc_void_RNRegion_RNCamera_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNRegion_RNCamera_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNRegion region, RNCamera camera, bool isGesture) -> void {
+          return __resultRef->invoke(region,camera,isGesture);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnCameraChangeStart(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeStart) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject> /* onCameraChangeStart */)>("setOnCameraChangeStart_cxx");
+    method(_javaPart, onCameraChangeStart.has_value() ? JFunc_void_RNRegion_RNCamera_bool_cxx::fromCpp(onCameraChangeStart.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> JHybridGoogleMapsNitroViewSpec::getOnCameraChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject>()>("getOnCameraChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)> {
+      if (__result->isInstanceOf(JFunc_void_RNRegion_RNCamera_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNRegion_RNCamera_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNRegion region, RNCamera camera, bool isGesture) -> void {
+          return __resultRef->invoke(region,camera,isGesture);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnCameraChange(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject> /* onCameraChange */)>("setOnCameraChange_cxx");
+    method(_javaPart, onCameraChange.has_value() ? JFunc_void_RNRegion_RNCamera_bool_cxx::fromCpp(onCameraChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> JHybridGoogleMapsNitroViewSpec::getOnCameraChangeComplete() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject>()>("getOnCameraChangeComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)> {
+      if (__result->isInstanceOf(JFunc_void_RNRegion_RNCamera_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_RNRegion_RNCamera_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef](RNRegion region, RNCamera camera, bool isGesture) -> void {
+          return __resultRef->invoke(region,camera,isGesture);
+        };
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridGoogleMapsNitroViewSpec::setOnCameraChangeComplete(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeComplete) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RNRegion_RNCamera_bool::javaobject> /* onCameraChangeComplete */)>("setOnCameraChangeComplete_cxx");
+    method(_javaPart, onCameraChangeComplete.has_value() ? JFunc_void_RNRegion_RNCamera_bool_cxx::fromCpp(onCameraChangeComplete.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridGoogleMapsNitroViewSpec::setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMS) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNCamera> /* camera */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMS */)>("setCamera");
+    method(_javaPart, JRNCamera::fromCpp(camera), animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMS.has_value() ? jni::JDouble::valueOf(durationMS.value()) : nullptr);
+  }
+  void JHybridGoogleMapsNitroViewSpec::setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMS) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRNLatLng>> /* coordinates */, jni::alias_ref<JRNMapPadding> /* padding */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JDouble> /* durationMS */)>("setCameraToCoordinates");
+    method(_javaPart, [&]() {
+      size_t __size = coordinates.size();
+      jni::local_ref<jni::JArrayClass<JRNLatLng>> __array = jni::JArrayClass<JRNLatLng>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = coordinates[__i];
+        __array->setElement(__i, *JRNLatLng::fromCpp(__element));
+      }
+      return __array;
+    }(), padding.has_value() ? JRNMapPadding::fromCpp(padding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, durationMS.has_value() ? jni::JDouble::valueOf(durationMS.value()) : nullptr);
+  }
+  void JHybridGoogleMapsNitroViewSpec::showLocationDialog() {
+    static const auto method = javaClassStatic()->getMethod<void()>("showLocationDialog");
+    method(_javaPart);
+  }
+  void JHybridGoogleMapsNitroViewSpec::openLocationSettings() {
+    static const auto method = javaClassStatic()->getMethod<void()>("openLocationSettings");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<RNLocationPermissionResult>> JHybridGoogleMapsNitroViewSpec::requestLocationPermission() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestLocationPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<RNLocationPermissionResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JRNLocationPermissionResult>(__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;
+    }();
+  }
+  bool JHybridGoogleMapsNitroViewSpec::isGooglePlayServicesAvailable() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isGooglePlayServicesAvailable");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+
+} // namespace margelo::nitro::googlemapsnitro

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

@@ -0,0 +1,108 @@
+///
+/// HybridGoogleMapsNitroViewSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridGoogleMapsNitroViewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::googlemapsnitro {
+
+  using namespace facebook;
+
+  class JHybridGoogleMapsNitroViewSpec: public jni::HybridClass<JHybridGoogleMapsNitroViewSpec, JHybridObject>,
+                                        public virtual HybridGoogleMapsNitroViewSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/googlemapsnitro/HybridGoogleMapsNitroViewSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridGoogleMapsNitroViewSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridGoogleMapsNitroViewSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridGoogleMapsNitroViewSpec() 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;
+
+  public:
+    inline const jni::global_ref<JHybridGoogleMapsNitroViewSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    bool getBuildingEnabled() override;
+    void setBuildingEnabled(bool buildingEnabled) override;
+    bool getTrafficEnabled() override;
+    void setTrafficEnabled(bool trafficEnabled) override;
+    std::string getCustomMapStyle() override;
+    void setCustomMapStyle(const std::string& customMapStyle) override;
+    RNCamera getInitialCamera() override;
+    void setInitialCamera(const RNCamera& initialCamera) override;
+    RNUserInterfaceStyle getUserInterfaceStyle() override;
+    void setUserInterfaceStyle(RNUserInterfaceStyle userInterfaceStyle) override;
+    double getMinZoomLevel() override;
+    void setMinZoomLevel(double minZoomLevel) override;
+    double getMaxZoomLevel() override;
+    void setMaxZoomLevel(double maxZoomLevel) override;
+    RNMapPadding getMapPadding() override;
+    void setMapPadding(const RNMapPadding& mapPadding) override;
+    std::vector<RNMarker> getMarkers() override;
+    void setMarkers(const std::vector<RNMarker>& markers) override;
+    std::vector<RNPolygon> getPolygons() override;
+    void setPolygons(const std::vector<RNPolygon>& polygons) override;
+    std::vector<RNPolyline> getPolylines() override;
+    void setPolylines(const std::vector<RNPolyline>& polylines) override;
+    std::optional<std::function<void(RNMapErrorCode /* error */)>> getOnMapError() override;
+    void setOnMapError(const std::optional<std::function<void(RNMapErrorCode /* error */)>>& onMapError) override;
+    std::optional<std::function<void(bool /* ready */)>> getOnMapReady() override;
+    void setOnMapReady(const std::optional<std::function<void(bool /* ready */)>>& onMapReady) override;
+    std::optional<std::function<void(const RNLocation& /* location */)>> getOnLocationUpdate() override;
+    void setOnLocationUpdate(const std::optional<std::function<void(const RNLocation& /* location */)>>& onLocationUpdate) override;
+    std::optional<std::function<void(RNLocationErrorCode /* error */)>> getOnLocationError() override;
+    void setOnLocationError(const std::optional<std::function<void(RNLocationErrorCode /* error */)>>& onLocationError) override;
+    std::optional<std::function<void(const RNLatLng& /* coordinate */)>> getOnMapPress() override;
+    void setOnMapPress(const std::optional<std::function<void(const RNLatLng& /* coordinate */)>>& onMapPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnMarkerPress() override;
+    void setOnMarkerPress(const std::optional<std::function<void(const std::string& /* id */)>>& onMarkerPress) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChangeStart() override;
+    void setOnCameraChangeStart(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeStart) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChange() override;
+    void setOnCameraChange(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChange) override;
+    std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChangeComplete() override;
+    void setOnCameraChangeComplete(const std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>& onCameraChangeComplete) override;
+
+  public:
+    // Methods
+    void setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMS) override;
+    void setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMS) override;
+    void showLocationDialog() override;
+    void openLocationSettings() override;
+    std::shared_ptr<Promise<RNLocationPermissionResult>> requestLocationPermission() override;
+    bool isGooglePlayServicesAvailable() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridGoogleMapsNitroViewSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::googlemapsnitro

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

@@ -0,0 +1,62 @@
+///
+/// JRNAndroidLocationPermissionResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RNAndroidLocationPermissionResult.hpp"
+
+namespace margelo::nitro::googlemapsnitro {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RNAndroidLocationPermissionResult" and the the Kotlin enum "RNAndroidLocationPermissionResult".
+   */
+  struct JRNAndroidLocationPermissionResult final: public jni::JavaClass<JRNAndroidLocationPermissionResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/googlemapsnitro/RNAndroidLocationPermissionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RNAndroidLocationPermissionResult.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RNAndroidLocationPermissionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RNAndroidLocationPermissionResult>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRNAndroidLocationPermissionResult> fromCpp(RNAndroidLocationPermissionResult value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGRANTED = clazz->getStaticField<JRNAndroidLocationPermissionResult>("GRANTED");
+      static const auto fieldDENIED = clazz->getStaticField<JRNAndroidLocationPermissionResult>("DENIED");
+      static const auto fieldNEVER_ASK_AGAIN = clazz->getStaticField<JRNAndroidLocationPermissionResult>("NEVER_ASK_AGAIN");
+      
+      switch (value) {
+        case RNAndroidLocationPermissionResult::GRANTED:
+          return clazz->getStaticFieldValue(fieldGRANTED);
+        case RNAndroidLocationPermissionResult::DENIED:
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case RNAndroidLocationPermissionResult::NEVER_ASK_AGAIN:
+          return clazz->getStaticFieldValue(fieldNEVER_ASK_AGAIN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::googlemapsnitro