@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.0

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

@@ -23,14 +23,16 @@ namespace margelo::nitro::nitromap { struct ClusterConfig; }
 namespace margelo::nitro::nitromap { enum class ClusterStrategy; }
 // Forward declaration of `MarkerColor` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MarkerColor; }
-// Forward declaration of `ClusterAnimationStyle` to properly resolve imports.
-namespace margelo::nitro::nitromap { enum class ClusterAnimationStyle; }
+// Forward declaration of `EdgePadding` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct EdgePadding; }
+// Forward declaration of `UserTrackingMode` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class UserTrackingMode; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Point; }
 // Forward declaration of `MapPressEvent` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapPressEvent; }
 // Forward declaration of `Coordinate` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Coordinate; }
-// Forward declaration of `Point` to properly resolve imports.
-namespace margelo::nitro::nitromap { struct Point; }
 // Forward declaration of `RegionChangeEvent` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct RegionChangeEvent; }
 // Forward declaration of `MarkerPressEvent` to properly resolve imports.
@@ -41,12 +43,12 @@ namespace margelo::nitro::nitromap { struct MarkerDragEvent; }
 namespace margelo::nitro::nitromap { struct ClusterPressEvent; }
 // Forward declaration of `MapError` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapError; }
+// Forward declaration of `UserLocationChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct UserLocationChangeEvent; }
 // Forward declaration of `Camera` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Camera; }
 // Forward declaration of `MapBoundaries` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapBoundaries; }
-// Forward declaration of `EdgePadding` to properly resolve imports.
-namespace margelo::nitro::nitromap { struct EdgePadding; }
 // Forward declaration of `MarkerData` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MarkerData; }
 // Forward declaration of `MarkerConfig` to properly resolve imports.
@@ -59,6 +61,12 @@ namespace margelo::nitro::nitromap { struct ImageMarkerConfig; }
 namespace margelo::nitro::nitromap { struct PriceMarkerStyle; }
 // Forward declaration of `MarkerAnimation` to properly resolve imports.
 namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
+// Forward declaration of `PolylineData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PolylineData; }
+// Forward declaration of `PolygonData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PolygonData; }
+// Forward declaration of `CircleData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct CircleData; }
 
 #include "MapProvider.hpp"
 #include <optional>
@@ -81,8 +89,12 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include <variant>
 #include "JVariant_String_MarkerColor.hpp"
 #include "JMarkerColor.hpp"
-#include "ClusterAnimationStyle.hpp"
-#include "JClusterAnimationStyle.hpp"
+#include "EdgePadding.hpp"
+#include "JEdgePadding.hpp"
+#include "UserTrackingMode.hpp"
+#include "JUserTrackingMode.hpp"
+#include "Point.hpp"
+#include "JPoint.hpp"
 #include "MapPressEvent.hpp"
 #include <functional>
 #include "JFunc_void_MapPressEvent.hpp"
@@ -90,8 +102,6 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include "JMapPressEvent.hpp"
 #include "Coordinate.hpp"
 #include "JCoordinate.hpp"
-#include "Point.hpp"
-#include "JPoint.hpp"
 #include "JFunc_void.hpp"
 #include "RegionChangeEvent.hpp"
 #include "JFunc_void_RegionChangeEvent.hpp"
@@ -105,17 +115,20 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include "ClusterPressEvent.hpp"
 #include "JFunc_void_ClusterPressEvent.hpp"
 #include "JClusterPressEvent.hpp"
+#include "JFunc_void_std__string.hpp"
 #include "MapError.hpp"
 #include "JFunc_void_MapError.hpp"
 #include "JMapError.hpp"
+#include "UserLocationChangeEvent.hpp"
+#include "JFunc_void_UserLocationChangeEvent.hpp"
+#include "JUserLocationChangeEvent.hpp"
+#include "JFunc_void_UserTrackingMode.hpp"
 #include "Camera.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JCamera.hpp"
 #include "MapBoundaries.hpp"
 #include "JMapBoundaries.hpp"
-#include "EdgePadding.hpp"
-#include "JEdgePadding.hpp"
 #include "MarkerData.hpp"
 #include "JMarkerData.hpp"
 #include "MarkerConfig.hpp"
@@ -129,6 +142,12 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include "JPriceMarkerStyle.hpp"
 #include "MarkerAnimation.hpp"
 #include "JMarkerAnimation.hpp"
