react-native-nitro-background-geolocation 0.1.0

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

@@ -0,0 +1,530 @@
+///
+/// JHybridNitroBackgroundGeolocationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroBackgroundGeolocationSpec.hpp"
+
+// Forward declaration of `Location` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct Location; }
+// Forward declaration of `StationaryLocation` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct StationaryLocation; }
+// Forward declaration of `ServiceStatus` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct ServiceStatus; }
+// Forward declaration of `AuthorizationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class AuthorizationStatus; }
+// Forward declaration of `ConfigureOptions` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct ConfigureOptions; }
+// Forward declaration of `LocationProvider` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class LocationProvider; }
+// Forward declaration of `LocationAccuracy` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class LocationAccuracy; }
+// Forward declaration of `LogEntry` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct LogEntry; }
+// Forward declaration of `LocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct LocationOptions; }
+// Forward declaration of `NativeLogLevel` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class NativeLogLevel; }
+// Forward declaration of `Activity` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct Activity; }
+// Forward declaration of `BackgroundGeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct BackgroundGeolocationError; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "Location.hpp"
+#include "JLocation.hpp"
+#include <string>
+#include "StationaryLocation.hpp"
+#include <optional>
+#include "JStationaryLocation.hpp"
+#include "ServiceStatus.hpp"
+#include "JServiceStatus.hpp"
+#include "AuthorizationStatus.hpp"
+#include "JAuthorizationStatus.hpp"
+#include "ConfigureOptions.hpp"
+#include "JConfigureOptions.hpp"
+#include <NitroModules/Null.hpp>
+#include "LocationProvider.hpp"
+#include <variant>
+#include "JVariant_NullType_LocationProvider.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JLocationProvider.hpp"
+#include "LocationAccuracy.hpp"
+#include "JVariant_NullType_LocationAccuracy.hpp"
+#include "JLocationAccuracy.hpp"
+#include "JVariant_NullType_Double.hpp"
+#include "JVariant_NullType_Boolean.hpp"
+#include "JVariant_NullType_String.hpp"
+#include <unordered_map>
+#include "JVariant_NullType_Map_String__String_.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include "JVariant_NullType_AnyMap.hpp"
+#include <NitroModules/JAnyMap.hpp>
+#include <vector>
+#include "LogEntry.hpp"
+#include "JLogEntry.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "LocationOptions.hpp"
+#include "JLocationOptions.hpp"
+#include "NativeLogLevel.hpp"
+#include "JNativeLogLevel.hpp"
+#include "JFunc_void_Location.hpp"
+#include "JFunc_void_StationaryLocation.hpp"
+#include "Activity.hpp"
+#include "JFunc_void_Activity.hpp"
+#include "JActivity.hpp"
+#include "BackgroundGeolocationError.hpp"
+#include "JFunc_void_BackgroundGeolocationError.hpp"
+#include "JBackgroundGeolocationError.hpp"
+#include "JFunc_void_AuthorizationStatus.hpp"
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  std::shared_ptr<JHybridNitroBackgroundGeolocationSpec> JHybridNitroBackgroundGeolocationSpec::JavaPart::getJHybridNitroBackgroundGeolocationSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroBackgroundGeolocationSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroBackgroundGeolocationSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroBackgroundGeolocationSpec::CxxPart::jhybriddata> JHybridNitroBackgroundGeolocationSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroBackgroundGeolocationSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroBackgroundGeolocationSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroBackgroundGeolocationSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroBackgroundGeolocationSpec>(castJavaPart);
+  }
+
+  void JHybridNitroBackgroundGeolocationSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroBackgroundGeolocationSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::configure(const ConfigureOptions& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JConfigureOptions> /* options */)>("configure");
+    auto __result = method(_javaPart, JConfigureOptions::fromCpp(options));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::start() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("start");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::stop() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("stop");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<Location>> JHybridNitroBackgroundGeolocationSpec::getCurrentLocation(const LocationOptions& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLocationOptions> /* options */)>("getCurrentLocation");
+    auto __result = method(_javaPart, JLocationOptions::fromCpp(options));
+    return [&]() {
+      auto __promise = Promise<Location>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JLocation>(__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;
+    }();
+  }
+  std::shared_ptr<Promise<std::optional<StationaryLocation>>> JHybridNitroBackgroundGeolocationSpec::getStationaryLocation() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getStationaryLocation");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::optional<StationaryLocation>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JStationaryLocation>(__boxedResult);
+        __promise->resolve(__result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt);
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<ServiceStatus>> JHybridNitroBackgroundGeolocationSpec::checkStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("checkStatus");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<ServiceStatus>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JServiceStatus>(__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;
+    }();
+  }
+  std::shared_ptr<Promise<ConfigureOptions>> JHybridNitroBackgroundGeolocationSpec::getConfig() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getConfig");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<ConfigureOptions>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JConfigureOptions>(__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;
+    }();
+  }
+  void JHybridNitroBackgroundGeolocationSpec::showAppSettings() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("showAppSettings");
+    method(_javaPart);
+  }
+  void JHybridNitroBackgroundGeolocationSpec::showLocationSettings() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("showLocationSettings");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<std::vector<Location>>> JHybridNitroBackgroundGeolocationSpec::getLocations() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getLocations");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<Location>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JLocation>>(__boxedResult);
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<Location> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(__result));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<Location>>> JHybridNitroBackgroundGeolocationSpec::getValidLocations() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getValidLocations");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<Location>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JLocation>>(__boxedResult);
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<Location> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(__result));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<Location>>> JHybridNitroBackgroundGeolocationSpec::getValidLocationsAndDelete() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getValidLocationsAndDelete");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<Location>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JLocation>>(__boxedResult);
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<Location> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(__result));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::deleteLocation(double locationId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* locationId */)>("deleteLocation");
+    auto __result = method(_javaPart, locationId);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::deleteAllLocations() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("deleteAllLocations");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroBackgroundGeolocationSpec::forceSync() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("forceSync");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::vector<LogEntry>>> JHybridNitroBackgroundGeolocationSpec::getLogEntries(double limit, double fromId, NativeLogLevel minLevel) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* limit */, double /* fromId */, jni::alias_ref<JNativeLogLevel> /* minLevel */)>("getLogEntries");
+    auto __result = method(_javaPart, limit, fromId, JNativeLogLevel::fromCpp(minLevel));
+    return [&]() {
+      auto __promise = Promise<std::vector<LogEntry>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JLogEntry>>(__boxedResult);
+        __promise->resolve([&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<LogEntry> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(__result));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::function<void()> JHybridNitroBackgroundGeolocationSpec::onLocation(const std::function<void(const Location& /* location */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_Location::javaobject> /* callback */)>("onLocation_cxx");
+    auto __result = method(_javaPart, JFunc_void_Location_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onStationary(const std::function<void(const StationaryLocation& /* location */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_StationaryLocation::javaobject> /* callback */)>("onStationary_cxx");
+    auto __result = method(_javaPart, JFunc_void_StationaryLocation_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onActivity(const std::function<void(const Activity& /* activity */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_Activity::javaobject> /* callback */)>("onActivity_cxx");
+    auto __result = method(_javaPart, JFunc_void_Activity_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onStart(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onStart_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onStop(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onStop_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onError(const std::function<void(const BackgroundGeolocationError& /* error */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_BackgroundGeolocationError::javaobject> /* callback */)>("onError_cxx");
+    auto __result = method(_javaPart, JFunc_void_BackgroundGeolocationError_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onAuthorization(const std::function<void(AuthorizationStatus /* status */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_AuthorizationStatus::javaobject> /* callback */)>("onAuthorization_cxx");
+    auto __result = method(_javaPart, JFunc_void_AuthorizationStatus_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onForeground(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onForeground_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onBackground(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onBackground_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onAbortRequested(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onAbortRequested_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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::function<void()> JHybridNitroBackgroundGeolocationSpec::onHttpAuthorization(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onHttpAuthorization_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(callback));
+    return [&]() -> 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));
+      }
+    }();
+  }
+  void JHybridNitroBackgroundGeolocationSpec::removeAllListeners() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("removeAllListeners");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

@@ -0,0 +1,90 @@
+///
+/// HybridNitroBackgroundGeolocationSpec.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 "HybridNitroBackgroundGeolocationSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  class JHybridNitroBackgroundGeolocationSpec: public virtual HybridNitroBackgroundGeolocationSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/HybridNitroBackgroundGeolocationSpec;";
+      std::shared_ptr<JHybridNitroBackgroundGeolocationSpec> getJHybridNitroBackgroundGeolocationSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/HybridNitroBackgroundGeolocationSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroBackgroundGeolocationSpec(const jni::local_ref<JHybridNitroBackgroundGeolocationSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroBackgroundGeolocationSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroBackgroundGeolocationSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroBackgroundGeolocationSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> configure(const ConfigureOptions& options) override;
+    std::shared_ptr<Promise<void>> start() override;
+    std::shared_ptr<Promise<void>> stop() override;
+    std::shared_ptr<Promise<Location>> getCurrentLocation(const LocationOptions& options) override;
+    std::shared_ptr<Promise<std::optional<StationaryLocation>>> getStationaryLocation() override;
+    std::shared_ptr<Promise<ServiceStatus>> checkStatus() override;
+    std::shared_ptr<Promise<ConfigureOptions>> getConfig() override;
+    void showAppSettings() override;
+    void showLocationSettings() override;
+    std::shared_ptr<Promise<std::vector<Location>>> getLocations() override;
+    std::shared_ptr<Promise<std::vector<Location>>> getValidLocations() override;
+    std::shared_ptr<Promise<std::vector<Location>>> getValidLocationsAndDelete() override;
+    std::shared_ptr<Promise<void>> deleteLocation(double locationId) override;
+    std::shared_ptr<Promise<void>> deleteAllLocations() override;
+    std::shared_ptr<Promise<void>> forceSync() override;
+    std::shared_ptr<Promise<std::vector<LogEntry>>> getLogEntries(double limit, double fromId, NativeLogLevel minLevel) override;
+    std::function<void()> onLocation(const std::function<void(const Location& /* location */)>& callback) override;
+    std::function<void()> onStationary(const std::function<void(const StationaryLocation& /* location */)>& callback) override;
+    std::function<void()> onActivity(const std::function<void(const Activity& /* activity */)>& callback) override;
+    std::function<void()> onStart(const std::function<void()>& callback) override;
+    std::function<void()> onStop(const std::function<void()>& callback) override;
+    std::function<void()> onError(const std::function<void(const BackgroundGeolocationError& /* error */)>& callback) override;
+    std::function<void()> onAuthorization(const std::function<void(AuthorizationStatus /* status */)>& callback) override;
+    std::function<void()> onForeground(const std::function<void()>& callback) override;
+    std::function<void()> onBackground(const std::function<void()>& callback) override;
+    std::function<void()> onAbortRequested(const std::function<void()>& callback) override;
+    std::function<void()> onHttpAuthorization(const std::function<void()>& callback) override;
+    void removeAllListeners() override;
+
+  private:
+    jni::global_ref<JHybridNitroBackgroundGeolocationSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrobackgroundgeolocation