react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactCommon/react/renderer/components/scrollview/CMakeLists.txt

@@ -14,10 +14,10 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB rrc_scrollview_SRC CONFIGURE_DEPENDS *.cpp)
+file(GLOB rrc_scrollview_SRC CONFIGURE_DEPENDS *.cpp platform/android/react/renderer/components/scrollview/*.cpp)
 add_library(rrc_scrollview STATIC ${rrc_scrollview_SRC})
 
-target_include_directories(rrc_scrollview PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(rrc_scrollview PUBLIC ${REACT_COMMON_DIR} . ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/)
 
 target_link_libraries(rrc_scrollview
         glog

package/ReactCommon/react/renderer/components/scrollview/ScrollEvent.cpp

@@ -76,6 +76,39 @@ EventPayloadType ScrollEvent::getType() const {
   return EventPayloadType::ScrollEvent;
 }
 
+jsi::Value ScrollEndDragEvent::asJSIValue(jsi::Runtime& runtime) const {
+  auto payload = ScrollEvent::asJSIValue(runtime).asObject(runtime);
+
+  {
+    auto targetContentOffsetObj = jsi::Object(runtime);
+    targetContentOffsetObj.setProperty(runtime, "x", targetContentOffset.x);
+    targetContentOffsetObj.setProperty(runtime, "y", targetContentOffset.y);
+    payload.setProperty(runtime, "targetContentOffset", targetContentOffsetObj);
+  }
+
+  {
+    auto velocityObj = jsi::Object(runtime);
+    velocityObj.setProperty(runtime, "x", velocity.x);
+    velocityObj.setProperty(runtime, "y", velocity.y);
+    payload.setProperty(runtime, "velocity", velocityObj);
+  }
+
+  return payload;
+}
+
+folly::dynamic ScrollEndDragEvent::asDynamic() const {
+  auto metrics = ScrollEvent::asDynamic();
+
+  auto targetContentOffsetObj = folly::dynamic::object(
+      "x", targetContentOffset.x)("y", targetContentOffset.y);
+  metrics["targetContentOffset"] = std::move(targetContentOffsetObj);
+
+  auto velocityObj = folly::dynamic::object("x", velocity.x)("y", velocity.y);
+  metrics["velocity"] = std::move(velocityObj);
+
+  return metrics;
+};
+
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const ScrollEvent& /*scrollEvent*/) {

package/ReactCommon/react/renderer/components/scrollview/ScrollEvent.h

@@ -37,6 +37,23 @@ struct ScrollEvent : public EventPayload {
   EventPayloadType getType() const override;
 };
 
+struct ScrollEndDragEvent : public ScrollEvent {
+  Point targetContentOffset;
+  Point velocity;
+
+  ScrollEndDragEvent() = default;
+
+  ScrollEndDragEvent(const ScrollEvent& scrollEvent)
+      : ScrollEvent(scrollEvent), targetContentOffset({}), velocity({}) {}
+
+  folly::dynamic asDynamic() const;
+
+  /*
+   * EventPayload implementations
+   */
+  jsi::Value asJSIValue(jsi::Runtime& runtime) const override;
+};
+
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const ScrollEvent& scrollEvent);

package/ReactCommon/react/renderer/components/scrollview/ScrollViewEventEmitter.cpp