+#include "PolylineData.hpp"
+#include "JPolylineData.hpp"
+#include "PolygonData.hpp"
+#include "JPolygonData.hpp"
+#include "CircleData.hpp"
+#include "JCircleData.hpp"
 
 namespace margelo::nitro::nitromap {
 
@@ -177,6 +196,15 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRegion> /* initialRegion */)>("setInitialRegion");
     method(_javaPart, initialRegion.has_value() ? JRegion::fromCpp(initialRegion.value()) : nullptr);
   }
+  std::optional<Region> JHybridNitroMapSpec::getRegion() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRegion>()>("getRegion");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setRegion(const std::optional<Region>& region) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRegion> /* region */)>("setRegion");
+    method(_javaPart, region.has_value() ? JRegion::fromCpp(region.value()) : nullptr);
+  }
   std::optional<bool> JHybridNitroMapSpec::getShowsUserLocation() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsUserLocation");
     auto __result = method(_javaPart);
@@ -258,15 +286,6 @@ namespace margelo::nitro::nitromap {
       return __array;
     }() : nullptr);
   }
-  std::optional<bool> JHybridNitroMapSpec::getShowsMyLocationButton() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsMyLocationButton");
-    auto __result = method(_javaPart);
-    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
-  }
-  void JHybridNitroMapSpec::setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsMyLocationButton */)>("setShowsMyLocationButton");
-    method(_javaPart, showsMyLocationButton.has_value() ? jni::JBoolean::valueOf(showsMyLocationButton.value()) : nullptr);
-  }
   std::optional<ClusterConfig> JHybridNitroMapSpec::getClusterConfig() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JClusterConfig>()>("getClusterConfig");
     auto __result = method(_javaPart);
@@ -276,6 +295,60 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JClusterConfig> /* clusterConfig */)>("setClusterConfig");
     method(_javaPart, clusterConfig.has_value() ? JClusterConfig::fromCpp(clusterConfig.value()) : nullptr);
   }
+  EdgePadding JHybridNitroMapSpec::getMapPadding() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JEdgePadding>()>("getMapPadding");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroMapSpec::setMapPadding(const EdgePadding& mapPadding) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JEdgePadding> /* mapPadding */)>("setMapPadding");
+    method(_javaPart, JEdgePadding::fromCpp(mapPadding));
+  }
+  std::optional<bool> JHybridNitroMapSpec::getShowsTraffic() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsTraffic");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setShowsTraffic(std::optional<bool> showsTraffic) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsTraffic */)>("setShowsTraffic");
+    method(_javaPart, showsTraffic.has_value() ? jni::JBoolean::valueOf(showsTraffic.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getShowsBuildings() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsBuildings");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setShowsBuildings(std::optional<bool> showsBuildings) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsBuildings */)>("setShowsBuildings");
+    method(_javaPart, showsBuildings.has_value() ? jni::JBoolean::valueOf(showsBuildings.value()) : nullptr);
+  }
+  std::optional<bool> JHybridNitroMapSpec::getShowsCompass() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getShowsCompass");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setShowsCompass(std::optional<bool> showsCompass) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* showsCompass */)>("setShowsCompass");
+    method(_javaPart, showsCompass.has_value() ? jni::JBoolean::valueOf(showsCompass.value()) : nullptr);
+  }
+  double JHybridNitroMapSpec::getMinZoom() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMinZoom");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroMapSpec::setMinZoom(double minZoom) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* minZoom */)>("setMinZoom");
+    method(_javaPart, minZoom);
+  }
+  double JHybridNitroMapSpec::getMaxZoom() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMaxZoom");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroMapSpec::setMaxZoom(double maxZoom) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* maxZoom */)>("setMaxZoom");
+    method(_javaPart, maxZoom);
+  }
   std::optional<bool> JHybridNitroMapSpec::getDarkMode() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getDarkMode");
     auto __result = method(_javaPart);
@@ -285,6 +358,42 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* darkMode */)>("setDarkMode");
     method(_javaPart, darkMode.has_value() ? jni::JBoolean::valueOf(darkMode.value()) : nullptr);
   }
