@onekeyfe/react-native-auto-size-input 3.0.96 → 3.0.98

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

@@ -15,161 +15,209 @@ namespace margelo::nitro::autosizeinput::views {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<HybridAutoSizeInputState>;
 
-void JHybridAutoSizeInputStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<JHybridAutoSizeInputSpec::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<JHybridAutoSizeInputSpec> hybridView = javaView->getJHybridAutoSizeInputSpec();
-
+std::shared_ptr<const HybridAutoSizeInputProps> JHybridAutoSizeInputStateUpdater::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 HybridAutoSizeInputState& data = concreteState->getData();
-  const std::shared_ptr<HybridAutoSizeInputProps>& props = data.getProps();
+  const std::shared_ptr<const HybridAutoSizeInputProps>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("HybridAutoSizeInputState's data doesn't contain any props!");
   }
+  return props;
+}
 
-  // Update all props if they are dirty
-  if (props->mostRecentEventCount.isDirty) {
-    hybridView->setMostRecentEventCount(props->mostRecentEventCount.value);
-    props->mostRecentEventCount.isDirty = false;
-  }
-  if (props->text.isDirty) {
-    hybridView->setText(props->text.value);
-    props->text.isDirty = false;
-  }
-  if (props->prefix.isDirty) {
-    hybridView->setPrefix(props->prefix.value);
-    props->prefix.isDirty = false;
-  }
-  if (props->suffix.isDirty) {
-    hybridView->setSuffix(props->suffix.value);
-    props->suffix.isDirty = false;
-  }
-  if (props->placeholder.isDirty) {
-    hybridView->setPlaceholder(props->placeholder.value);
-    props->placeholder.isDirty = false;
-  }
-  if (props->fontSize.isDirty) {
-    hybridView->setFontSize(props->fontSize.value);
-    props->fontSize.isDirty = false;
-  }
-  if (props->minFontSize.isDirty) {
-    hybridView->setMinFontSize(props->minFontSize.value);
-    props->minFontSize.isDirty = false;
-  }
-  if (props->multiline.isDirty) {
-    hybridView->setMultiline(props->multiline.value);
-    props->multiline.isDirty = false;
-  }
-  if (props->maxNumberOfLines.isDirty) {
-    hybridView->setMaxNumberOfLines(props->maxNumberOfLines.value);
-    props->maxNumberOfLines.isDirty = false;
-  }
-  if (props->textColor.isDirty) {
-    hybridView->setTextColor(props->textColor.value);
-    props->textColor.isDirty = false;
-  }
-  if (props->prefixColor.isDirty) {
-    hybridView->setPrefixColor(props->prefixColor.value);
-    props->prefixColor.isDirty = false;
-  }
-  if (props->suffixColor.isDirty) {
-    hybridView->setSuffixColor(props->suffixColor.value);
-    props->suffixColor.isDirty = false;
-  }
-  if (props->placeholderColor.isDirty) {
-    hybridView->setPlaceholderColor(props->placeholderColor.value);
-    props->placeholderColor.isDirty = false;
-  }
-  if (props->textAlign.isDirty) {
-    hybridView->setTextAlign(props->textAlign.value);
-    props->textAlign.isDirty = false;
-  }
-  if (props->fontFamily.isDirty) {
-    hybridView->setFontFamily(props->fontFamily.value);
-    props->fontFamily.isDirty = false;
-  }
-  if (props->fontWeight.isDirty) {
-    hybridView->setFontWeight(props->fontWeight.value);
-    props->fontWeight.isDirty = false;
-  }
-  if (props->editable.isDirty) {
-    hybridView->setEditable(props->editable.value);
-    props->editable.isDirty = false;
-  }
-  if (props->keyboardType.isDirty) {
-    hybridView->setKeyboardType(props->keyboardType.value);
-    props->keyboardType.isDirty = false;
-  }
-  if (props->returnKeyType.isDirty) {
-    hybridView->setReturnKeyType(props->returnKeyType.value);
-    props->returnKeyType.isDirty = false;
-  }
-  if (props->autoCorrect.isDirty) {
-    hybridView->setAutoCorrect(props->autoCorrect.value);
-    props->autoCorrect.isDirty = false;
-  }
-  if (props->autoCapitalize.isDirty) {
-    hybridView->setAutoCapitalize(props->autoCapitalize.value);
-    props->autoCapitalize.isDirty = false;
-  }
-  if (props->selectionColor.isDirty) {
-    hybridView->setSelectionColor(props->selectionColor.value);
-    props->selectionColor.isDirty = false;
-  }
-  if (props->prefixMarginRight.isDirty) {
-    hybridView->setPrefixMarginRight(props->prefixMarginRight.value);
-    props->prefixMarginRight.isDirty = false;
-  }
-  if (props->suffixMarginLeft.isDirty) {
-    hybridView->setSuffixMarginLeft(props->suffixMarginLeft.value);
-    props->suffixMarginLeft.isDirty = false;
-  }
-  if (props->showBorder.isDirty) {
-    hybridView->setShowBorder(props->showBorder.value);
-    props->showBorder.isDirty = false;
-  }
-  if (props->inputBackgroundColor.isDirty) {
-    hybridView->setInputBackgroundColor(props->inputBackgroundColor.value);
-    props->inputBackgroundColor.isDirty = false;
-  }
-  if (props->contentAutoWidth.isDirty) {
-    hybridView->setContentAutoWidth(props->contentAutoWidth.value);
-    props->contentAutoWidth.isDirty = false;
-  }
-  if (props->contentCentered.isDirty) {
-    hybridView->setContentCentered(props->contentCentered.value);
-    props->contentCentered.isDirty = false;
-  }
-  if (props->onChangeText.isDirty) {
-    hybridView->setOnChangeText(props->onChangeText.value);
-    props->onChangeText.isDirty = false;
-  }
-  if (props->onFocus.isDirty) {
-    hybridView->setOnFocus(props->onFocus.value);
-    props->onFocus.isDirty = false;
+void JHybridAutoSizeInputStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAutoSizeInputSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridAutoSizeInputSpec> hybridView = javaView->getJHybridAutoSizeInputSpec();
+  std::shared_ptr<const HybridAutoSizeInputProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridAutoSizeInputProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
   }
