react-native-cesium 1.0.1

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

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

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

@@ -0,0 +1,178 @@
+///
+/// JHybridCesiumViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridCesiumViewSpec.hpp"
+
+// Forward declaration of `CameraState` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct CameraState; }
+// Forward declaration of `CesiumMetrics` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
+
+#include <string>
+#include "CameraState.hpp"
+#include "JCameraState.hpp"
+#include "CesiumMetrics.hpp"
+#include <functional>
+#include <optional>
+#include "JFunc_void_CesiumMetrics.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JCesiumMetrics.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+
+namespace margelo::nitro::reactnativecesium {
+
+  std::shared_ptr<JHybridCesiumViewSpec> JHybridCesiumViewSpec::JavaPart::getJHybridCesiumViewSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridCesiumViewSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridCesiumViewSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridCesiumViewSpec::CxxPart::jhybriddata> JHybridCesiumViewSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridCesiumViewSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridCesiumViewSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridCesiumViewSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridCesiumViewSpec>(castJavaPart);
+  }
+
+  void JHybridCesiumViewSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridCesiumViewSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridCesiumViewSpec::getIonAccessToken() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getIonAccessToken");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridCesiumViewSpec::setIonAccessToken(const std::string& ionAccessToken) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* ionAccessToken */)>("setIonAccessToken");
+    method(_javaPart, jni::make_jstring(ionAccessToken));
+  }
+  double JHybridCesiumViewSpec::getIonAssetId() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getIonAssetId");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setIonAssetId(double ionAssetId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* ionAssetId */)>("setIonAssetId");
+    method(_javaPart, ionAssetId);
+  }
+  CameraState JHybridCesiumViewSpec::getInitialCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JCameraState>()>("getInitialCamera");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridCesiumViewSpec::setInitialCamera(const CameraState& initialCamera) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* initialCamera */)>("setInitialCamera");
+    method(_javaPart, JCameraState::fromCpp(initialCamera));
+  }
+  bool JHybridCesiumViewSpec::getPauseRendering() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getPauseRendering");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridCesiumViewSpec::setPauseRendering(bool pauseRendering) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* pauseRendering */)>("setPauseRendering");
+    method(_javaPart, pauseRendering);
+  }
+  double JHybridCesiumViewSpec::getMaximumScreenSpaceError() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaximumScreenSpaceError");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setMaximumScreenSpaceError(double maximumScreenSpaceError) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* maximumScreenSpaceError */)>("setMaximumScreenSpaceError");
+    method(_javaPart, maximumScreenSpaceError);
+  }
+  double JHybridCesiumViewSpec::getMaximumSimultaneousTileLoads() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaximumSimultaneousTileLoads");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setMaximumSimultaneousTileLoads(double maximumSimultaneousTileLoads) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* maximumSimultaneousTileLoads */)>("setMaximumSimultaneousTileLoads");
+    method(_javaPart, maximumSimultaneousTileLoads);
+  }
+  double JHybridCesiumViewSpec::getLoadingDescendantLimit() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getLoadingDescendantLimit");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setLoadingDescendantLimit(double loadingDescendantLimit) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* loadingDescendantLimit */)>("setLoadingDescendantLimit");
+    method(_javaPart, loadingDescendantLimit);
+  }
+  double JHybridCesiumViewSpec::getMsaaSampleCount() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMsaaSampleCount");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setMsaaSampleCount(double msaaSampleCount) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* msaaSampleCount */)>("setMsaaSampleCount");
+    method(_javaPart, msaaSampleCount);
+  }
+  double JHybridCesiumViewSpec::getIonImageryAssetId() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getIonImageryAssetId");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridCesiumViewSpec::setIonImageryAssetId(double ionImageryAssetId) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* ionImageryAssetId */)>("setIonImageryAssetId");
+    method(_javaPart, ionImageryAssetId);
+  }
+  std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> JHybridCesiumViewSpec::getOnMetrics() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_CesiumMetrics::javaobject>()>("getOnMetrics_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const CesiumMetrics& /* metrics */)> {
+      if (__result->isInstanceOf(JFunc_void_CesiumMetrics_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_CesiumMetrics_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_CesiumMetrics, void(CesiumMetrics)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_CesiumMetrics::javaobject> /* onMetrics */)>("setOnMetrics_cxx");
+    method(_javaPart, onMetrics.has_value() ? JFunc_void_CesiumMetrics_cxx::fromCpp(onMetrics.value()) : nullptr);
+  }
+
+  // Methods
+  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getCameraState() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCameraState");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<CameraState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JCameraState>(__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 JHybridCesiumViewSpec::setCamera(const CameraState& camera) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("setCamera");
+    method(_javaPart, JCameraState::fromCpp(camera));
+  }
+
+} // namespace margelo::nitro::reactnativecesium

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