+  std::optional<UserTrackingMode> JHybridNitroMapSpec::getUserTrackingMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JUserTrackingMode>()>("getUserTrackingMode");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setUserTrackingMode(std::optional<UserTrackingMode> userTrackingMode) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUserTrackingMode> /* userTrackingMode */)>("setUserTrackingMode");
+    method(_javaPart, userTrackingMode.has_value() ? JUserTrackingMode::fromCpp(userTrackingMode.value()) : nullptr);
+  }
+  std::string JHybridNitroMapSpec::getUserLocationImage() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getUserLocationImage");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridNitroMapSpec::setUserLocationImage(const std::string& userLocationImage) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* userLocationImage */)>("setUserLocationImage");
+    method(_javaPart, jni::make_jstring(userLocationImage));
+  }
+  double JHybridNitroMapSpec::getUserLocationSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getUserLocationSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroMapSpec::setUserLocationSize(double userLocationSize) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* userLocationSize */)>("setUserLocationSize");
+    method(_javaPart, userLocationSize);
+  }
+  std::optional<Point> JHybridNitroMapSpec::getUserLocationAnchor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPoint>()>("getUserLocationAnchor");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setUserLocationAnchor(const std::optional<Point>& userLocationAnchor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPoint> /* userLocationAnchor */)>("setUserLocationAnchor");
+    method(_javaPart, userLocationAnchor.has_value() ? JPoint::fromCpp(userLocationAnchor.value()) : nullptr);
+  }
   std::optional<std::function<void(const MapPressEvent& /* event */)>> JHybridNitroMapSpec::getOnPress() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapPressEvent::javaobject>()>("getOnPress_cxx");
     auto __result = method(_javaPart);
@@ -455,6 +564,57 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ClusterPressEvent::javaobject> /* onClusterPress */)>("setOnClusterPress_cxx");
     method(_javaPart, onClusterPress.has_value() ? JFunc_void_ClusterPressEvent_cxx::fromCpp(onClusterPress.value()) : nullptr);
   }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridNitroMapSpec::getOnPolylinePress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnPolylinePress_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 JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onPolylinePress */)>("setOnPolylinePress_cxx");
+    method(_javaPart, onPolylinePress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onPolylinePress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridNitroMapSpec::getOnPolygonPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnPolygonPress_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 JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onPolygonPress */)>("setOnPolygonPress_cxx");
+    method(_javaPart, onPolygonPress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onPolygonPress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* id */)>> JHybridNitroMapSpec::getOnCirclePress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnCirclePress_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 JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onCirclePress */)>("setOnCirclePress_cxx");
+    method(_javaPart, onCirclePress.has_value() ? JFunc_void_std__string_cxx::fromCpp(onCirclePress.value()) : nullptr);
+  }
   std::optional<std::function<void(const MapError& /* error */)>> JHybridNitroMapSpec::getOnError() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapError::javaobject>()>("getOnError_cxx");
     auto __result = method(_javaPart);
@@ -472,6 +632,74 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MapError::javaobject> /* onError */)>("setOnError_cxx");
     method(_javaPart, onError.has_value() ? JFunc_void_MapError_cxx::fromCpp(onError.value()) : nullptr);
   }
