@onekeyfe/react-native-segment-slider 3.0.96 → 3.0.99

package/lib/nitrogen/generated/android/c++/views/JHybridSegmentSliderStateUpdater.cpp

@@ -15,121 +15,159 @@ namespace margelo::nitro::segmentslider::views {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<HybridSegmentSliderState>;
 
-void JHybridSegmentSliderStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<JHybridSegmentSliderSpec::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<JHybridSegmentSliderSpec> hybridView = javaView->getJHybridSegmentSliderSpec();
-
+std::shared_ptr<const HybridSegmentSliderProps> JHybridSegmentSliderStateUpdater::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 HybridSegmentSliderState& data = concreteState->getData();
-  const std::shared_ptr<HybridSegmentSliderProps>& props = data.getProps();
+  const std::shared_ptr<const HybridSegmentSliderProps>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("HybridSegmentSliderState's data doesn't contain any props!");
   }
+  return props;
+}
 
-  // Update all props if they are dirty
-  if (props->defaultValue.isDirty) {
-    hybridView->setDefaultValue(props->defaultValue.value);
-    props->defaultValue.isDirty = false;
-  }
-  if (props->min.isDirty) {
-    hybridView->setMin(props->min.value);
-    props->min.isDirty = false;
-  }
-  if (props->max.isDirty) {
-    hybridView->setMax(props->max.value);
-    props->max.isDirty = false;
-  }
-  if (props->segments.isDirty) {
-    hybridView->setSegments(props->segments.value);
-    props->segments.isDirty = false;
-  }
-  if (props->sliderHeight.isDirty) {
-    hybridView->setSliderHeight(props->sliderHeight.value);
-    props->sliderHeight.isDirty = false;
-  }
-  if (props->disabled.isDirty) {
-    hybridView->setDisabled(props->disabled.value);
-    props->disabled.isDirty = false;
-  }
-  if (props->showBubble.isDirty) {
-    hybridView->setShowBubble(props->showBubble.value);
-    props->showBubble.isDirty = false;
-  }
-  if (props->centerOrigin.isDirty) {
-    hybridView->setCenterOrigin(props->centerOrigin.value);
-    props->centerOrigin.isDirty = false;
-  }
-  if (props->snapTapToSegment.isDirty) {
-    hybridView->setSnapTapToSegment(props->snapTapToSegment.value);
-    props->snapTapToSegment.isDirty = false;
-  }
-  if (props->fillColor.isDirty) {
-    hybridView->setFillColor(props->fillColor.value);
-    props->fillColor.isDirty = false;
-  }
-  if (props->trackColor.isDirty) {
-    hybridView->setTrackColor(props->trackColor.value);
-    props->trackColor.isDirty = false;
-  }
-  if (props->thumbColor.isDirty) {
-    hybridView->setThumbColor(props->thumbColor.value);
-    props->thumbColor.isDirty = false;
-  }
-  if (props->thumbBorderColor.isDirty) {
-    hybridView->setThumbBorderColor(props->thumbBorderColor.value);
-    props->thumbBorderColor.isDirty = false;
-  }
-  if (props->markActiveColor.isDirty) {
-    hybridView->setMarkActiveColor(props->markActiveColor.value);
-    props->markActiveColor.isDirty = false;
-  }
-  if (props->markInactiveColor.isDirty) {
-    hybridView->setMarkInactiveColor(props->markInactiveColor.value);
-    props->markInactiveColor.isDirty = false;
-  }
-  if (props->markBorderColor.isDirty) {
-    hybridView->setMarkBorderColor(props->markBorderColor.value);
-    props->markBorderColor.isDirty = false;
-  }
-  if (props->bubbleColor.isDirty) {
-    hybridView->setBubbleColor(props->bubbleColor.value);
-    props->bubbleColor.isDirty = false;
-  }
-  if (props->bubbleTextColor.isDirty) {
-    hybridView->setBubbleTextColor(props->bubbleTextColor.value);
-    props->bubbleTextColor.isDirty = false;
-  }
-  if (props->onChange.isDirty) {
-    hybridView->setOnChange(props->onChange.value);
-    props->onChange.isDirty = false;
-  }
-  if (props->onSlideStart.isDirty) {
-    hybridView->setOnSlideStart(props->onSlideStart.value);
-    props->onSlideStart.isDirty = false;
+void JHybridSegmentSliderStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridSegmentSliderSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridSegmentSliderSpec> hybridView = javaView->getJHybridSegmentSliderSpec();
+  std::shared_ptr<const HybridSegmentSliderProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridSegmentSliderProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
   }
