react-native-cesium 1.2.18 → 1.2.19

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

@@ -17,7 +17,7 @@ namespace margelo::nitro::reactnativecesium {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "Quaternion" and the the Kotlin data class "Quaternion".
+   * The C++ JNI bridge between the C++ struct "Quaternion" and the Kotlin data class "Quaternion".
    */
   struct JQuaternion final: public jni::JavaClass<JQuaternion> {
   public:

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

@@ -15,153 +15,199 @@ 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();
-
+std::shared_ptr<const HybridCesiumViewProps> JHybridCesiumViewStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
   // 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");
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
   }
-  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();
+  const std::shared_ptr<const 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!");
   }
+  return 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->maximumCachedMiB.isDirty) {
-    hybridView->setMaximumCachedMiB(props->maximumCachedMiB.value);
-    props->maximumCachedMiB.isDirty = false;
-  }
-  if (props->preloadAncestors.isDirty) {
-    hybridView->setPreloadAncestors(props->preloadAncestors.value);
-    props->preloadAncestors.isDirty = false;
-  }
-  if (props->preloadSiblings.isDirty) {
-    hybridView->setPreloadSiblings(props->preloadSiblings.value);
-    props->preloadSiblings.isDirty = false;
-  }
-  if (props->forbidHoles.isDirty) {
-    hybridView->setForbidHoles(props->forbidHoles.value);
-    props->forbidHoles.isDirty = false;
-  }
-  if (props->enableWaterMask.isDirty) {
-    hybridView->setEnableWaterMask(props->enableWaterMask.value);
-    props->enableWaterMask.isDirty = false;
-  }
-  if (props->enableFogCulling.isDirty) {
-    hybridView->setEnableFogCulling(props->enableFogCulling.value);
-    props->enableFogCulling.isDirty = false;
-  }
-  if (props->enforceCulledScreenSpaceError.isDirty) {
-    hybridView->setEnforceCulledScreenSpaceError(props->enforceCulledScreenSpaceError.value);
-    props->enforceCulledScreenSpaceError.isDirty = false;
-  }
-  if (props->culledScreenSpaceError.isDirty) {
-    hybridView->setCulledScreenSpaceError(props->culledScreenSpaceError.value);
-    props->culledScreenSpaceError.isDirty = false;
-  }
-  if (props->enableLodTransitionPeriod.isDirty) {
-    hybridView->setEnableLodTransitionPeriod(props->enableLodTransitionPeriod.value);
-    props->enableLodTransitionPeriod.isDirty = false;
-  }
-  if (props->lodTransitionLength.isDirty) {
-    hybridView->setLodTransitionLength(props->lodTransitionLength.value);
-    props->lodTransitionLength.isDirty = false;
-  }
-  if (props->sqliteCacheMaxRows.isDirty) {
-    hybridView->setSqliteCacheMaxRows(props->sqliteCacheMaxRows.value);
-    props->sqliteCacheMaxRows.isDirty = false;
-  }
-  if (props->taskProcessorThreads.isDirty) {
-    hybridView->setTaskProcessorThreads(props->taskProcessorThreads.value);
-    props->taskProcessorThreads.isDirty = false;
-  }
-  if (props->minAltitudeAboveTerrain.isDirty) {
-    hybridView->setMinAltitudeAboveTerrain(props->minAltitudeAboveTerrain.value);
-    props->minAltitudeAboveTerrain.isDirty = false;
-  }
-  if (props->maxYawRateDegSec.isDirty) {
-    hybridView->setMaxYawRateDegSec(props->maxYawRateDegSec.value);
-    props->maxYawRateDegSec.isDirty = false;
-  }
-  if (props->maxPitchRateDegSec.isDirty) {
-    hybridView->setMaxPitchRateDegSec(props->maxPitchRateDegSec.value);
-    props->maxPitchRateDegSec.isDirty = false;
-  }
-  if (props->maxRollRateDegSec.isDirty) {
-    hybridView->setMaxRollRateDegSec(props->maxRollRateDegSec.value);
-    props->maxRollRateDegSec.isDirty = false;
-  }
-  if (props->maxClimbRateMps.isDirty) {
-    hybridView->setMaxClimbRateMps(props->maxClimbRateMps.value);
-    props->maxClimbRateMps.isDirty = false;
-  }
-  if (props->maxGroundSpeedMps.isDirty) {
-    hybridView->setMaxGroundSpeedMps(props->maxGroundSpeedMps.value);
-    props->maxGroundSpeedMps.isDirty = false;
-  }
-  if (props->onMetrics.isDirty) {
-    hybridView->setOnMetrics(props->onMetrics.value);
-    props->onMetrics.isDirty = false;
+void JHybridCesiumViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridCesiumViewSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridCesiumViewSpec> hybridView = javaView->getJHybridCesiumViewSpec();
+  std::shared_ptr<const HybridCesiumViewProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridCesiumViewProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
   }