+  std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>> JHybridNitroMapSpec::getOnUserLocationChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_UserLocationChangeEvent::javaobject>()>("getOnUserLocationChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const UserLocationChangeEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_UserLocationChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_UserLocationChangeEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_UserLocationChangeEvent, void(UserLocationChangeEvent)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnUserLocationChange(const std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>& onUserLocationChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_UserLocationChangeEvent::javaobject> /* onUserLocationChange */)>("setOnUserLocationChange_cxx");
+    method(_javaPart, onUserLocationChange.has_value() ? JFunc_void_UserLocationChangeEvent_cxx::fromCpp(onUserLocationChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(UserTrackingMode /* mode */)>> JHybridNitroMapSpec::getOnUserTrackingModeChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_UserTrackingMode::javaobject>()>("getOnUserTrackingModeChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(UserTrackingMode /* mode */)> {
+      if (__result->isInstanceOf(JFunc_void_UserTrackingMode_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_UserTrackingMode_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_UserTrackingMode, void(UserTrackingMode)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnUserTrackingModeChange(const std::optional<std::function<void(UserTrackingMode /* mode */)>>& onUserTrackingModeChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_UserTrackingMode::javaobject> /* onUserTrackingModeChange */)>("setOnUserTrackingModeChange_cxx");
+    method(_javaPart, onUserTrackingModeChange.has_value() ? JFunc_void_UserTrackingMode_cxx::fromCpp(onUserTrackingModeChange.value()) : nullptr);
+  }
+  std::optional<std::function<void(const MapError& /* error */)>> JHybridNitroMapSpec::getOnUserLocationError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_MapError::javaobject>()>("getOnUserLocationError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const MapError& /* error */)> {
+      if (__result->isInstanceOf(JFunc_void_MapError_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_MapError_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_MapError, void(MapError)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnUserLocationError(const std::optional<std::function<void(const MapError& /* error */)>>& onUserLocationError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MapError::javaobject> /* onUserLocationError */)>("setOnUserLocationError_cxx");
+    method(_javaPart, onUserLocationError.has_value() ? JFunc_void_MapError_cxx::fromCpp(onUserLocationError.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroMapSpec::getOnMapIdle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnMapIdle_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroMapSpec::setOnMapIdle(const std::optional<std::function<void()>>& onMapIdle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onMapIdle */)>("setOnMapIdle_cxx");
+    method(_javaPart, onMapIdle.has_value() ? JFunc_void_cxx::fromCpp(onMapIdle.value()) : nullptr);
+  }
 
   // Methods
   void JHybridNitroMapSpec::animateToRegion(const Region& region, std::optional<double> duration) {
@@ -491,6 +719,19 @@ namespace margelo::nitro::nitromap {
       return __array;
     }(), edgePadding.has_value() ? JEdgePadding::fromCpp(edgePadding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr);
   }
+  void JHybridNitroMapSpec::fitToSuppliedMarkers(const std::vector<std::string>& markerIds, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* markerIds */, jni::alias_ref<JEdgePadding> /* edgePadding */, jni::alias_ref<jni::JBoolean> /* animated */)>("fitToSuppliedMarkers");
+    method(_javaPart, [&]() {
+      size_t __size = markerIds.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = markerIds[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), edgePadding.has_value() ? JEdgePadding::fromCpp(edgePadding.value()) : nullptr, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr);
+  }
   void JHybridNitroMapSpec::animateCamera(const Camera& camera, std::optional<double> duration) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCamera> /* camera */, jni::alias_ref<jni::JDouble> /* duration */)>("animateCamera");
     method(_javaPart, JCamera::fromCpp(camera), duration.has_value() ? jni::JDouble::valueOf(duration.value()) : nullptr);
@@ -544,6 +785,20 @@ namespace margelo::nitro::nitromap {
       return __promise;
     }();
   }
+  void JHybridNitroMapSpec::centerOnUserLocation() {
+    static const auto method = javaClassStatic()->getMethod<void()>("centerOnUserLocation");
+    method(_javaPart);
+  }
+  Point JHybridNitroMapSpec::pointForCoordinate(const Coordinate& coordinate) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPoint>(jni::alias_ref<JCoordinate> /* coordinate */)>("pointForCoordinate");
+    auto __result = method(_javaPart, JCoordinate::fromCpp(coordinate));
+    return __result->toCpp();
+  }
+  Coordinate JHybridNitroMapSpec::coordinateForPoint(const Point& point) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JCoordinate>(jni::alias_ref<JPoint> /* point */)>("coordinateForPoint");
+    auto __result = method(_javaPart, JPoint::fromCpp(point));
+    return __result->toCpp();
+  }
   void JHybridNitroMapSpec::setIsDarkMode(bool enabled) {
     static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setIsDarkMode");
     method(_javaPart, enabled);
@@ -577,6 +832,10 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("selectMarker");
     method(_javaPart, jni::make_jstring(id));
   }
+  void JHybridNitroMapSpec::deselectMarker() {
+    static const auto method = javaClassStatic()->getMethod<void()>("deselectMarker");
+    method(_javaPart);
+  }
   void JHybridNitroMapSpec::clearMarkers() {
     static const auto method = javaClassStatic()->getMethod<void()>("clearMarkers");
     method(_javaPart);
@@ -589,5 +848,53 @@ namespace margelo::nitro::nitromap {
     static const auto method = javaClassStatic()->getMethod<void()>("refreshClusters");
     method(_javaPart);
   }
+  void JHybridNitroMapSpec::addPolyline(const PolylineData& polyline) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPolylineData> /* polyline */)>("addPolyline");
+    method(_javaPart, JPolylineData::fromCpp(polyline));
+  }
+  void JHybridNitroMapSpec::updatePolyline(const PolylineData& polyline) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPolylineData> /* polyline */)>("updatePolyline");
+    method(_javaPart, JPolylineData::fromCpp(polyline));
+  }
+  void JHybridNitroMapSpec::removePolyline(const std::string& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("removePolyline");
+    method(_javaPart, jni::make_jstring(id));
+  }
+  void JHybridNitroMapSpec::clearPolylines() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearPolylines");
+    method(_javaPart);
+  }
+  void JHybridNitroMapSpec::addPolygon(const PolygonData& polygon) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPolygonData> /* polygon */)>("addPolygon");
+    method(_javaPart, JPolygonData::fromCpp(polygon));
+  }
+  void JHybridNitroMapSpec::updatePolygon(const PolygonData& polygon) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPolygonData> /* polygon */)>("updatePolygon");
+    method(_javaPart, JPolygonData::fromCpp(polygon));
+  }
+  void JHybridNitroMapSpec::removePolygon(const std::string& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("removePolygon");
+    method(_javaPart, jni::make_jstring(id));
+  }
+  void JHybridNitroMapSpec::clearPolygons() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearPolygons");
+    method(_javaPart);
+  }
+  void JHybridNitroMapSpec::addCircle(const CircleData& circle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCircleData> /* circle */)>("addCircle");
+    method(_javaPart, JCircleData::fromCpp(circle));
+  }
+  void JHybridNitroMapSpec::updateCircle(const CircleData& circle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCircleData> /* circle */)>("updateCircle");
+    method(_javaPart, JCircleData::fromCpp(circle));
+  }
+  void JHybridNitroMapSpec::removeCircle(const std::string& id) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* id */)>("removeCircle");
+    method(_javaPart, jni::make_jstring(id));
+  }
+  void JHybridNitroMapSpec::clearCircles() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearCircles");
+    method(_javaPart);
+  }
 
 } // namespace margelo::nitro::nitromap

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