@@ -25,8 +25,9 @@ void ScrollViewEventEmitter::onScrollBeginDrag(
 }
 
 void ScrollViewEventEmitter::onScrollEndDrag(
-    const ScrollEvent& scrollEvent) const {
-  dispatchScrollViewEvent("scrollEndDrag", scrollEvent);
+    const ScrollEndDragEvent& scrollEvent) const {
+  dispatchEvent(
+      "scrollEndDrag", std::make_shared<ScrollEndDragEvent>(scrollEvent));
 }
 
 void ScrollViewEventEmitter::onMomentumScrollBegin(

package/ReactCommon/react/renderer/components/scrollview/ScrollViewEventEmitter.h

@@ -21,10 +21,11 @@ class ScrollViewEventEmitter : public ViewEventEmitter {
   using ViewEventEmitter::ViewEventEmitter;
 
   using Metrics = ScrollEvent;
+  using EndDragMetrics = ScrollEndDragEvent;
 
   void onScroll(const ScrollEvent& scrollEvent) const;
   void onScrollBeginDrag(const ScrollEvent& scrollEvent) const;
-  void onScrollEndDrag(const ScrollEvent& scrollEvent) const;
+  void onScrollEndDrag(const ScrollEndDragEvent& scrollEvent) const;
   void onMomentumScrollBegin(const ScrollEvent& scrollEvent) const;
   void onMomentumScrollEnd(const ScrollEvent& scrollEvent) const;
   void onScrollToTop(const ScrollEvent& scrollEvent) const;

package/ReactCommon/react/renderer/components/switch/androidswitch/react/renderer/components/androidswitch/AndroidSwitchComponentDescriptor.h

@@ -36,10 +36,6 @@ class AndroidSwitchComponentDescriptor final
     // provide measurements to Yoga.
     androidSwitchShadowNode.setAndroidSwitchMeasurementsManager(
         measurementsManager_);
-
-    // All `AndroidSwitchShadowNode`s must have leaf Yoga nodes with properly
-    // setup measure function.
-    androidSwitchShadowNode.enableMeasurement();
   }
 
  private:

package/ReactCommon/react/renderer/components/switch/androidswitch/react/renderer/components/androidswitch/AndroidSwitchShadowNode.h

@@ -27,6 +27,13 @@ class AndroidSwitchShadowNode final : public ConcreteViewShadowNode<
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
   // Associates a shared `AndroidSwitchMeasurementsManager` with the node.
   void setAndroidSwitchMeasurementsManager(
       const std::shared_ptr<AndroidSwitchMeasurementsManager>&

package/ReactCommon/react/renderer/{uimanager/bindingUtils.h → components/text/ParagraphComponentDescriptor.cpp}

@@ -5,16 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
-
-#include <jsi/jsi.h>
+#include "ParagraphComponentDescriptor.h"
 
 namespace facebook::react {
 
-jsi::Value callMethodOfModule(
-    jsi::Runtime& runtime,
-    const std::string& moduleName,
-    const std::string& methodName,
-    std::initializer_list<jsi::Value> args);
+extern const char TextLayoutManagerKey[] = "TextLayoutManager";
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/text/ParagraphComponentDescriptor.h

@@ -14,18 +14,20 @@
 
 namespace facebook::react {
 
+extern const char TextLayoutManagerKey[];
+
 /*
  * Descriptor for <Paragraph> component.
  */
 class ParagraphComponentDescriptor final
     : public ConcreteComponentDescriptor<ParagraphShadowNode> {
  public:
-  ParagraphComponentDescriptor(const ComponentDescriptorParameters& parameters)
-      : ConcreteComponentDescriptor<ParagraphShadowNode>(parameters) {
-    // Every single `ParagraphShadowNode` will have a reference to
-    // a shared `TextLayoutManager`.
-    textLayoutManager_ = std::make_shared<TextLayoutManager>(contextContainer_);
-  }
+  explicit ParagraphComponentDescriptor(
+      const ComponentDescriptorParameters& parameters)
+      : ConcreteComponentDescriptor<ParagraphShadowNode>(parameters),
+        textLayoutManager_(getManagerByName<TextLayoutManager>(
+            contextContainer_,
+            TextLayoutManagerKey)) {}
 
  protected:
   void adopt(ShadowNode& shadowNode) const override {
@@ -39,7 +41,8 @@ class ParagraphComponentDescriptor final
   }
 
  private:
-  std::shared_ptr<const TextLayoutManager> textLayoutManager_;
+  // Every `ParagraphShadowNode` has a reference to a shared `TextLayoutManager`
+  const std::shared_ptr<const TextLayoutManager> textLayoutManager_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/BaseTextInputProps.cpp

@@ -126,6 +126,12 @@ BaseTextInputProps::BaseTextInputProps(
           rawProps,
           "multiline",
           sourceProps.multiline,
+          {false})),
+      disableKeyboardShortcuts(convertRawProp(
+          context,
+          rawProps,
+          "disableKeyboardShortcuts",
+          sourceProps.disableKeyboardShortcuts,
           {false})) {}
 
 void BaseTextInputProps::setProp(
@@ -208,9 +214,26 @@ void BaseTextInputProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(readOnly);
     RAW_SET_PROP_SWITCH_CASE_BASIC(submitBehavior);
     RAW_SET_PROP_SWITCH_CASE_BASIC(multiline);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(disableKeyboardShortcuts);
   }
 }
 
+TextAttributes BaseTextInputProps::getEffectiveTextAttributes(
+    Float fontSizeMultiplier) const {
+  auto result = TextAttributes::defaultTextAttributes();
+  result.fontSizeMultiplier = fontSizeMultiplier;
+  result.apply(textAttributes);
+
+  /*
+   * These props are applied to `View`, therefore they must not be a part of
+   * base text attributes.
+   */
+  result.backgroundColor = clearColor();
+  result.opacity = 1;
+
+  return result;
+}
+
 SubmitBehavior BaseTextInputProps::getNonDefaultSubmitBehavior() const {
   if (submitBehavior == SubmitBehavior::Default) {
     return multiline ? SubmitBehavior::Newline : SubmitBehavior::BlurAndSubmit;

package/ReactCommon/react/renderer/components/textinput/BaseTextInputProps.h

@@ -31,6 +31,13 @@ class BaseTextInputProps : public ViewProps, public BaseTextProps {
       const char* propName,
       const RawValue& value);
 
+  SubmitBehavior getNonDefaultSubmitBehavior() const;
+
+  /*
+   * Accessors
+   */
+  TextAttributes getEffectiveTextAttributes(Float fontSizeMultiplier) const;
+
 #pragma mark - Props
 
   /*
@@ -72,7 +79,7 @@ class BaseTextInputProps : public ViewProps, public BaseTextProps {
 
   bool multiline{false};
 
-  SubmitBehavior getNonDefaultSubmitBehavior() const;
+  bool disableKeyboardShortcuts{false};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/BaseTextInputShadowNode.h

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/components/text/BaseTextShadowNode.h>
+#include <react/renderer/components/textinput/BaseTextInputProps.h>
+#include <react/renderer/components/textinput/TextInputState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/YogaLayoutableShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextLayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+/*
+ * Base `ShadowNode` for <TextInput> component.
+ */
+template <
+    const char* concreteComponentName,
+    typename ViewPropsT,
+    typename ViewEventEmitterT,
+    typename StateDataT,
+    bool usesMapBufferForStateData = false>
+class BaseTextInputShadowNode : public ConcreteViewShadowNode<
+                                    concreteComponentName,
+                                    ViewPropsT,
+                                    ViewEventEmitterT,
+                                    StateDataT,
+                                    usesMapBufferForStateData>,
+                                public BaseTextShadowNode {
+ public:
+  using BaseShadowNode = ConcreteViewShadowNode<
+      concreteComponentName,
+      ViewPropsT,
+      ViewEventEmitterT,
+      StateDataT,
+      usesMapBufferForStateData>;
+
+  using BaseShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = BaseShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    traits.set(ShadowNodeTraits::Trait::BaselineYogaNode);
+    return traits;
+  }
+
+  /*
+   * Associates a shared `TextLayoutManager` with the node.
+   * `TextInputShadowNode` uses the manager to measure text content
+   * and construct `TextInputState` objects.
+   */
+  void setTextLayoutManager(
+      std::shared_ptr<const TextLayoutManager> textLayoutManager) {
+    Sealable::ensureUnsealed();
+    textLayoutManager_ = std::move(textLayoutManager);
+  }
+
+ protected:
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    auto textConstraints = getTextConstraints(layoutConstraints);
+
+    TextLayoutContext textLayoutContext{
+        .pointScaleFactor = layoutContext.pointScaleFactor};
+    auto textSize = textLayoutManager_
+                        ->measure(
+                            attributedStringBoxToMeasure(layoutContext),
+                            props.paragraphAttributes,
+                            textLayoutContext,
+                            textConstraints)
+                        .size;
+
+    return layoutConstraints.clamp(textSize);
+  }
+
+  void layout(LayoutContext layoutContext) override {
+    updateStateIfNeeded(layoutContext);
+    BaseShadowNode::layout(layoutContext);
+  }
+
+  Float baseline(const LayoutContext& layoutContext, Size size) const override {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    auto attributedString = getAttributedString(layoutContext);
+
+    if (attributedString.isEmpty()) {
+      attributedString = getPlaceholderAttributedString(layoutContext);
+    }
+
+    // Yoga expects a baseline relative to the Node's border-box edge instead of
+    // the content, so we need to adjust by the padding and border widths, which
+    // have already been set by the time of baseline alignment
+    auto top = YGNodeLayoutGetBorder(
+                   &(YogaLayoutableShadowNode::yogaNode_), YGEdgeTop) +
+        YGNodeLayoutGetPadding(
+                   &(YogaLayoutableShadowNode::yogaNode_), YGEdgeTop);
+
+    AttributedStringBox attributedStringBox{attributedString};
+    return textLayoutManager_->baseline(
+               attributedStringBox, props.paragraphAttributes, size) +
+        top;
+  }
+
+  /*
+   * Determines the constraints to use while measure the underlying text
+   */
+  LayoutConstraints getTextConstraints(
+      const LayoutConstraints& layoutConstraints) const {
+    if (BaseShadowNode::getConcreteProps().multiline) {
+      return layoutConstraints;
+    } else {
+      // A single line TextInput acts as a horizontal scroller of infinitely
+      // expandable text, so we want to measure the text as if it is allowed to
+      // infinitely expand horizontally, and later clamp to the constraints of
+      // the input.
+      return LayoutConstraints{
+          .minimumSize = layoutConstraints.minimumSize,
+          .maximumSize =
+              Size{
+                  .width = std::numeric_limits<Float>::infinity(),
+                  .height = layoutConstraints.maximumSize.height,
+              },
+          .layoutDirection = layoutConstraints.layoutDirection,
+      };
+    }
+  }
+
+  std::shared_ptr<const TextLayoutManager> textLayoutManager_;
+
+ private:
+  /*
+   * Creates a `State` object if needed.
+   */
+  void updateStateIfNeeded(const LayoutContext& layoutContext) {
+    Sealable::ensureUnsealed();
+    const auto& stateData = BaseShadowNode::getStateData();
+    const auto& reactTreeAttributedString = getAttributedString(layoutContext);
+
+    react_native_assert(textLayoutManager_);
+    if (stateData.reactTreeAttributedString.isContentEqual(
+            reactTreeAttributedString)) {
+      return;
+    }
+
+    const auto& props = BaseShadowNode::getConcreteProps();
+    TextInputState newState(
+        AttributedStringBox{reactTreeAttributedString},
+        reactTreeAttributedString,
+        props.paragraphAttributes,
+        props.mostRecentEventCount);
+    BaseShadowNode::setStateData(std::move(newState));
+  }
+
+  /*
+   * Returns a `AttributedString` which represents text content of the node.
+   */
+  AttributedString getAttributedString(
+      const LayoutContext& layoutContext) const {
+    const auto& props = BaseShadowNode::getConcreteProps();
+    const auto textAttributes =
+        props.getEffectiveTextAttributes(layoutContext.fontSizeMultiplier);
+
+    AttributedString attributedString;
+    attributedString.appendFragment(AttributedString::Fragment{
+        .string = props.text,
+        .textAttributes = textAttributes,
+        .parentShadowView = ShadowView(*this)});
+
+    auto attachments = BaseTextShadowNode::Attachments{};
+    BaseTextShadowNode::buildAttributedString(
+        textAttributes, *this, attributedString, attachments);
+    attributedString.setBaseTextAttributes(textAttributes);
+    return attributedString;
+  }
+
+  /*
+   * Returns an `AttributedStringBox` which represents text content that should
+   * be used for measuring purposes. It might contain actual text value,
+   * placeholder value or some character that represents the size of the font.
+   */
+  AttributedStringBox attributedStringBoxToMeasure(
+      const LayoutContext& layoutContext) const {
+    bool meaningfulState = BaseShadowNode::getState() &&
+        BaseShadowNode::getState()->getRevision() !=
+            State::initialRevisionValue;
+    if (meaningfulState) {
+      const auto& stateData = BaseShadowNode::getStateData();
+      auto attributedStringBox = stateData.attributedStringBox;
+      if (attributedStringBox.getMode() ==
+              AttributedStringBox::Mode::OpaquePointer ||
+          !attributedStringBox.getValue().isEmpty()) {
+        return stateData.attributedStringBox;
+      }
+    }
+
+    auto attributedString = meaningfulState
+        ? AttributedString{}
+        : getAttributedString(layoutContext);
+
+    if (attributedString.isEmpty()) {
+      attributedString = getPlaceholderAttributedString(layoutContext);
+    }
+    return AttributedStringBox{attributedString};
+  }
+
+  // For measurement purposes, we want to make sure that there's at least a
+  // single character in the string so that the measured height is greater
+  // than zero. Otherwise, empty TextInputs with no placeholder don't
+  // display at all.
+  // TODO T67606511: We will redefine the measurement of empty strings as part
+  // of T67606511
+  AttributedString getPlaceholderAttributedString(
+      const LayoutContext& layoutContext) const {
+    const auto& props = BaseShadowNode::getConcreteProps();
+
+    AttributedString attributedString;
+    auto placeholderString = !props.placeholder.empty()
+        ? props.placeholder
+        : BaseTextShadowNode::getEmptyPlaceholder();
+    auto textAttributes =
+        props.getEffectiveTextAttributes(layoutContext.fontSizeMultiplier);
+    attributedString.appendFragment(
+        {.string = std::move(placeholderString),
+         .textAttributes = textAttributes,
+         .parentShadowView = {}});
+    return attributedString;
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/TextInputState.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "TextInputState.h"
+
+#ifdef ANDROID
+#include <react/renderer/attributedstring/conversions.h>
+#include <react/renderer/components/text/ParagraphState.h>
+#endif
+
+namespace facebook::react {
+
+TextInputState::TextInputState(
+    AttributedStringBox attributedStringBox,
+    AttributedString reactTreeAttributedString,
+    ParagraphAttributes paragraphAttributes,
+    int64_t mostRecentEventCount)
+    : attributedStringBox(std::move(attributedStringBox)),
+      reactTreeAttributedString(std::move(reactTreeAttributedString)),
+      paragraphAttributes(std::move(paragraphAttributes)),
+      mostRecentEventCount(mostRecentEventCount) {}
+
+#ifdef ANDROID
+TextInputState::TextInputState(
+    const TextInputState& previousState,
+    const folly::dynamic& data)
+    : attributedStringBox(previousState.attributedStringBox),
+      reactTreeAttributedString(previousState.reactTreeAttributedString),
+      paragraphAttributes(previousState.paragraphAttributes),
+      mostRecentEventCount(data.getDefault(
+                                   "mostRecentEventCount",
+                                   previousState.mostRecentEventCount)
+                               .getInt()),
+      cachedAttributedStringId(data.getDefault(
+                                       "opaqueCacheId",
+                                       previousState.cachedAttributedStringId)
+                                   .getInt()){};
+
+folly::dynamic TextInputState::getDynamic() const {
+  LOG(FATAL) << "TextInputState state should only be read using MapBuffer";
+}
+
+MapBuffer TextInputState::getMapBuffer() const {
+  auto builder = MapBufferBuilder();
+  // If we have a `cachedAttributedStringId` we know that we're (1) not trying
+  // to set a new string, so we don't need to pass it along; (2) setState was
+  // called from Java to trigger a relayout with a `cachedAttributedStringId`,
+  // so Java has all up-to-date information and we should pass an empty map
+  // through.
+  if (cachedAttributedStringId == 0) {
+    // TODO truncation
+    builder.putInt(
+        TX_STATE_KEY_MOST_RECENT_EVENT_COUNT,
+        static_cast<int32_t>(mostRecentEventCount));
+
+    auto attStringMapBuffer = toMapBuffer(attributedStringBox.getValue());
+    builder.putMapBuffer(TX_STATE_KEY_ATTRIBUTED_STRING, attStringMapBuffer);
+    auto paMapBuffer = toMapBuffer(paragraphAttributes);
+    builder.putMapBuffer(TX_STATE_KEY_PARAGRAPH_ATTRIBUTES, paMapBuffer);
+
+    builder.putInt(TX_STATE_KEY_HASH, attStringMapBuffer.getInt(AS_KEY_HASH));
+  }
+  return builder.build();
+}
+#endif
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/{platform/ios/react/renderer/components/iostextinput/TextInputState.h → TextInputState.h}

@@ -11,6 +11,11 @@
 #include <react/renderer/attributedstring/ParagraphAttributes.h>
 #include <react/renderer/textlayoutmanager/TextLayoutManager.h>
 
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#endif
+
 namespace facebook::react {
 
 /*
@@ -20,6 +25,20 @@ class TextInputState final {
  public:
   TextInputState() = default;
 
+  TextInputState(
+      AttributedStringBox attributedStringBox,
+      AttributedString reactTreeAttributedString,
+      ParagraphAttributes paragraphAttributes,
+      int64_t mostRecentEventCount);
+
+#ifdef ANDROID
+  TextInputState(
+      const TextInputState& previousState,
+      const folly::dynamic& data);
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const;
+#endif
+
   /*
    * All content of <TextInput> component.
    */
@@ -40,14 +59,15 @@ class TextInputState final {
    */
   ParagraphAttributes paragraphAttributes;
 
-  /*
-   * `TextLayoutManager` provides a connection to platform-specific
-   * text rendering infrastructure which is capable to render the
-   * `AttributedString`.
-   */
-  std::shared_ptr<const TextLayoutManager> layoutManager;
+  int64_t mostRecentEventCount{0};
 
-  size_t mostRecentEventCount{0};
+#ifdef ANDROID
+  /**
+   * Stores an opaque cache ID used on the Java side to refer to a specific
+   * AttributedString for measurement purposes only.
+   */
+  int64_t cachedAttributedStringId{0};
+#endif
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/platform/android/react/renderer/components/androidtextinput/AndroidTextInputComponentDescriptor.h

@@ -28,11 +28,9 @@ class AndroidTextInputComponentDescriptor final
  public:
   AndroidTextInputComponentDescriptor(
       const ComponentDescriptorParameters& parameters)
-      : ConcreteComponentDescriptor<AndroidTextInputShadowNode>(parameters) {
-    // Every single `AndroidTextInputShadowNode` will have a reference to
-    // a shared `TextLayoutManager`.
-    textLayoutManager_ = std::make_shared<TextLayoutManager>(contextContainer_);
-  }
+      : ConcreteComponentDescriptor<AndroidTextInputShadowNode>(parameters),
+        textLayoutManager_(
+            std::make_shared<TextLayoutManager>(contextContainer_)) {}
 
   virtual State::Shared createInitialState(
       const Props::Shared& props,
@@ -70,8 +68,7 @@ class AndroidTextInputComponentDescriptor final
     }
 
     return std::make_shared<AndroidTextInputShadowNode::ConcreteState>(
-        std::make_shared<const AndroidTextInputState>(AndroidTextInputState(
-            0, {}, {}, {}, theme.start, theme.end, theme.top, theme.bottom)),
+        std::make_shared<const TextInputState>(TextInputState({}, {}, {}, 0)),
         family);
   }
 
@@ -80,13 +77,10 @@ class AndroidTextInputComponentDescriptor final
     auto& textInputShadowNode =
         static_cast<AndroidTextInputShadowNode&>(shadowNode);
 
-    // `ParagraphShadowNode` uses `TextLayoutManager` to measure text content
+    // `TextInputShadowNode` uses `TextLayoutManager` to measure text content
     // and communicate text rendering metrics to mounting layer.
     textInputShadowNode.setTextLayoutManager(textLayoutManager_);
 
-    textInputShadowNode.setContextContainer(
-        const_cast<ContextContainer*>(getContextContainer().get()));
-
     int surfaceId = textInputShadowNode.getSurfaceId();
     if (surfaceIdToThemePaddingMap_.find(surfaceId) !=
         surfaceIdToThemePaddingMap_.end()) {
@@ -152,7 +146,6 @@ class AndroidTextInputComponentDescriptor final
     }
 
     textInputShadowNode.dirtyLayout();
-    textInputShadowNode.enableMeasurement();
 
     ConcreteComponentDescriptor::adopt(shadowNode);
   }
@@ -169,7 +162,7 @@ class AndroidTextInputComponentDescriptor final
   constexpr static auto UIManagerJavaDescriptor =
       "com/facebook/react/fabric/FabricUIManager";
 
-  SharedTextLayoutManager textLayoutManager_;
+  const std::shared_ptr<TextLayoutManager> textLayoutManager_;
   mutable std::unordered_map<int, ThemePadding> surfaceIdToThemePaddingMap_;
 };