-  if (props->onSlideComplete.isDirty) {
-    hybridView->setOnSlideComplete(props->onSlideComplete.value);
-    props->onSlideComplete.isDirty = false;
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->defaultValue.isProvided()
+        : !newProps->defaultValue.hasSameValue(oldProps->defaultValue)) {
+    hybridView->setDefaultValue(newProps->defaultValue.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->min.isProvided()
+        : !newProps->min.hasSameValue(oldProps->min)) {
+    hybridView->setMin(newProps->min.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->max.isProvided()
+        : !newProps->max.hasSameValue(oldProps->max)) {
+    hybridView->setMax(newProps->max.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->segments.isProvided()
+        : !newProps->segments.hasSameValue(oldProps->segments)) {
+    hybridView->setSegments(newProps->segments.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sliderHeight.isProvided()
+        : !newProps->sliderHeight.hasSameValue(oldProps->sliderHeight)) {
+    hybridView->setSliderHeight(newProps->sliderHeight.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->disabled.isProvided()
+        : !newProps->disabled.hasSameValue(oldProps->disabled)) {
+    hybridView->setDisabled(newProps->disabled.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->showBubble.isProvided()
+        : !newProps->showBubble.hasSameValue(oldProps->showBubble)) {
+    hybridView->setShowBubble(newProps->showBubble.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->centerOrigin.isProvided()
+        : !newProps->centerOrigin.hasSameValue(oldProps->centerOrigin)) {
+    hybridView->setCenterOrigin(newProps->centerOrigin.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->snapTapToSegment.isProvided()
+        : !newProps->snapTapToSegment.hasSameValue(oldProps->snapTapToSegment)) {
+    hybridView->setSnapTapToSegment(newProps->snapTapToSegment.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->fillColor.isProvided()
+        : !newProps->fillColor.hasSameValue(oldProps->fillColor)) {
+    hybridView->setFillColor(newProps->fillColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->trackColor.isProvided()
+        : !newProps->trackColor.hasSameValue(oldProps->trackColor)) {
+    hybridView->setTrackColor(newProps->trackColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->thumbColor.isProvided()
+        : !newProps->thumbColor.hasSameValue(oldProps->thumbColor)) {
+    hybridView->setThumbColor(newProps->thumbColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->thumbBorderColor.isProvided()
+        : !newProps->thumbBorderColor.hasSameValue(oldProps->thumbBorderColor)) {
+    hybridView->setThumbBorderColor(newProps->thumbBorderColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markActiveColor.isProvided()
+        : !newProps->markActiveColor.hasSameValue(oldProps->markActiveColor)) {
+    hybridView->setMarkActiveColor(newProps->markActiveColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markInactiveColor.isProvided()
+        : !newProps->markInactiveColor.hasSameValue(oldProps->markInactiveColor)) {
+    hybridView->setMarkInactiveColor(newProps->markInactiveColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markBorderColor.isProvided()
+        : !newProps->markBorderColor.hasSameValue(oldProps->markBorderColor)) {
+    hybridView->setMarkBorderColor(newProps->markBorderColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->bubbleColor.isProvided()
+        : !newProps->bubbleColor.hasSameValue(oldProps->bubbleColor)) {
+    hybridView->setBubbleColor(newProps->bubbleColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->bubbleTextColor.isProvided()
+        : !newProps->bubbleTextColor.hasSameValue(oldProps->bubbleTextColor)) {
+    hybridView->setBubbleTextColor(newProps->bubbleTextColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onChange.isProvided()
+        : !newProps->onChange.hasSameValue(oldProps->onChange)) {
+    hybridView->setOnChange(newProps->onChange.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onSlideStart.isProvided()
+        : !newProps->onSlideStart.hasSameValue(oldProps->onSlideStart)) {
+    hybridView->setOnSlideStart(newProps->onSlideStart.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onSlideComplete.isProvided()
+        : !newProps->onSlideComplete.hasSameValue(oldProps->onSlideComplete)) {
+    hybridView->setOnSlideComplete(newProps->onSlideComplete.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/lib/nitrogen/generated/android/c++/views/JHybridSegmentSliderStateUpdater.hpp

@@ -31,7 +31,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<JHybridSegmentSliderSpec::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 HybridSegmentSliderProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/segmentslider/views/HybridSegmentSliderManager.kt

@@ -20,6 +20,14 @@ import com.margelo.nitro.segmentslider.*
  * Represents the React Native `ViewManager` for the "SegmentSlider" Nitro HybridView.
  */
 public class HybridSegmentSliderManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridSegmentSlider,
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(HybridSegmentSlider::class.java)) {
       // Enable view recycling
@@ -34,33 +42,41 @@ public class HybridSegmentSliderManager: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = HybridSegmentSlider(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()
-    HybridSegmentSliderStateUpdater.updateViewProps(hybridView, stateWrapper)
+    HybridSegmentSliderStateUpdater.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 HybridSegmentSliderManager: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): HybridSegmentSlider? {
-    return view.getTag(associated_hybrid_view_tag) as? HybridSegmentSlider
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/segmentslider/views/HybridSegmentSliderStateUpdater.kt

@@ -14,10 +14,10 @@ internal class HybridSegmentSliderStateUpdater {
   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: HybridSegmentSliderSpec, state: StateWrapper)
+    external fun updateViewProps(view: HybridSegmentSliderSpec, newState: StateWrapper, oldState: StateWrapper?)
   }
 }