react-native-windows 0.80.1 → 0.81.0-preview.4

package/Microsoft.ReactNative/Fabric/Composition/DebuggerUIIsland.cpp

@@ -0,0 +1,169 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "DebuggerUIIsland.h"
+
+#include <AutoDraw.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/textlayoutmanager/WindowsTextLayoutManager.h>
+#include <winrt/Microsoft.UI.Composition.h>
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.Input.h>
+#include "CompositionContextHelper.h"
+#include "TextDrawing.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+constexpr float debuggerUIFontSize = 10.0f;
+constexpr float debuggerTextMargin = 4.0f;
+
+DebuggerUIIsland::DebuggerUIIsland(
+    const winrt::Microsoft::UI::Composition::Compositor &compositor,
+    winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
+    winrt::Microsoft::ReactNative::Composition::Theme theme) noexcept
+    : m_compositor(compositor), m_compContext(compContext), m_theme(theme) {
+  m_backgroundVisual = m_compositor.CreateSpriteVisual();
+  m_backgroundVisual.RelativeSizeAdjustment({1.0f, 1.0f});
+
+  auto backgroundBrush = m_compositor.CreateColorBrush({100, 0, 0, 0});
+  m_backgroundVisual.Brush(backgroundBrush);
+
+  m_TextVisual = m_compositor.CreateSpriteVisual();
+  m_TextVisual.IsPixelSnappingEnabled(true);
+
+  m_backgroundVisual.Children().InsertAtTop(m_TextVisual);
+}
+
+DebuggerUIIsland::~DebuggerUIIsland() noexcept {
+  m_island.StateChanged(m_islandStateChangedToken);
+}
+
+void DebuggerUIIsland::Redraw() noexcept {
+  if (!m_island)
+    return;
+
+  if (m_island.ActualSize().x == 0 || m_island.ActualSize().y == 0)
+    return;
+
+  auto scaleFactor = m_island.Environment().DisplayScale();
+
+  auto attributedString = facebook::react::AttributedString{};
+  auto fragment = facebook::react::AttributedString::Fragment{};
+  fragment.string = m_message;
+  fragment.textAttributes.fontSize = debuggerUIFontSize;
+  attributedString.appendFragment(std::move(fragment));
+
+  // Resume Icon
+  auto iconFragment = facebook::react::AttributedString::Fragment{};
+  iconFragment.string = " \uF08F";
+  iconFragment.textAttributes.fontFamily = "Segoe Fluent Icons";
+  iconFragment.textAttributes.fontSize = debuggerUIFontSize;
+  attributedString.appendFragment(std::move(iconFragment));
+
+  auto attributedStringBox = facebook::react::AttributedStringBox{attributedString};
+
+  facebook::react::LayoutConstraints constraints;
+  constraints.maximumSize.width = std::max(0.0f, m_island.ActualSize().x - debuggerTextMargin * 2 * scaleFactor);
+  constraints.maximumSize.height = std::max(0.0f, m_island.ActualSize().y - debuggerTextMargin * 2 * scaleFactor);
+
+  auto textAttributes = facebook::react::TextAttributes{};
+  textAttributes.foregroundColor = facebook::react::blackColor();
+
+  winrt::com_ptr<::IDWriteTextLayout> textLayout;
+  facebook::react::WindowsTextLayoutManager::GetTextLayout(attributedStringBox, {}, constraints, textLayout);
+
+  DWRITE_TEXT_METRICS tm;
+  textLayout->GetMetrics(&tm);
+
+  winrt::Windows::Foundation::Size surfaceSize = {
+      std::ceilf(std::min(constraints.maximumSize.width, tm.width + debuggerTextMargin * 2 * scaleFactor)),
+      std::ceilf(std::min(constraints.maximumSize.height, tm.height + debuggerTextMargin * 2 * scaleFactor))};
+  auto drawingSurface = m_compContext.CreateDrawingSurfaceBrush(
+      surfaceSize,
+      winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,
+      winrt::Windows::Graphics::DirectX::DirectXAlphaMode::Premultiplied);
+
+  POINT offset;
+  {
+    ::Microsoft::ReactNative::Composition::AutoDrawDrawingSurface autoDraw(drawingSurface, scaleFactor, &offset);
+    if (auto d2dDeviceContext = autoDraw.GetRenderTarget()) {
+      d2dDeviceContext->Clear(D2D1::ColorF{1.0f, 1.0f, 0.76f, 1.0f});
+
+      auto theme = winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(m_theme);
+
+      Composition::RenderText(
+          *d2dDeviceContext,
+          *textLayout,
+          attributedStringBox.getValue(),
+          textAttributes,
+          {static_cast<float>(offset.x + std::floorf(debuggerTextMargin * scaleFactor)),
+           static_cast<float>(offset.y + std::floorf(debuggerTextMargin * scaleFactor))},
+          scaleFactor,
+          *theme);
+    }
+
+    drawingSurface.HorizontalAlignmentRatio(0.0f);
+    drawingSurface.Stretch(winrt::Microsoft::ReactNative::Composition::Experimental::CompositionStretch::None);
+
+    m_TextVisual.Brush(winrt::Microsoft::ReactNative::Composition::Experimental::implementation::
+                           MicrosoftCompositionContextHelper::InnerBrush(drawingSurface));
+    m_TextVisual.Size({surfaceSize.Width, surfaceSize.Height});
+
+    m_debuggerHitRect = {
+        m_island.ActualSize().x / 2 - tm.width / 2 + debuggerTextMargin * scaleFactor,
+        debuggerTextMargin * scaleFactor,
+        surfaceSize.Width,
+        surfaceSize.Height};
+
+    m_TextVisual.Offset({m_debuggerHitRect.X, m_debuggerHitRect.Y, 0.0f});
+  }
+}
+
+void DebuggerUIIsland::Message(std::string &&value) noexcept {
+  m_message = value;
+  Redraw();
+}
+
+winrt::Microsoft::UI::Content::ContentIsland DebuggerUIIsland::Island() noexcept {
+  if (!m_island) {
+    m_island = winrt::Microsoft::UI::Content::ContentIsland::Create(m_backgroundVisual);
+
+    m_islandStateChangedToken =
+        m_island.StateChanged([weakThis = weak_from_this()](
+                                  winrt::Microsoft::UI::Content::ContentIsland const &island,
+                                  winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
+          if (auto pThis = weakThis.lock()) {
+            if (args.DidRasterizationScaleChange() || args.DidActualSizeChange()) {
+              pThis->Redraw();
+            }
+          }
+        });
+
+    auto pointerSource = winrt::Microsoft::UI::Input::InputPointerSource::GetForIsland(m_island);
+
+    m_islandPointerUpToken =
+        pointerSource.PointerReleased([weakThis = weak_from_this()](
+                                          winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                          winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+          if (auto pThis = weakThis.lock()) {
+            auto position = args.CurrentPoint().Position();
+            if (position.X >= pThis->m_debuggerHitRect.X && position.Y >= pThis->m_debuggerHitRect.Y &&
+                position.X <= pThis->m_debuggerHitRect.X + pThis->m_debuggerHitRect.Width &&
+                position.Y <= pThis->m_debuggerHitRect.Y + pThis->m_debuggerHitRect.Height) {
+              pThis->m_resumedEvent(nullptr, nullptr);
+            }
+          }
+        });
+  }
+  return m_island;
+}
+
+winrt::event_token DebuggerUIIsland::Resumed(
+    winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept {
+  return m_resumedEvent.add(handler);
+}
+void DebuggerUIIsland::Resumed(winrt::event_token const &token) noexcept {
+  m_resumedEvent.remove(token);
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Fabric/Composition/DebuggerUIIsland.h

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+struct DebuggerUIIsland : std::enable_shared_from_this<DebuggerUIIsland> {
+  DebuggerUIIsland(
+      const winrt::Microsoft::UI::Composition::Compositor &compositor,
+      winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
+      winrt::Microsoft::ReactNative::Composition::Theme theme) noexcept;
+  ~DebuggerUIIsland() noexcept;
+  winrt::Microsoft::UI::Content::ContentIsland Island() noexcept;
+
+  void Message(std::string &&value) noexcept;
+
+  winrt::event_token Resumed(
+      winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept;
+  void Resumed(winrt::event_token const &token) noexcept;
+
+ private:
+  void Redraw() noexcept;
+
+  winrt::event_token m_islandStateChangedToken;
+  winrt::event_token m_islandPointerUpToken;
+
+  winrt::Microsoft::UI::Composition::SpriteVisual m_backgroundVisual{nullptr};
+  winrt::Microsoft::UI::Composition::SpriteVisual m_TextVisual{nullptr};
+  winrt::Windows::Foundation::Rect m_debuggerHitRect{0, 0, 0, 0};
+  winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
+  std::string m_message;
+
+  winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>> m_resumedEvent;
+  winrt::Microsoft::UI::Composition::Compositor m_compositor{nullptr};
+  winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext m_compContext{nullptr};
+  winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Fabric/Composition/DebuggingOverlayComponentView.cpp

@@ -103,9 +103,9 @@ void DebuggingOverlayComponentView::HandleCommand(
       auto rootVisual = root->OuterVisual();
 
       while (m_activeOverlays != 0) {
+        --m_activeOverlays;
         auto visual = rootVisual.GetAt(root->overlayIndex() + m_activeOverlays);
         rootVisual.Remove(visual);
-        --m_activeOverlays;
       }
     }
     return;

package/Microsoft.ReactNative/Fabric/Composition/Modal/WindowsModalHostViewComponentView.cpp

@@ -35,26 +35,38 @@ struct ModalHostState
 struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::Foundation::IInspectable>,
                        ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView> {
   ~ModalHostView() {
-    if (m_reactNativeIsland) {
-      m_reactNativeIsland.Island().Close();
-    }
+    if (m_popUp) {
+      // Unregister closing event handler
+      if (m_appWindow && m_appWindowClosingToken) {
+        m_appWindow.Closing(m_appWindowClosingToken);
+        m_appWindowClosingToken.value = 0;
+      }
 
-    // Add AppWindow closing token cleanup
-    if (m_appWindow && m_appWindowClosingToken) {
-      m_appWindow.Closing(m_appWindowClosingToken);
-      m_appWindowClosingToken.value = 0;
-    }
+      // Reset topWindowID before destroying
+      if (m_prevWindowID) {
+        winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
+            m_reactContext.Properties().Handle(), m_prevWindowID);
+        m_prevWindowID = 0;
+      }
 
-    if (m_popUp) {
-      if (m_departFocusToken && !m_popUp.IsClosed()) {
-        // WASDK BUG: InputFocusNavigationHost::GetForSiteBridge fails on a DesktopPopupSiteBridge
-        // https://github.com/microsoft/react-native-windows/issues/14604
-        /*
-        auto navHost =
-        winrt::Microsoft::UI::Input::InputFocusNavigationHost::GetForSiteBridge(m_popUp.as<winrt::Microsoft::UI::Content::IContentSiteBridge>());
-        navHost.DepartFocusRequested(m_departFocusToken);
-        */
+      // Close island
+      if (m_reactNativeIsland) {
+        m_reactNativeIsland.Island().Close();
+        m_reactNativeIsland = nullptr;
+      }
+
+      // Hide popup
+      if (m_popUp.IsVisible()) {
+        m_popUp.Hide();
+      }
+
+      // Destroy AppWindow this automatically resumes parent window to receive inputs
+      if (m_appWindow) {
+        m_appWindow.Destroy();
+        m_appWindow = nullptr;
       }
+
+      // Close bridge
       m_popUp.Close();
       m_popUp = nullptr;
     }
@@ -88,7 +100,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         QueueShow(view);
       } else {
         m_visible = false;
-        CloseWindow();
+        HideWindow();
       }
     }
 
@@ -219,31 +231,27 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     }
   }
 
-  void CloseWindow() noexcept {
-    // enable input to parent before closing the modal window, so focus can return back to the parent window
-    EnableWindow(m_parentHwnd, true);
+  /*
+  HideWindow called on visible=false
+  unmounts the modal window using onDismiss event
+  */
+  void HideWindow() noexcept {
+    // Hide popup
     if (m_popUp) {
       m_popUp.Hide();
     }
 
-    // Unregister closing event handler
-    if (m_appWindow && m_appWindowClosingToken) {
-      m_appWindow.Closing(m_appWindowClosingToken);
-      m_appWindowClosingToken.value = 0;
+    // Restore message routing to parent
+    if (m_prevWindowID) {
+      winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
+          m_reactContext.Properties().Handle(), m_prevWindowID);
     }
 
-    // dispatch onDismiss event
+    // Dispatch onDismiss event
     if (auto eventEmitter = EventEmitter()) {
       ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnDismiss eventArgs;
       eventEmitter->onDismiss(eventArgs);
     }
-
-    // reset the topWindowID
-    if (m_prevWindowID) {
-      winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
-          m_reactContext.Properties().Handle(), m_prevWindowID);
-      m_prevWindowID = 0;
-    }
   }
 
   // creates a new modal window

package/Microsoft.ReactNative/Fabric/Composition/ReactNativeIsland.cpp

@@ -284,6 +284,7 @@ void ReactNativeIsland::UpdateRootVisualSize() noexcept {
     m_rootVisual.Size({m_size.Width * m_scaleFactor, m_size.Height * m_scaleFactor});
 
   UpdateLoadingVisualSize();
+  UpdateDebuggerVisualSize();
 }
 
 void ReactNativeIsland::UpdateLoadingVisualSize() noexcept {
@@ -300,6 +301,13 @@ void ReactNativeIsland::UpdateLoadingVisualSize() noexcept {
   }
 }
 
+void ReactNativeIsland::UpdateDebuggerVisualSize() noexcept {
+  if (!m_debuggerChildSiteLink)
+    return;
+
+  m_debuggerChildSiteLink.ActualSize(m_size);
+}
+
 float ReactNativeIsland::ScaleFactor() noexcept {
   return m_scaleFactor;
 }
@@ -484,6 +492,20 @@ void ReactNativeIsland::InitRootView(
   m_CompositionEventHandler = std::make_shared<::Microsoft::ReactNative::CompositionEventHandler>(m_context, *this);
   m_CompositionEventHandler->Initialize();
 
+  ::Microsoft::ReactNative::DebuggerNotifications::SubscribeShowDebuggerPausedOverlay(
+      m_context.Notifications().Handle(),
+      m_context.UIDispatcher().Handle(),
+      [weakThis = get_weak()](std::string message, std::function<void()> onResume) {
+        if (auto strongThis = weakThis.get()) {
+          strongThis->ShowDebuggerUI(message, onResume);
+        }
+      },
+      [weakThis = get_weak()]() {
+        if (auto strongThis = weakThis.get()) {
+          strongThis->HideDebuggerUI();
+        }
+      });
+
   UpdateRootViewInternal();
 
   m_isInitialized = true;
@@ -746,7 +768,10 @@ void ReactNativeIsland::ShowInstanceLoading() noexcept {
   NotifySizeChanged();
   UpdateLoadingVisualSize();
 
-  InternalRootVisual().InsertAt(m_loadingVisual, m_hasRenderedVisual ? 1 : 0);
+  // ShowDebuggerUI(); // TEMP
+
+  InternalRootVisual().InsertAt(
+      m_loadingVisual, m_hasRenderedVisual ? (m_debuggerVisual ? 2 : 1) : (m_debuggerVisual ? 1 : 0));
 }
 
 void ReactNativeIsland::InitTextScaleMultiplier() noexcept {
@@ -767,6 +792,48 @@ void ReactNativeIsland::InitTextScaleMultiplier() noexcept {
       });
 }
 
+void ReactNativeIsland::ShowDebuggerUI(std::string message, const std::function<void()> &onResume) noexcept {
+  if (!m_debuggerVisual) {
+    auto compContext =
+        winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+            m_context.Properties().Handle());
+    m_debuggerVisual = compContext.CreateSpriteVisual();
+
+    m_debuggerChildSiteLink = winrt::Microsoft::UI::Content::ChildSiteLink::Create(
+        Island(),
+        winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerVisual(
+            m_debuggerVisual)
+            .as<winrt::Microsoft::UI::Composition::ContainerVisual>());
+
+    m_debuggerUIIsland = std::make_shared<DebuggerUIIsland>(m_compositor, compContext, Theme());
+    m_debuggerUIIsland->Message(std::string(message));
+    m_debuggerVisual.RelativeSizeWithOffset({0.0f, 0.0f}, {1.0f, 1.0f});
+
+    m_debuggerUIIsland->Resumed(
+        [wkThis = get_weak(), onResume](
+            const winrt::Windows::Foundation::IInspectable &, const winrt::Windows::Foundation::IInspectable &) {
+          if (auto pThis = wkThis.get()) {
+            // pThis->HideDebuggerUI();
+            onResume();
+          }
+        });
+
+    InternalRootVisual().InsertAt(m_debuggerVisual, m_hasRenderedVisual ? 1 : 0);
+    m_debuggerUIIsland->Island().IsHitTestVisibleWhenTransparent(false);
+    m_debuggerChildSiteLink.Connect(m_debuggerUIIsland->Island());
+  }
+
+  m_debuggerVisual.IsVisible(true);
+
+  UpdateRootVisualSize();
+}
+
+void ReactNativeIsland::HideDebuggerUI() noexcept {
+  if (m_debuggerVisual) {
+    m_debuggerVisual.IsVisible(false);
+  }
+}
+
 winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) const {

package/Microsoft.ReactNative/Fabric/Composition/ReactNativeIsland.h

@@ -7,11 +7,14 @@
 #include <FocusNavigationResult.g.h>
 
 #include <ReactContext.h>
+#include <ReactHost/DebuggerNotifications.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
 #include <winrt/Microsoft.ReactNative.h>
+#include <winrt/Microsoft.UI.Content.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 #include "CompositionEventHandler.h"
+#include "DebuggerUIIsland.h"
 #include "PortalComponentView.h"
 #include "ReactHost/React.h"
 
@@ -181,6 +184,9 @@ struct ReactNativeIsland
   std::shared_ptr<::Microsoft::ReactNative::CompositionEventHandler> m_CompositionEventHandler;
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual m_rootVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual m_loadingVisual{nullptr};
+  winrt::Microsoft::UI::Content::ChildSiteLink m_debuggerChildSiteLink{nullptr};
+  std::shared_ptr<DebuggerUIIsland> m_debuggerUIIsland;
+  winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual m_debuggerVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IActivityVisual m_loadingActivityVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader m_resources{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
@@ -196,8 +202,11 @@ struct ReactNativeIsland
   void ShowInstanceLoaded() noexcept;
   void ShowInstanceError() noexcept;
   void ShowInstanceLoading() noexcept;
+  void ShowDebuggerUI(std::string message, const std::function<void()> &onResume) noexcept;
+  void HideDebuggerUI() noexcept;
   void UpdateRootVisualSize() noexcept;
   void UpdateLoadingVisualSize() noexcept;
+  void UpdateDebuggerVisualSize() noexcept;
   Composition::Experimental::IDrawingSurfaceBrush CreateLoadingVisualBrush() noexcept;
   void ApplyConstraints(
       const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,

package/Microsoft.ReactNative/Fabric/Composition/ScrollViewComponentView.cpp

@@ -814,6 +814,25 @@ void ScrollViewComponentView::updateProps(
     }
     m_scrollVisual.SetSnapPoints(newViewProps.snapToStart, newViewProps.snapToEnd, snapToOffsets.GetView());
   }
+
+  if (!oldProps || oldViewProps.pagingEnabled != newViewProps.pagingEnabled) {
+    m_scrollVisual.PagingEnabled(newViewProps.pagingEnabled);
+  }
+
+  if (!oldProps || oldViewProps.snapToInterval != newViewProps.snapToInterval) {
+    m_scrollVisual.SnapToInterval(static_cast<float>(newViewProps.snapToInterval));
+  }
+
+  if (!oldProps || oldViewProps.snapToAlignment != newViewProps.snapToAlignment) {
+    using SnapPointsAlignment = winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment;
+    SnapPointsAlignment alignment = SnapPointsAlignment::Near; // default is "start"
+    if (newViewProps.snapToAlignment == facebook::react::ScrollViewSnapToAlignment::Center) {
+      alignment = SnapPointsAlignment::Center;
+    } else if (newViewProps.snapToAlignment == facebook::react::ScrollViewSnapToAlignment::End) {
+      alignment = SnapPointsAlignment::Far;
+    }
+    m_scrollVisual.SnapToAlignment(alignment);
+  }
 }
 
 void ScrollViewComponentView::updateState(

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentDescriptor.h

@@ -48,7 +48,7 @@ virtual State::Shared createInitialState(
       if (getThemeData(
               fabricUIManager, surfaceId, defaultTextInputPaddingArray)) {
         jfloat* defaultTextInputPadding =
-            env->GetFloatArrayElements(defaultTextInputPaddingArray, 0);
+            env->GetFloatArrayElements(defaultTextInputPaddingArray, nullptr);
         theme.start = defaultTextInputPadding[0];
         theme.end = defaultTextInputPadding[1];
         theme.top = defaultTextInputPadding[2];
@@ -59,8 +59,8 @@ virtual State::Shared createInitialState(
       }
 
     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 AndroidTextInputState>(
+            AndroidTextInputState({}, {}, {}, 0)),
         family);
   }
   */