react-native-nitro-ar 2026.2.1

package/nitrogen/generated/ios/c++/HybridARViewSpecSwift.hpp

@@ -0,0 +1,243 @@
+///
+/// HybridARViewSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARViewSpec.hpp"
+
+// Forward declaration of `HybridARViewSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARViewSpec_cxx; }
+
+// Forward declaration of `SceneReconstructionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class SceneReconstructionMode; }
+// Forward declaration of `ARViewHitResult` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARViewHitResult; }
+
+#include <optional>
+#include "SceneReconstructionMode.hpp"
+#include <string>
+#include "ARViewHitResult.hpp"
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARViewSpec_cxx.swift.
+   *
+   * HybridARViewSpecSwift (C++) accesses HybridARViewSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARViewSpec_cxx can directly inherit from the C++ class HybridARViewSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARViewSpecSwift: public virtual HybridARViewSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARViewSpecSwift(const NitroAR::HybridARViewSpec_cxx& swiftPart):
+      HybridObject(HybridARViewSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARViewSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARViewSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<bool> getShowDebugOptions() noexcept override {
+      auto __result = _swiftPart.getShowDebugOptions();
+      return __result;
+    }
+    inline void setShowDebugOptions(std::optional<bool> showDebugOptions) noexcept override {
+      _swiftPart.setShowDebugOptions(showDebugOptions);
+    }
+    inline std::optional<bool> getShowPlanes() noexcept override {
+      auto __result = _swiftPart.getShowPlanes();
+      return __result;
+    }
+    inline void setShowPlanes(std::optional<bool> showPlanes) noexcept override {
+      _swiftPart.setShowPlanes(showPlanes);
+    }
+    inline std::optional<bool> getShowFeaturePoints() noexcept override {
+      auto __result = _swiftPart.getShowFeaturePoints();
+      return __result;
+    }
+    inline void setShowFeaturePoints(std::optional<bool> showFeaturePoints) noexcept override {
+      _swiftPart.setShowFeaturePoints(showFeaturePoints);
+    }
+    inline std::optional<bool> getShowWorldOrigin() noexcept override {
+      auto __result = _swiftPart.getShowWorldOrigin();
+      return __result;
+    }
+    inline void setShowWorldOrigin(std::optional<bool> showWorldOrigin) noexcept override {
+      _swiftPart.setShowWorldOrigin(showWorldOrigin);
+    }
+    inline std::optional<bool> getAutoenablesDefaultLighting() noexcept override {
+      auto __result = _swiftPart.getAutoenablesDefaultLighting();
+      return __result;
+    }
+    inline void setAutoenablesDefaultLighting(std::optional<bool> autoenablesDefaultLighting) noexcept override {
+      _swiftPart.setAutoenablesDefaultLighting(autoenablesDefaultLighting);
+    }
+    inline std::optional<SceneReconstructionMode> getSceneReconstruction() noexcept override {
+      auto __result = _swiftPart.getSceneReconstruction();
+      return __result;
+    }
+    inline void setSceneReconstruction(std::optional<SceneReconstructionMode> sceneReconstruction) noexcept override {
+      _swiftPart.setSceneReconstruction(sceneReconstruction);
+    }
+    inline std::optional<bool> getShowSceneMesh() noexcept override {
+      auto __result = _swiftPart.getShowSceneMesh();
+      return __result;
+    }
+    inline void setShowSceneMesh(std::optional<bool> showSceneMesh) noexcept override {
+      _swiftPart.setShowSceneMesh(showSceneMesh);
+    }
+    inline std::optional<bool> getSceneDepth() noexcept override {
+      auto __result = _swiftPart.getSceneDepth();
+      return __result;
+    }
+    inline void setSceneDepth(std::optional<bool> sceneDepth) noexcept override {
+      _swiftPart.setSceneDepth(sceneDepth);
+    }
+    inline std::optional<bool> getObjectOcclusion() noexcept override {
+      auto __result = _swiftPart.getObjectOcclusion();
+      return __result;
+    }
+    inline void setObjectOcclusion(std::optional<bool> objectOcclusion) noexcept override {
+      _swiftPart.setObjectOcclusion(objectOcclusion);
+    }
+    inline std::optional<bool> getPeopleOcclusion() noexcept override {
+      auto __result = _swiftPart.getPeopleOcclusion();
+      return __result;
+    }
+    inline void setPeopleOcclusion(std::optional<bool> peopleOcclusion) noexcept override {
+      _swiftPart.setPeopleOcclusion(peopleOcclusion);
+    }
+
+  public:
+    // Methods
+    inline void addMeasurementPoint(const std::string& id, double x, double y, double z, const std::optional<std::string>& color) override {
+      auto __result = _swiftPart.addMeasurementPoint(id, std::forward<decltype(x)>(x), std::forward<decltype(y)>(y), std::forward<decltype(z)>(z), color);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeMeasurementPoint(const std::string& id) override {
+      auto __result = _swiftPart.removeMeasurementPoint(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateMeasurementPoint(const std::string& id, double x, double y, double z) override {
+      auto __result = _swiftPart.updateMeasurementPoint(id, std::forward<decltype(x)>(x), std::forward<decltype(y)>(y), std::forward<decltype(z)>(z));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addLine(const std::string& id, double fromX, double fromY, double fromZ, double toX, double toY, double toZ, const std::optional<std::string>& color) override {
+      auto __result = _swiftPart.addLine(id, std::forward<decltype(fromX)>(fromX), std::forward<decltype(fromY)>(fromY), std::forward<decltype(fromZ)>(fromZ), std::forward<decltype(toX)>(toX), std::forward<decltype(toY)>(toY), std::forward<decltype(toZ)>(toZ), color);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateLine(const std::string& id, double fromX, double fromY, double fromZ, double toX, double toY, double toZ) override {
+      auto __result = _swiftPart.updateLine(id, std::forward<decltype(fromX)>(fromX), std::forward<decltype(fromY)>(fromY), std::forward<decltype(fromZ)>(fromZ), std::forward<decltype(toX)>(toX), std::forward<decltype(toY)>(toY), std::forward<decltype(toZ)>(toZ));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeLine(const std::string& id) override {
+      auto __result = _swiftPart.removeLine(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addDistanceLabel(const std::string& id, double x, double y, double z, double distance) override {
+      auto __result = _swiftPart.addDistanceLabel(id, std::forward<decltype(x)>(x), std::forward<decltype(y)>(y), std::forward<decltype(z)>(z), std::forward<decltype(distance)>(distance));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateDistanceLabel(const std::string& id, double x, double y, double z, double distance) override {
+      auto __result = _swiftPart.updateDistanceLabel(id, std::forward<decltype(x)>(x), std::forward<decltype(y)>(y), std::forward<decltype(z)>(z), std::forward<decltype(distance)>(distance));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeDistanceLabel(const std::string& id) override {
+      auto __result = _swiftPart.removeDistanceLabel(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void clearAllVisuals() override {
+      auto __result = _swiftPart.clearAllVisuals();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::optional<ARViewHitResult> raycast(double x, double y) override {
+      auto __result = _swiftPart.raycast(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void startSession() override {
+      auto __result = _swiftPart.startSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void pauseSession() override {
+      auto __result = _swiftPart.pauseSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void resetSession() override {
+      auto __result = _swiftPart.resetSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool isLiDARAvailable() override {
+      auto __result = _swiftPart.isLiDARAvailable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARViewSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARVolumeSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridARVolumeSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARVolumeSpecSwift.hpp"
+
+namespace margelo::nitro::ar {
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARVolumeSpecSwift.hpp

@@ -0,0 +1,94 @@
+///
+/// HybridARVolumeSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARVolumeSpec.hpp"
+
+// Forward declaration of `HybridARVolumeSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARVolumeSpec_cxx; }
+
+
+
+#include <vector>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARVolumeSpec_cxx.swift.
+   *
+   * HybridARVolumeSpecSwift (C++) accesses HybridARVolumeSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARVolumeSpec_cxx can directly inherit from the C++ class HybridARVolumeSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARVolumeSpecSwift: public virtual HybridARVolumeSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARVolumeSpecSwift(const NitroAR::HybridARVolumeSpec_cxx& swiftPart):
+      HybridObject(HybridARVolumeSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARVolumeSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARVolumeSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::vector<double> getCenter() noexcept override {
+      auto __result = _swiftPart.getCenter();
+      return __result;
+    }
+    inline double getWidth() noexcept override {
+      return _swiftPart.getWidth();
+    }
+    inline double getHeight() noexcept override {
+      return _swiftPart.getHeight();
+    }
+    inline double getDepth() noexcept override {
+      return _swiftPart.getDepth();
+    }
+    inline std::vector<double> getRotation() noexcept override {
+      auto __result = _swiftPart.getRotation();
+      return __result;
+    }
+    inline bool getIsStable() noexcept override {
+      return _swiftPart.isStable();
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroAR::HybridARVolumeSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARWorldMapSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridARWorldMapSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARWorldMapSpecSwift.hpp"
+
+namespace margelo::nitro::ar {
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARWorldMapSpecSwift.hpp

@@ -0,0 +1,97 @@
+///
+/// HybridARWorldMapSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARWorldMapSpec.hpp"
+
+// Forward declaration of `HybridARWorldMapSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARWorldMapSpec_cxx; }
+
+
+
+#include <string>
+#include <vector>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARWorldMapSpec_cxx.swift.
+   *
+   * HybridARWorldMapSpecSwift (C++) accesses HybridARWorldMapSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARWorldMapSpec_cxx can directly inherit from the C++ class HybridARWorldMapSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARWorldMapSpecSwift: public virtual HybridARWorldMapSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARWorldMapSpecSwift(const NitroAR::HybridARWorldMapSpec_cxx& swiftPart):
+      HybridObject(HybridARWorldMapSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARWorldMapSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARWorldMapSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::string getIdentifier() noexcept override {
+      auto __result = _swiftPart.getIdentifier();
+      return __result;
+    }
+    inline std::vector<double> getCenter() noexcept override {
+      auto __result = _swiftPart.getCenter();
+      return __result;
+    }
+    inline std::vector<double> getExtent() noexcept override {
+      auto __result = _swiftPart.getExtent();
+      return __result;
+    }
+    inline double getAnchorCount() noexcept override {
+      return _swiftPart.getAnchorCount();
+    }
+
+  public:
+    // Methods
+    inline std::string getData() override {
+      auto __result = _swiftPart.getData();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARWorldMapSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/views/HybridARViewComponent.mm

@@ -0,0 +1,152 @@
+///
+/// HybridARViewComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import "HybridARViewComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridARViewSpecSwift.hpp"
+#import "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+using namespace facebook;
+using namespace margelo::nitro::ar;
+using namespace margelo::nitro::ar::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "ARView" HybridView.
+ */
+@interface HybridARViewComponent: RCTViewComponentView
++ (BOOL)shouldBeRecycled;
+@end
+
+@implementation HybridARViewComponent {
+  std::shared_ptr<HybridARViewSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridARViewComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridARViewComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridARViewSpec> hybridView = NitroAR::NitroARAutolinking::createARView();
+    _hybridView = std::dynamic_pointer_cast<HybridARViewSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  NitroAR::HybridARViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridARViewProps const>(props);
+  auto& newViewProps = const_cast<HybridARViewProps&>(newViewPropsConst);
+  NitroAR::HybridARViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // showDebugOptions: optional
+  if (newViewProps.showDebugOptions.isDirty) {
+    swiftPart.setShowDebugOptions(newViewProps.showDebugOptions.value);
+    newViewProps.showDebugOptions.isDirty = false;
+  }
+  // showPlanes: optional
+  if (newViewProps.showPlanes.isDirty) {
+    swiftPart.setShowPlanes(newViewProps.showPlanes.value);
+    newViewProps.showPlanes.isDirty = false;
+  }
+  // showFeaturePoints: optional
+  if (newViewProps.showFeaturePoints.isDirty) {
+    swiftPart.setShowFeaturePoints(newViewProps.showFeaturePoints.value);
+    newViewProps.showFeaturePoints.isDirty = false;
+  }
+  // showWorldOrigin: optional
+  if (newViewProps.showWorldOrigin.isDirty) {
+    swiftPart.setShowWorldOrigin(newViewProps.showWorldOrigin.value);
+    newViewProps.showWorldOrigin.isDirty = false;
+  }
+  // autoenablesDefaultLighting: optional
+  if (newViewProps.autoenablesDefaultLighting.isDirty) {
+    swiftPart.setAutoenablesDefaultLighting(newViewProps.autoenablesDefaultLighting.value);
+    newViewProps.autoenablesDefaultLighting.isDirty = false;
+  }
+  // sceneReconstruction: optional
+  if (newViewProps.sceneReconstruction.isDirty) {
+    swiftPart.setSceneReconstruction(newViewProps.sceneReconstruction.value);
+    newViewProps.sceneReconstruction.isDirty = false;
+  }
+  // showSceneMesh: optional
+  if (newViewProps.showSceneMesh.isDirty) {
+    swiftPart.setShowSceneMesh(newViewProps.showSceneMesh.value);
+    newViewProps.showSceneMesh.isDirty = false;
+  }
+  // sceneDepth: optional
+  if (newViewProps.sceneDepth.isDirty) {
+    swiftPart.setSceneDepth(newViewProps.sceneDepth.value);
+    newViewProps.sceneDepth.isDirty = false;
+  }
+  // objectOcclusion: optional
+  if (newViewProps.objectOcclusion.isDirty) {
+    swiftPart.setObjectOcclusion(newViewProps.objectOcclusion.value);
+    newViewProps.objectOcclusion.isDirty = false;
+  }
+  // peopleOcclusion: optional
+  if (newViewProps.peopleOcclusion.isDirty) {
+    swiftPart.setPeopleOcclusion(newViewProps.peopleOcclusion.value);
+    newViewProps.peopleOcclusion.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (BOOL)shouldBeRecycled {
+  return NitroAR::NitroARAutolinking::isARViewRecyclable();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  NitroAR::HybridARViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.maybePrepareForRecycle();
+}
+
+@end