@@ -0,0 +1,83 @@
+///
+/// HybridCesiumViewSpec.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 "HybridCesiumViewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::reactnativecesium {
+
+  using namespace facebook;
+
+  class JHybridCesiumViewSpec: public virtual HybridCesiumViewSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/HybridCesiumViewSpec;";
+      std::shared_ptr<JHybridCesiumViewSpec> getJHybridCesiumViewSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/HybridCesiumViewSpec$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 JHybridCesiumViewSpec(const jni::local_ref<JHybridCesiumViewSpec::JavaPart>& javaPart):
+      HybridObject(HybridCesiumViewSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridCesiumViewSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridCesiumViewSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getIonAccessToken() override;
+    void setIonAccessToken(const std::string& ionAccessToken) override;
+    double getIonAssetId() override;
+    void setIonAssetId(double ionAssetId) override;
+    CameraState getInitialCamera() override;
+    void setInitialCamera(const CameraState& initialCamera) override;
+    bool getPauseRendering() override;
+    void setPauseRendering(bool pauseRendering) override;
+    double getMaximumScreenSpaceError() override;
+    void setMaximumScreenSpaceError(double maximumScreenSpaceError) override;
+    double getMaximumSimultaneousTileLoads() override;
+    void setMaximumSimultaneousTileLoads(double maximumSimultaneousTileLoads) override;
+    double getLoadingDescendantLimit() override;
+    void setLoadingDescendantLimit(double loadingDescendantLimit) override;
+    double getMsaaSampleCount() override;
+    void setMsaaSampleCount(double msaaSampleCount) override;
+    double getIonImageryAssetId() override;
+    void setIonImageryAssetId(double ionImageryAssetId) override;
+    std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() override;
+    void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) override;
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<CameraState>> getCameraState() override;
+    void setCamera(const CameraState& camera) override;
+
+  private:
+    jni::global_ref<JHybridCesiumViewSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::reactnativecesium

package/nitrogen/generated/android/c++/views/JHybridCesiumViewStateUpdater.cpp

@@ -0,0 +1,92 @@
+///
+/// JHybridCesiumViewStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridCesiumViewStateUpdater.hpp"
+#include "views/HybridCesiumViewComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::reactnativecesium::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridCesiumViewState>;
+
+void JHybridCesiumViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridCesiumViewSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  std::shared_ptr<JHybridCesiumViewSpec> hybridView = javaView->getJHybridCesiumViewSpec();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridCesiumViewState& data = concreteState->getData();
+  const std::shared_ptr<HybridCesiumViewProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridCesiumViewState's data doesn't contain any props!");
+  }
+
+  // Update all props if they are dirty
+  if (props->ionAccessToken.isDirty) {
+    hybridView->setIonAccessToken(props->ionAccessToken.value);
+    props->ionAccessToken.isDirty = false;
+  }
+  if (props->ionAssetId.isDirty) {
+    hybridView->setIonAssetId(props->ionAssetId.value);
+    props->ionAssetId.isDirty = false;
+  }
+  if (props->initialCamera.isDirty) {
+    hybridView->setInitialCamera(props->initialCamera.value);
+    props->initialCamera.isDirty = false;
+  }
+  if (props->pauseRendering.isDirty) {
+    hybridView->setPauseRendering(props->pauseRendering.value);
+    props->pauseRendering.isDirty = false;
+  }
+  if (props->maximumScreenSpaceError.isDirty) {
+    hybridView->setMaximumScreenSpaceError(props->maximumScreenSpaceError.value);
+    props->maximumScreenSpaceError.isDirty = false;
+  }
+  if (props->maximumSimultaneousTileLoads.isDirty) {
+    hybridView->setMaximumSimultaneousTileLoads(props->maximumSimultaneousTileLoads.value);
+    props->maximumSimultaneousTileLoads.isDirty = false;
+  }
+  if (props->loadingDescendantLimit.isDirty) {
+    hybridView->setLoadingDescendantLimit(props->loadingDescendantLimit.value);
+    props->loadingDescendantLimit.isDirty = false;
+  }
+  if (props->msaaSampleCount.isDirty) {
+    hybridView->setMsaaSampleCount(props->msaaSampleCount.value);
+    props->msaaSampleCount.isDirty = false;
+  }
+  if (props->ionImageryAssetId.isDirty) {
+    hybridView->setIonImageryAssetId(props->ionImageryAssetId.value);
+    props->ionImageryAssetId.isDirty = false;
+  }
+  if (props->onMetrics.isDirty) {
+    hybridView->setOnMetrics(props->onMetrics.value);
+    props->onMetrics.isDirty = false;
+  }
+
+  // Update hybridRef if it changed
+  if (props->hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props->hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(hybridView);
+    }
+    props->hybridRef.isDirty = false;
+  }
+}
+
+} // namespace margelo::nitro::reactnativecesium::views