@@ -54,6 +54,8 @@ namespace margelo::nitro::nitromap {
     void setProvider(std::optional<MapProvider> provider) override;
     std::optional<Region> getInitialRegion() override;
     void setInitialRegion(const std::optional<Region>& initialRegion) override;
+    std::optional<Region> getRegion() override;
+    void setRegion(const std::optional<Region>& region) override;
     std::optional<bool> getShowsUserLocation() override;
     void setShowsUserLocation(std::optional<bool> showsUserLocation) override;
     std::optional<bool> getZoomEnabled() override;
@@ -68,12 +70,30 @@ namespace margelo::nitro::nitromap {
     void setMapType(std::optional<MapType> mapType) override;
     std::optional<std::vector<MapStyleElement>> getCustomMapStyle() override;
     void setCustomMapStyle(const std::optional<std::vector<MapStyleElement>>& customMapStyle) override;
-    std::optional<bool> getShowsMyLocationButton() override;
-    void setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) override;
     std::optional<ClusterConfig> getClusterConfig() override;
     void setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) override;
+    EdgePadding getMapPadding() override;
+    void setMapPadding(const EdgePadding& mapPadding) override;
+    std::optional<bool> getShowsTraffic() override;
+    void setShowsTraffic(std::optional<bool> showsTraffic) override;
+    std::optional<bool> getShowsBuildings() override;
+    void setShowsBuildings(std::optional<bool> showsBuildings) override;
+    std::optional<bool> getShowsCompass() override;
+    void setShowsCompass(std::optional<bool> showsCompass) override;
+    double getMinZoom() override;
+    void setMinZoom(double minZoom) override;
+    double getMaxZoom() override;
+    void setMaxZoom(double maxZoom) override;
     std::optional<bool> getDarkMode() override;
     void setDarkMode(std::optional<bool> darkMode) override;
+    std::optional<UserTrackingMode> getUserTrackingMode() override;
+    void setUserTrackingMode(std::optional<UserTrackingMode> userTrackingMode) override;
+    std::string getUserLocationImage() override;
+    void setUserLocationImage(const std::string& userLocationImage) override;
+    double getUserLocationSize() override;
+    void setUserLocationSize(double userLocationSize) override;
+    std::optional<Point> getUserLocationAnchor() override;
+    void setUserLocationAnchor(const std::optional<Point>& userLocationAnchor) override;
     std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnPress() override;
     void setOnPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onPress) override;
     std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnLongPress() override;