-  if (props->onActualCamera.isDirty) {
-    hybridView->setOnActualCamera(props->onActualCamera.value);
-    props->onActualCamera.isDirty = false;
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->ionAccessToken.isProvided()
+        : !newProps->ionAccessToken.hasSameValue(oldProps->ionAccessToken)) {
+    hybridView->setIonAccessToken(newProps->ionAccessToken.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->ionAssetId.isProvided()
+        : !newProps->ionAssetId.hasSameValue(oldProps->ionAssetId)) {
+    hybridView->setIonAssetId(newProps->ionAssetId.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->initialCamera.isProvided()
+        : !newProps->initialCamera.hasSameValue(oldProps->initialCamera)) {
+    hybridView->setInitialCamera(newProps->initialCamera.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->pauseRendering.isProvided()
+        : !newProps->pauseRendering.hasSameValue(oldProps->pauseRendering)) {
+    hybridView->setPauseRendering(newProps->pauseRendering.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maximumScreenSpaceError.isProvided()
+        : !newProps->maximumScreenSpaceError.hasSameValue(oldProps->maximumScreenSpaceError)) {
+    hybridView->setMaximumScreenSpaceError(newProps->maximumScreenSpaceError.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maximumSimultaneousTileLoads.isProvided()
+        : !newProps->maximumSimultaneousTileLoads.hasSameValue(oldProps->maximumSimultaneousTileLoads)) {
+    hybridView->setMaximumSimultaneousTileLoads(newProps->maximumSimultaneousTileLoads.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->loadingDescendantLimit.isProvided()
+        : !newProps->loadingDescendantLimit.hasSameValue(oldProps->loadingDescendantLimit)) {
+    hybridView->setLoadingDescendantLimit(newProps->loadingDescendantLimit.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->msaaSampleCount.isProvided()
+        : !newProps->msaaSampleCount.hasSameValue(oldProps->msaaSampleCount)) {
+    hybridView->setMsaaSampleCount(newProps->msaaSampleCount.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->ionImageryAssetId.isProvided()
+        : !newProps->ionImageryAssetId.hasSameValue(oldProps->ionImageryAssetId)) {
+    hybridView->setIonImageryAssetId(newProps->ionImageryAssetId.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maximumCachedMiB.isProvided()
+        : !newProps->maximumCachedMiB.hasSameValue(oldProps->maximumCachedMiB)) {
+    hybridView->setMaximumCachedMiB(newProps->maximumCachedMiB.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->preloadAncestors.isProvided()
+        : !newProps->preloadAncestors.hasSameValue(oldProps->preloadAncestors)) {
+    hybridView->setPreloadAncestors(newProps->preloadAncestors.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->preloadSiblings.isProvided()
+        : !newProps->preloadSiblings.hasSameValue(oldProps->preloadSiblings)) {
+    hybridView->setPreloadSiblings(newProps->preloadSiblings.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->forbidHoles.isProvided()
+        : !newProps->forbidHoles.hasSameValue(oldProps->forbidHoles)) {
+    hybridView->setForbidHoles(newProps->forbidHoles.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->enableWaterMask.isProvided()
+        : !newProps->enableWaterMask.hasSameValue(oldProps->enableWaterMask)) {
+    hybridView->setEnableWaterMask(newProps->enableWaterMask.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->enableFogCulling.isProvided()
+        : !newProps->enableFogCulling.hasSameValue(oldProps->enableFogCulling)) {
+    hybridView->setEnableFogCulling(newProps->enableFogCulling.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->enforceCulledScreenSpaceError.isProvided()
+        : !newProps->enforceCulledScreenSpaceError.hasSameValue(oldProps->enforceCulledScreenSpaceError)) {
+    hybridView->setEnforceCulledScreenSpaceError(newProps->enforceCulledScreenSpaceError.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->culledScreenSpaceError.isProvided()
+        : !newProps->culledScreenSpaceError.hasSameValue(oldProps->culledScreenSpaceError)) {
+    hybridView->setCulledScreenSpaceError(newProps->culledScreenSpaceError.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->enableLodTransitionPeriod.isProvided()
+        : !newProps->enableLodTransitionPeriod.hasSameValue(oldProps->enableLodTransitionPeriod)) {
+    hybridView->setEnableLodTransitionPeriod(newProps->enableLodTransitionPeriod.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->lodTransitionLength.isProvided()
+        : !newProps->lodTransitionLength.hasSameValue(oldProps->lodTransitionLength)) {
+    hybridView->setLodTransitionLength(newProps->lodTransitionLength.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sqliteCacheMaxRows.isProvided()
+        : !newProps->sqliteCacheMaxRows.hasSameValue(oldProps->sqliteCacheMaxRows)) {
+    hybridView->setSqliteCacheMaxRows(newProps->sqliteCacheMaxRows.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->taskProcessorThreads.isProvided()
+        : !newProps->taskProcessorThreads.hasSameValue(oldProps->taskProcessorThreads)) {
+    hybridView->setTaskProcessorThreads(newProps->taskProcessorThreads.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->minAltitudeAboveTerrain.isProvided()
+        : !newProps->minAltitudeAboveTerrain.hasSameValue(oldProps->minAltitudeAboveTerrain)) {
+    hybridView->setMinAltitudeAboveTerrain(newProps->minAltitudeAboveTerrain.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxYawRateDegSec.isProvided()
+        : !newProps->maxYawRateDegSec.hasSameValue(oldProps->maxYawRateDegSec)) {
+    hybridView->setMaxYawRateDegSec(newProps->maxYawRateDegSec.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxPitchRateDegSec.isProvided()
+        : !newProps->maxPitchRateDegSec.hasSameValue(oldProps->maxPitchRateDegSec)) {
+    hybridView->setMaxPitchRateDegSec(newProps->maxPitchRateDegSec.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxRollRateDegSec.isProvided()
+        : !newProps->maxRollRateDegSec.hasSameValue(oldProps->maxRollRateDegSec)) {
+    hybridView->setMaxRollRateDegSec(newProps->maxRollRateDegSec.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxClimbRateMps.isProvided()
+        : !newProps->maxClimbRateMps.hasSameValue(oldProps->maxClimbRateMps)) {
+    hybridView->setMaxClimbRateMps(newProps->maxClimbRateMps.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxGroundSpeedMps.isProvided()
+        : !newProps->maxGroundSpeedMps.hasSameValue(oldProps->maxGroundSpeedMps)) {
+    hybridView->setMaxGroundSpeedMps(newProps->maxGroundSpeedMps.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onMetrics.isProvided()
+        : !newProps->onMetrics.hasSameValue(oldProps->onMetrics)) {
+    hybridView->setOnMetrics(newProps->onMetrics.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onActualCamera.isProvided()
+        : !newProps->onActualCamera.hasSameValue(oldProps->onActualCamera)) {
+    hybridView->setOnActualCamera(newProps->onActualCamera.get());
   }
 
   // Update hybridRef if it changed
-  if (props->hybridRef.isDirty) {
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
     // hybridRef changed - call it with new this
-    const auto& maybeFunc = props->hybridRef.value;
+    const auto& maybeFunc = newProps->hybridRef.get();
     if (maybeFunc.has_value()) {
       maybeFunc.value()(hybridView);
     }
-    props->hybridRef.isDirty = false;
   }
 }
 

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

@@ -31,7 +31,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<JHybridCesiumViewSpec::JavaPart> view,
-                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridCesiumViewProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {

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

@@ -55,7 +55,7 @@ data class CameraState(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       latitude,
       longitude,
       altitude,

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

@@ -59,7 +59,7 @@ data class CesiumMetrics(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       fps,
       tilesRendered,
       tilesLoading,

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

@@ -10,7 +10,6 @@ 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
 
 
 /**
@@ -59,7 +58,6 @@ class Func_void_CameraState_cxx: Func_void_CameraState {
   override fun invoke(camera: CameraState): Unit
     = invoke_cxx(camera)
 
-  @FastNative
   private external fun invoke_cxx(camera: CameraState): Unit
 }
 

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

@@ -10,7 +10,6 @@ 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
 
 
 /**
@@ -59,7 +58,6 @@ class Func_void_CesiumMetrics_cxx: Func_void_CesiumMetrics {
   override fun invoke(metrics: CesiumMetrics): Unit
     = invoke_cxx(metrics)
 
-  @FastNative
   private external fun invoke_cxx(metrics: CesiumMetrics): Unit
 }
 

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

@@ -10,6 +10,7 @@ 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
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 import com.margelo.nitro.views.HybridView
@@ -268,6 +269,7 @@ abstract class HybridCesiumViewSpec: HybridView() {
   @Keep
   protected open class CxxPart(javaPart: HybridCesiumViewSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridCesiumViewSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

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

@@ -43,7 +43,7 @@ data class Quaternion(
   }
 
   override fun hashCode(): Int {
-    return arrayOf(
+    return arrayOf<Any?>(
       w,
       x,
       y,

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

@@ -20,6 +20,14 @@ import com.margelo.nitro.reactnativecesium.*
  * Represents the React Native `ViewManager` for the "CesiumView" Nitro HybridView.
  */
 public class HybridCesiumViewManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridCesiumView,
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(HybridCesiumView::class.java)) {
       // Enable view recycling
@@ -34,33 +42,41 @@ public class HybridCesiumViewManager: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = HybridCesiumView(reactContext)
     val view = hybridView.view
-    view.setTag(associated_hybrid_view_tag, hybridView)
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
   override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
-    val hybridView = getHybridView(view)
+    val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
 
     // 1. Update each prop individually
     hybridView.beforeUpdate()
-    HybridCesiumViewStateUpdater.updateViewProps(hybridView, stateWrapper)
+    HybridCesiumViewStateUpdater.updateViewProps(hybridView, newState, oldState)
     hybridView.afterUpdate()
+    holder.lastState = newState
 
     // 2. Continue in base View props
-    return super.updateState(view, props, stateWrapper)
+    return super.updateState(view, props, newState)
   }
 
   override fun onDropViewInstance(view: View) {
-    val hybridView = getHybridView(view)
-    hybridView?.onDropView()
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
   protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
-    super.prepareToRecycleView(reactContext, view)
-    val hybridView = getHybridView(view)
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+      ?: return null
+    val holder = getHybridViewHolder(preparedView)
       ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
 
     @Suppress("USELESS_IS_CHECK")
     if (hybridView is RecyclableView) {
@@ -74,7 +90,7 @@ public class HybridCesiumViewManager: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): HybridCesiumView? {
-    return view.getTag(associated_hybrid_view_tag) as? HybridCesiumView
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

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

@@ -14,10 +14,10 @@ internal class HybridCesiumViewStateUpdater {
   companion object {
     /**
      * Updates the props for [view] through C++.
-     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
      */
     @Suppress("KotlinJniMissingFunction")
     @JvmStatic
-    external fun updateViewProps(view: HybridCesiumViewSpec, state: StateWrapper)
+    external fun updateViewProps(view: HybridCesiumViewSpec, newState: StateWrapper, oldState: StateWrapper?)
   }
 }