package/nitrogen/generated/android/c++/views/JHybridCesiumViewStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridCesiumViewStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error ReactNativeCesium was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridCesiumViewSpec.hpp"
+#include "views/HybridCesiumViewComponent.hpp"
+
+namespace margelo::nitro::reactnativecesium::views {
+
+using namespace facebook;
+
+class JHybridCesiumViewStateUpdater final: public jni::JavaClass<JHybridCesiumViewStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/views/HybridCesiumViewStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridCesiumViewSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridCesiumViewStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridCesiumViewComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::reactnativecesium::views

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/CameraState.kt

@@ -0,0 +1,56 @@
+///
+/// CameraState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativecesium
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "CameraState".
+ */
+@DoNotStrip
+@Keep
+data class CameraState(
+  @DoNotStrip
+  @Keep
+  val latitude: Double,
+  @DoNotStrip
+  @Keep
+  val longitude: Double,
+  @DoNotStrip
+  @Keep
+  val altitude: Double,
+  @DoNotStrip
+  @Keep
+  val heading: Double,
+  @DoNotStrip
+  @Keep
+  val pitch: Double,
+  @DoNotStrip
+  @Keep
+  val roll: Double,
+  @DoNotStrip
+  @Keep
+  val verticalFovDeg: Double
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(latitude: Double, longitude: Double, altitude: Double, heading: Double, pitch: Double, roll: Double, verticalFovDeg: Double): CameraState {
+      return CameraState(latitude, longitude, altitude, heading, pitch, roll, verticalFovDeg)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/CesiumMetrics.kt

@@ -0,0 +1,56 @@
+///
+/// CesiumMetrics.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativecesium
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "CesiumMetrics".
+ */
+@DoNotStrip
+@Keep
+data class CesiumMetrics(
+  @DoNotStrip
+  @Keep
+  val fps: Double,
+  @DoNotStrip
+  @Keep
+  val tilesRendered: Double,
+  @DoNotStrip
+  @Keep
+  val tilesLoading: Double,
+  @DoNotStrip
+  @Keep
+  val tilesVisited: Double,
+  @DoNotStrip
+  @Keep
+  val ionTokenConfigured: Boolean,
+  @DoNotStrip
+  @Keep
+  val tilesetReady: Boolean,
+  @DoNotStrip
+  @Keep
+  val creditsPlainText: String
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(fps: Double, tilesRendered: Double, tilesLoading: Double, tilesVisited: Double, ionTokenConfigured: Boolean, tilesetReady: Boolean, creditsPlainText: String): CesiumMetrics {
+      return CesiumMetrics(fps, tilesRendered, tilesLoading, tilesVisited, ionTokenConfigured, tilesetReady, creditsPlainText)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/Func_void_CesiumMetrics.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_CesiumMetrics.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativecesium
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(metrics: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_CesiumMetrics: (CesiumMetrics) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(metrics: CesiumMetrics): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(metrics: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_CesiumMetrics_cxx: Func_void_CesiumMetrics {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(metrics: CesiumMetrics): Unit
+    = invoke_cxx(metrics)
+
+  @FastNative
+  private external fun invoke_cxx(metrics: CesiumMetrics): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(metrics: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(CesiumMetrics) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_CesiumMetrics_java(private val function: (CesiumMetrics) -> Unit): Func_void_CesiumMetrics {
+  @DoNotStrip
+  @Keep
+  override fun invoke(metrics: CesiumMetrics): Unit {
+    return this.function(metrics)
+  }
+}