@@ -94,27 +114,58 @@ namespace margelo::nitro::nitromap {
     void setOnMarkerDragEnd(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragEnd) override;
     std::optional<std::function<void(const ClusterPressEvent& /* event */)>> getOnClusterPress() override;
     void setOnClusterPress(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& onClusterPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnPolylinePress() override;
+    void setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnPolygonPress() override;
+    void setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) override;
+    std::optional<std::function<void(const std::string& /* id */)>> getOnCirclePress() override;
+    void setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) override;
     std::optional<std::function<void(const MapError& /* error */)>> getOnError() override;
     void setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) override;
+    std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>> getOnUserLocationChange() override;
+    void setOnUserLocationChange(const std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>& onUserLocationChange) override;
+    std::optional<std::function<void(UserTrackingMode /* mode */)>> getOnUserTrackingModeChange() override;
+    void setOnUserTrackingModeChange(const std::optional<std::function<void(UserTrackingMode /* mode */)>>& onUserTrackingModeChange) override;
+    std::optional<std::function<void(const MapError& /* error */)>> getOnUserLocationError() override;
+    void setOnUserLocationError(const std::optional<std::function<void(const MapError& /* error */)>>& onUserLocationError) override;
+    std::optional<std::function<void()>> getOnMapIdle() override;
+    void setOnMapIdle(const std::optional<std::function<void()>>& onMapIdle) override;
 
   public:
     // Methods
     void animateToRegion(const Region& region, std::optional<double> duration) override;
     void fitToCoordinates(const std::vector<Coordinate>& coordinates, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) override;
+    void fitToSuppliedMarkers(const std::vector<std::string>& markerIds, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) override;
     void animateCamera(const Camera& camera, std::optional<double> duration) override;
     std::shared_ptr<Promise<Camera>> getCamera() override;
     void setCamera(const Camera& camera) override;
     void setMapStyle(const std::optional<std::vector<MapStyleElement>>& style) override;
     std::shared_ptr<Promise<MapBoundaries>> getMapBoundaries() override;
+    void centerOnUserLocation() override;
+    Point pointForCoordinate(const Coordinate& coordinate) override;
+    Coordinate coordinateForPoint(const Point& point) override;
     void setIsDarkMode(bool enabled) override;
     void addMarker(const MarkerData& marker) override;
     void addMarkers(const std::vector<MarkerData>& markers) override;
     void updateMarker(const MarkerData& marker) override;
     void removeMarker(const std::string& id) override;
     void selectMarker(const std::string& id) override;
+    void deselectMarker() override;
     void clearMarkers() override;
     void setClusteringEnabled(bool enabled) override;
     void refreshClusters() override;
+    void addPolyline(const PolylineData& polyline) override;
+    void updatePolyline(const PolylineData& polyline) override;
+    void removePolyline(const std::string& id) override;
+    void clearPolylines() override;
+    void addPolygon(const PolygonData& polygon) override;
+    void updatePolygon(const PolygonData& polygon) override;
+    void removePolygon(const std::string& id) override;
+    void clearPolygons() override;
+    void addCircle(const CircleData& circle) override;
+    void updateCircle(const CircleData& circle) override;
+    void removeCircle(const std::string& id) override;
+    void clearCircles() override;
 
   private:
     friend HybridBase;

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

@@ -42,16 +42,13 @@ namespace margelo::nitro::nitromap {
     static jni::alias_ref<JMarkerAnimation> fromCpp(MarkerAnimation value) {
       static const auto clazz = javaClassStatic();
       static const auto fieldNONE = clazz->getStaticField<JMarkerAnimation>("NONE");
-      static const auto fieldPOP = clazz->getStaticField<JMarkerAnimation>("POP");
-      static const auto fieldFADEIN = clazz->getStaticField<JMarkerAnimation>("FADEIN");
+      static const auto fieldAPPEAR = clazz->getStaticField<JMarkerAnimation>("APPEAR");
       
       switch (value) {
         case MarkerAnimation::NONE:
           return clazz->getStaticFieldValue(fieldNONE);
-        case MarkerAnimation::POP:
-          return clazz->getStaticFieldValue(fieldPOP);
-        case MarkerAnimation::FADEIN:
-          return clazz->getStaticFieldValue(fieldFADEIN);
+        case MarkerAnimation::APPEAR:
+          return clazz->getStaticFieldValue(fieldAPPEAR);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");