-  if (props->onBlur.isDirty) {
-    hybridView->setOnBlur(props->onBlur.value);
-    props->onBlur.isDirty = false;
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->mostRecentEventCount.isProvided()
+        : !newProps->mostRecentEventCount.hasSameValue(oldProps->mostRecentEventCount)) {
+    hybridView->setMostRecentEventCount(newProps->mostRecentEventCount.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->text.isProvided()
+        : !newProps->text.hasSameValue(oldProps->text)) {
+    hybridView->setText(newProps->text.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->prefix.isProvided()
+        : !newProps->prefix.hasSameValue(oldProps->prefix)) {
+    hybridView->setPrefix(newProps->prefix.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->suffix.isProvided()
+        : !newProps->suffix.hasSameValue(oldProps->suffix)) {
+    hybridView->setSuffix(newProps->suffix.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->placeholder.isProvided()
+        : !newProps->placeholder.hasSameValue(oldProps->placeholder)) {
+    hybridView->setPlaceholder(newProps->placeholder.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->fontSize.isProvided()
+        : !newProps->fontSize.hasSameValue(oldProps->fontSize)) {
+    hybridView->setFontSize(newProps->fontSize.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->minFontSize.isProvided()
+        : !newProps->minFontSize.hasSameValue(oldProps->minFontSize)) {
+    hybridView->setMinFontSize(newProps->minFontSize.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->multiline.isProvided()
+        : !newProps->multiline.hasSameValue(oldProps->multiline)) {
+    hybridView->setMultiline(newProps->multiline.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->maxNumberOfLines.isProvided()
+        : !newProps->maxNumberOfLines.hasSameValue(oldProps->maxNumberOfLines)) {
+    hybridView->setMaxNumberOfLines(newProps->maxNumberOfLines.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->textColor.isProvided()
+        : !newProps->textColor.hasSameValue(oldProps->textColor)) {
+    hybridView->setTextColor(newProps->textColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->prefixColor.isProvided()
+        : !newProps->prefixColor.hasSameValue(oldProps->prefixColor)) {
+    hybridView->setPrefixColor(newProps->prefixColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->suffixColor.isProvided()
+        : !newProps->suffixColor.hasSameValue(oldProps->suffixColor)) {
+    hybridView->setSuffixColor(newProps->suffixColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->placeholderColor.isProvided()
+        : !newProps->placeholderColor.hasSameValue(oldProps->placeholderColor)) {
+    hybridView->setPlaceholderColor(newProps->placeholderColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->textAlign.isProvided()
+        : !newProps->textAlign.hasSameValue(oldProps->textAlign)) {
+    hybridView->setTextAlign(newProps->textAlign.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->fontFamily.isProvided()
+        : !newProps->fontFamily.hasSameValue(oldProps->fontFamily)) {
+    hybridView->setFontFamily(newProps->fontFamily.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->fontWeight.isProvided()
+        : !newProps->fontWeight.hasSameValue(oldProps->fontWeight)) {
+    hybridView->setFontWeight(newProps->fontWeight.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->editable.isProvided()
+        : !newProps->editable.hasSameValue(oldProps->editable)) {
+    hybridView->setEditable(newProps->editable.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->keyboardType.isProvided()
+        : !newProps->keyboardType.hasSameValue(oldProps->keyboardType)) {
+    hybridView->setKeyboardType(newProps->keyboardType.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->returnKeyType.isProvided()
+        : !newProps->returnKeyType.hasSameValue(oldProps->returnKeyType)) {
+    hybridView->setReturnKeyType(newProps->returnKeyType.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->autoCorrect.isProvided()
+        : !newProps->autoCorrect.hasSameValue(oldProps->autoCorrect)) {
+    hybridView->setAutoCorrect(newProps->autoCorrect.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->autoCapitalize.isProvided()
+        : !newProps->autoCapitalize.hasSameValue(oldProps->autoCapitalize)) {
+    hybridView->setAutoCapitalize(newProps->autoCapitalize.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->selectionColor.isProvided()
+        : !newProps->selectionColor.hasSameValue(oldProps->selectionColor)) {
+    hybridView->setSelectionColor(newProps->selectionColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->prefixMarginRight.isProvided()
+        : !newProps->prefixMarginRight.hasSameValue(oldProps->prefixMarginRight)) {
+    hybridView->setPrefixMarginRight(newProps->prefixMarginRight.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->suffixMarginLeft.isProvided()
+        : !newProps->suffixMarginLeft.hasSameValue(oldProps->suffixMarginLeft)) {
+    hybridView->setSuffixMarginLeft(newProps->suffixMarginLeft.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->showBorder.isProvided()
+        : !newProps->showBorder.hasSameValue(oldProps->showBorder)) {
+    hybridView->setShowBorder(newProps->showBorder.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->inputBackgroundColor.isProvided()
+        : !newProps->inputBackgroundColor.hasSameValue(oldProps->inputBackgroundColor)) {
+    hybridView->setInputBackgroundColor(newProps->inputBackgroundColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->contentAutoWidth.isProvided()
+        : !newProps->contentAutoWidth.hasSameValue(oldProps->contentAutoWidth)) {
+    hybridView->setContentAutoWidth(newProps->contentAutoWidth.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->contentCentered.isProvided()
+        : !newProps->contentCentered.hasSameValue(oldProps->contentCentered)) {
+    hybridView->setContentCentered(newProps->contentCentered.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onChangeText.isProvided()
+        : !newProps->onChangeText.hasSameValue(oldProps->onChangeText)) {
+    hybridView->setOnChangeText(newProps->onChangeText.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onFocus.isProvided()
+        : !newProps->onFocus.hasSameValue(oldProps->onFocus)) {
+    hybridView->setOnFocus(newProps->onFocus.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onBlur.isProvided()
+        : !newProps->onBlur.hasSameValue(oldProps->onBlur)) {
+    hybridView->setOnBlur(newProps->onBlur.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/JHybridAutoSizeInputStateUpdater.hpp

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

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/autosizeinput/views/HybridAutoSizeInputManager.kt

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

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/autosizeinput/views/HybridAutoSizeInputStateUpdater.kt

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