react-native-readium 4.0.2 → 5.0.0-rc.1

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

@@ -0,0 +1,85 @@
+///
+/// JFunc_void_SelectionEvent.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 "SelectionEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JSelectionEvent.hpp"
+#include "Locator.hpp"
+#include <optional>
+#include "JLocator.hpp"
+#include <string>
+#include "LocatorLocations.hpp"
+#include "JLocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include "JLocatorText.hpp"
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: SelectionEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_SelectionEvent: public jni::JavaClass<JFunc_void_SelectionEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_SelectionEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_SelectionEvent` instance holds through JNI.
+     */
+    void invoke(const SelectionEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSelectionEvent> /* event */)>("invoke");
+      method(self(), JSelectionEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_SelectionEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_SelectionEvent_cxx final: public jni::HybridClass<JFunc_void_SelectionEvent_cxx, JFunc_void_SelectionEvent> {
+  public:
+    static jni::local_ref<JFunc_void_SelectionEvent::javaobject> fromCpp(const std::function<void(const SelectionEvent& /* event */)>& func) {
+      return JFunc_void_SelectionEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_SelectionEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JSelectionEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const SelectionEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Func_void_SelectionEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_SelectionEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_SelectionEvent_cxx(const std::function<void(const SelectionEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const SelectionEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,328 @@
+///
+/// JHybridReadiumViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridReadiumViewSpec.hpp"
+
+// Forward declaration of `ReadiumFile` to properly resolve imports.
+namespace margelo::nitro::readium { struct ReadiumFile; }
+// Forward declaration of `Locator` to properly resolve imports.
+namespace margelo::nitro::readium { struct Locator; }
+// Forward declaration of `LocatorLocations` to properly resolve imports.
+namespace margelo::nitro::readium { struct LocatorLocations; }
+// Forward declaration of `LocatorText` to properly resolve imports.
+namespace margelo::nitro::readium { struct LocatorText; }
+// Forward declaration of `Preferences` to properly resolve imports.
+namespace margelo::nitro::readium { struct Preferences; }
+// Forward declaration of `DecorationGroup` to properly resolve imports.
+namespace margelo::nitro::readium { struct DecorationGroup; }
+// Forward declaration of `Decoration` to properly resolve imports.
+namespace margelo::nitro::readium { struct Decoration; }
+// Forward declaration of `DecorationStyle` to properly resolve imports.
+namespace margelo::nitro::readium { struct DecorationStyle; }
+// Forward declaration of `SelectionAction` to properly resolve imports.
+namespace margelo::nitro::readium { struct SelectionAction; }
+// Forward declaration of `PublicationReadyEvent` to properly resolve imports.
+namespace margelo::nitro::readium { struct PublicationReadyEvent; }
+// Forward declaration of `Link` to properly resolve imports.
+namespace margelo::nitro::readium { struct Link; }
+// Forward declaration of `PublicationMetadata` to properly resolve imports.
+namespace margelo::nitro::readium { struct PublicationMetadata; }
+// Forward declaration of `Accessibility` to properly resolve imports.
+namespace margelo::nitro::readium { struct Accessibility; }
+// Forward declaration of `AccessibilityCertification` to properly resolve imports.
+namespace margelo::nitro::readium { struct AccessibilityCertification; }
+// Forward declaration of `Contributor` to properly resolve imports.
+namespace margelo::nitro::readium { struct Contributor; }
+// Forward declaration of `Subject` to properly resolve imports.
+namespace margelo::nitro::readium { struct Subject; }
+// Forward declaration of `BelongsTo` to properly resolve imports.
+namespace margelo::nitro::readium { struct BelongsTo; }
+// Forward declaration of `SeriesInfo` to properly resolve imports.
+namespace margelo::nitro::readium { struct SeriesInfo; }
+// Forward declaration of `DecorationActivatedEvent` to properly resolve imports.
+namespace margelo::nitro::readium { struct DecorationActivatedEvent; }
+// Forward declaration of `Rect` to properly resolve imports.
+namespace margelo::nitro::readium { struct Rect; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace margelo::nitro::readium { struct Point; }
+// Forward declaration of `SelectionEvent` to properly resolve imports.
+namespace margelo::nitro::readium { struct SelectionEvent; }
+// Forward declaration of `SelectionActionEvent` to properly resolve imports.
+namespace margelo::nitro::readium { struct SelectionActionEvent; }
+
+#include "ReadiumFile.hpp"
+#include "JReadiumFile.hpp"
+#include <string>
+#include "Locator.hpp"
+#include <optional>
+#include "JLocator.hpp"
+#include "LocatorLocations.hpp"
+#include "JLocatorLocations.hpp"
+#include "LocatorText.hpp"
+#include "JLocatorText.hpp"
+#include "Preferences.hpp"
+#include "JPreferences.hpp"
+#include "DecorationGroup.hpp"
+#include <vector>
+#include "JDecorationGroup.hpp"
+#include "Decoration.hpp"
+#include "JDecoration.hpp"
+#include "DecorationStyle.hpp"
+#include "JDecorationStyle.hpp"
+#include <unordered_map>
+#include "SelectionAction.hpp"
+#include "JSelectionAction.hpp"
+#include <functional>
+#include "JFunc_void_Locator.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "PublicationReadyEvent.hpp"
+#include "JFunc_void_PublicationReadyEvent.hpp"
+#include "JPublicationReadyEvent.hpp"
+#include "Link.hpp"
+#include "JLink.hpp"
+#include "PublicationMetadata.hpp"
+#include "JPublicationMetadata.hpp"
+#include "Accessibility.hpp"
+#include "JAccessibility.hpp"
+#include "AccessibilityCertification.hpp"
+#include "JAccessibilityCertification.hpp"
+#include "Contributor.hpp"
+#include "JContributor.hpp"
+#include "Subject.hpp"
+#include "JSubject.hpp"
+#include "BelongsTo.hpp"
+#include "JBelongsTo.hpp"
+#include "SeriesInfo.hpp"
+#include "JSeriesInfo.hpp"
+#include "DecorationActivatedEvent.hpp"
+#include "JFunc_void_DecorationActivatedEvent.hpp"
+#include "JDecorationActivatedEvent.hpp"
+#include "Rect.hpp"
+#include "JRect.hpp"
+#include "Point.hpp"
+#include "JPoint.hpp"
+#include "SelectionEvent.hpp"
+#include "JFunc_void_SelectionEvent.hpp"
+#include "JSelectionEvent.hpp"
+#include "SelectionActionEvent.hpp"
+#include "JFunc_void_SelectionActionEvent.hpp"
+#include "JSelectionActionEvent.hpp"
+
+namespace margelo::nitro::readium {
+
+  jni::local_ref<JHybridReadiumViewSpec::jhybriddata> JHybridReadiumViewSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridReadiumViewSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridReadiumViewSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridReadiumViewSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridReadiumViewSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridReadiumViewSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridReadiumViewSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridReadiumViewSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  ReadiumFile JHybridReadiumViewSpec::getFile() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JReadiumFile>()>("getFile");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridReadiumViewSpec::setFile(const ReadiumFile& file) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JReadiumFile> /* file */)>("setFile");
+    method(_javaPart, JReadiumFile::fromCpp(file));
+  }
+  std::optional<Locator> JHybridReadiumViewSpec::getLocation() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JLocator>()>("getLocation");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridReadiumViewSpec::setLocation(const std::optional<Locator>& location) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLocator> /* location */)>("setLocation");
+    method(_javaPart, location.has_value() ? JLocator::fromCpp(location.value()) : nullptr);
+  }
+  std::optional<Preferences> JHybridReadiumViewSpec::getPreferences() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPreferences>()>("getPreferences");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridReadiumViewSpec::setPreferences(const std::optional<Preferences>& preferences) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPreferences> /* preferences */)>("setPreferences");
+    method(_javaPart, preferences.has_value() ? JPreferences::fromCpp(preferences.value()) : nullptr);
+  }
+  std::optional<std::vector<DecorationGroup>> JHybridReadiumViewSpec::getDecorations() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDecorationGroup>>()>("getDecorations");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<DecorationGroup> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridReadiumViewSpec::setDecorations(const std::optional<std::vector<DecorationGroup>>& decorations) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JDecorationGroup>> /* decorations */)>("setDecorations");
+    method(_javaPart, decorations.has_value() ? [&]() {
+      size_t __size = decorations.value().size();
+      jni::local_ref<jni::JArrayClass<JDecorationGroup>> __array = jni::JArrayClass<JDecorationGroup>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = decorations.value()[__i];
+        auto __elementJni = JDecorationGroup::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::optional<std::vector<SelectionAction>> JHybridReadiumViewSpec::getSelectionActions() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JSelectionAction>>()>("getSelectionActions");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<SelectionAction> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridReadiumViewSpec::setSelectionActions(const std::optional<std::vector<SelectionAction>>& selectionActions) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JSelectionAction>> /* selectionActions */)>("setSelectionActions");
+    method(_javaPart, selectionActions.has_value() ? [&]() {
+      size_t __size = selectionActions.value().size();
+      jni::local_ref<jni::JArrayClass<JSelectionAction>> __array = jni::JArrayClass<JSelectionAction>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = selectionActions.value()[__i];
+        auto __elementJni = JSelectionAction::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::function<void(const Locator& /* locator */)> JHybridReadiumViewSpec::getOnLocationChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_Locator::javaobject>()>("getOnLocationChange_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const Locator& /* locator */)> {
+      if (__result->isInstanceOf(JFunc_void_Locator_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_Locator_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_Locator, void(Locator)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridReadiumViewSpec::setOnLocationChange(const std::function<void(const Locator& /* locator */)>& onLocationChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_Locator::javaobject> /* onLocationChange */)>("setOnLocationChange_cxx");
+    method(_javaPart, JFunc_void_Locator_cxx::fromCpp(onLocationChange));
+  }
+  std::function<void(const PublicationReadyEvent& /* event */)> JHybridReadiumViewSpec::getOnPublicationReady() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_PublicationReadyEvent::javaobject>()>("getOnPublicationReady_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const PublicationReadyEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_PublicationReadyEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_PublicationReadyEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_PublicationReadyEvent, void(PublicationReadyEvent)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridReadiumViewSpec::setOnPublicationReady(const std::function<void(const PublicationReadyEvent& /* event */)>& onPublicationReady) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_PublicationReadyEvent::javaobject> /* onPublicationReady */)>("setOnPublicationReady_cxx");
+    method(_javaPart, JFunc_void_PublicationReadyEvent_cxx::fromCpp(onPublicationReady));
+  }
+  std::function<void(const DecorationActivatedEvent& /* event */)> JHybridReadiumViewSpec::getOnDecorationActivated() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_DecorationActivatedEvent::javaobject>()>("getOnDecorationActivated_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const DecorationActivatedEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_DecorationActivatedEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_DecorationActivatedEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_DecorationActivatedEvent, void(DecorationActivatedEvent)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridReadiumViewSpec::setOnDecorationActivated(const std::function<void(const DecorationActivatedEvent& /* event */)>& onDecorationActivated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_DecorationActivatedEvent::javaobject> /* onDecorationActivated */)>("setOnDecorationActivated_cxx");
+    method(_javaPart, JFunc_void_DecorationActivatedEvent_cxx::fromCpp(onDecorationActivated));
+  }
+  std::function<void(const SelectionEvent& /* event */)> JHybridReadiumViewSpec::getOnSelectionChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_SelectionEvent::javaobject>()>("getOnSelectionChange_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const SelectionEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_SelectionEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_SelectionEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_SelectionEvent, void(SelectionEvent)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridReadiumViewSpec::setOnSelectionChange(const std::function<void(const SelectionEvent& /* event */)>& onSelectionChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_SelectionEvent::javaobject> /* onSelectionChange */)>("setOnSelectionChange_cxx");
+    method(_javaPart, JFunc_void_SelectionEvent_cxx::fromCpp(onSelectionChange));
+  }
+  std::function<void(const SelectionActionEvent& /* event */)> JHybridReadiumViewSpec::getOnSelectionAction() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_SelectionActionEvent::javaobject>()>("getOnSelectionAction_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const SelectionActionEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_SelectionActionEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_SelectionActionEvent_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_SelectionActionEvent, void(SelectionActionEvent)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridReadiumViewSpec::setOnSelectionAction(const std::function<void(const SelectionActionEvent& /* event */)>& onSelectionAction) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_SelectionActionEvent::javaobject> /* onSelectionAction */)>("setOnSelectionAction_cxx");
+    method(_javaPart, JFunc_void_SelectionActionEvent_cxx::fromCpp(onSelectionAction));
+  }
+
+  // Methods
+  void JHybridReadiumViewSpec::goForward() {
+    static const auto method = javaClassStatic()->getMethod<void()>("goForward");
+    method(_javaPart);
+  }
+  void JHybridReadiumViewSpec::goBackward() {
+    static const auto method = javaClassStatic()->getMethod<void()>("goBackward");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,86 @@
+///
+/// HybridReadiumViewSpec.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 "HybridReadiumViewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  class JHybridReadiumViewSpec: public jni::HybridClass<JHybridReadiumViewSpec, JHybridObject>,
+                                public virtual HybridReadiumViewSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/HybridReadiumViewSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridReadiumViewSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridReadiumViewSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridReadiumViewSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridReadiumViewSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    ReadiumFile getFile() override;
+    void setFile(const ReadiumFile& file) override;
+    std::optional<Locator> getLocation() override;
+    void setLocation(const std::optional<Locator>& location) override;
+    std::optional<Preferences> getPreferences() override;
+    void setPreferences(const std::optional<Preferences>& preferences) override;
+    std::optional<std::vector<DecorationGroup>> getDecorations() override;
+    void setDecorations(const std::optional<std::vector<DecorationGroup>>& decorations) override;
+    std::optional<std::vector<SelectionAction>> getSelectionActions() override;
+    void setSelectionActions(const std::optional<std::vector<SelectionAction>>& selectionActions) override;
+    std::function<void(const Locator& /* locator */)> getOnLocationChange() override;
+    void setOnLocationChange(const std::function<void(const Locator& /* locator */)>& onLocationChange) override;
+    std::function<void(const PublicationReadyEvent& /* event */)> getOnPublicationReady() override;
+    void setOnPublicationReady(const std::function<void(const PublicationReadyEvent& /* event */)>& onPublicationReady) override;
+    std::function<void(const DecorationActivatedEvent& /* event */)> getOnDecorationActivated() override;
+    void setOnDecorationActivated(const std::function<void(const DecorationActivatedEvent& /* event */)>& onDecorationActivated) override;
+    std::function<void(const SelectionEvent& /* event */)> getOnSelectionChange() override;
+    void setOnSelectionChange(const std::function<void(const SelectionEvent& /* event */)>& onSelectionChange) override;
+    std::function<void(const SelectionActionEvent& /* event */)> getOnSelectionAction() override;
+    void setOnSelectionAction(const std::function<void(const SelectionActionEvent& /* event */)>& onSelectionAction) override;
+
+  public:
+    // Methods
+    void goForward() override;
+    void goBackward() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridReadiumViewSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::readium

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

@@ -0,0 +1,131 @@
+///
+/// JLink.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 "Link.hpp"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::readium {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Link" and the the Kotlin data class "Link".
+   */
+  struct JLink final: public jni::JavaClass<JLink> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativereadium/Link;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Link by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Link toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldHref = clazz->getField<jni::JString>("href");
+      jni::local_ref<jni::JString> href = this->getFieldValue(fieldHref);
+      static const auto fieldTemplated = clazz->getField<jboolean>("templated");
+      jboolean templated = this->getFieldValue(fieldTemplated);
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldTitle = clazz->getField<jni::JString>("title");
+      jni::local_ref<jni::JString> title = this->getFieldValue(fieldTitle);
+      static const auto fieldRels = clazz->getField<jni::JArrayClass<jni::JString>>("rels");
+      jni::local_ref<jni::JArrayClass<jni::JString>> rels = this->getFieldValue(fieldRels);
+      static const auto fieldHeight = clazz->getField<jni::JDouble>("height");
+      jni::local_ref<jni::JDouble> height = this->getFieldValue(fieldHeight);
+      static const auto fieldWidth = clazz->getField<jni::JDouble>("width");
+      jni::local_ref<jni::JDouble> width = this->getFieldValue(fieldWidth);
+      static const auto fieldBitrate = clazz->getField<jni::JDouble>("bitrate");
+      jni::local_ref<jni::JDouble> bitrate = this->getFieldValue(fieldBitrate);
+      static const auto fieldDuration = clazz->getField<jni::JDouble>("duration");
+      jni::local_ref<jni::JDouble> duration = this->getFieldValue(fieldDuration);
+      static const auto fieldLanguages = clazz->getField<jni::JArrayClass<jni::JString>>("languages");
+      jni::local_ref<jni::JArrayClass<jni::JString>> languages = this->getFieldValue(fieldLanguages);
+      return Link(
+        href->toStdString(),
+        static_cast<bool>(templated),
+        type != nullptr ? std::make_optional(type->toStdString()) : std::nullopt,
+        title != nullptr ? std::make_optional(title->toStdString()) : std::nullopt,
+        rels != nullptr ? std::make_optional([&]() {
+          size_t __size = rels->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = rels->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }()) : std::nullopt,
+        height != nullptr ? std::make_optional(height->value()) : std::nullopt,
+        width != nullptr ? std::make_optional(width->value()) : std::nullopt,
+        bitrate != nullptr ? std::make_optional(bitrate->value()) : std::nullopt,
+        duration != nullptr ? std::make_optional(duration->value()) : std::nullopt,
+        languages != nullptr ? std::make_optional([&]() {
+          size_t __size = languages->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = languages->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLink::javaobject> fromCpp(const Link& value) {
+      using JSignature = JLink(jni::alias_ref<jni::JString>, jboolean, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayClass<jni::JString>>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JArrayClass<jni::JString>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.href),
+        value.templated,
+        value.type.has_value() ? jni::make_jstring(value.type.value()) : nullptr,
+        value.title.has_value() ? jni::make_jstring(value.title.value()) : nullptr,
+        value.rels.has_value() ? [&]() {
+          size_t __size = value.rels.value().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 = value.rels.value()[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }() : nullptr,
+        value.height.has_value() ? jni::JDouble::valueOf(value.height.value()) : nullptr,
+        value.width.has_value() ? jni::JDouble::valueOf(value.width.value()) : nullptr,
+        value.bitrate.has_value() ? jni::JDouble::valueOf(value.bitrate.value()) : nullptr,
+        value.duration.has_value() ? jni::JDouble::valueOf(value.duration.value()) : nullptr,
+        value.languages.has_value() ? [&]() {
+          size_t __size = value.languages.value().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 = value.languages.value()[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }() : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::readium