From 73f4a788f18aed2277f6711f689b75ab8ce13b1b Mon Sep 17 00:00:00 2001 From: Jakub Trzebiatowski Date: Thu, 25 May 2023 17:09:21 -0700 Subject: [PATCH] Fixed random styling for text nodes with many children (#36656) Summary: Attempting to fix the issue https://github.com/facebook/react-native/issues/33418 ## Changelog [ANDROID] Fixed inconsistent styling for text nodes with many children Pull Request resolved: https://github.com/facebook/react-native/pull/36656 Test Plan: No test plan yet. I'd like to ask for help with creating one. ## Putting template aside, I'd like to ask for a review of the approach I'm suggesting. React Native as-is (at least in some cases) [messes up the styles](https://github.com/facebook/react-native/issues/33418#issuecomment-1485305556) for text nodes with more than 85 children, just like that. ![image](https://user-images.githubusercontent.com/2590174/227981778-7ef6e7e1-00ee-4f67-bcf1-d452183ea33d.png) All of this text should be blue. The root cause is that code (on Android) assumes it can assign as many `Spannable` span priority values as we'd like, while in reality, it has to be packed in an 8-bit-long section of the flags mask. So 255 possible values. In the scenario I produced, React generates three spans per text node, and for 85 text nodes, it sums up to 255. For each span, a new priority value is assigned. As I understand it, we don't need that many priority values. If I'm not mistaken, these priorities are crucial only for ensuring that nested styles have precedence over the outer ones. I'm proposing to calculate the priority value "vertically" (based on the node's depth in the tree) not "horizontally" (based on its position). It would be awesome if some core engineer familiar with `ReactAndroid` shared their experience with this module, especially if there are any known cases when we _know_ that we'd like to create overlapping spans fighting over the same aspects of the style. Reviewed By: cortinico Differential Revision: D46094200 Pulled By: NickGerleman fbshipit-source-id: aae195c71684fe50469a1ee1bd30625cbfc3622f --- .../views/text/ReactBaseTextShadowNode.java | 35 ++----------- .../react/views/text/SetSpanOperation.java | 52 +++++++++++++++++++ .../react/views/text/TextLayoutManager.java | 36 ++----------- .../text/TextLayoutManagerMapBuffer.java | 36 ++----------- 4 files changed, 67 insertions(+), 92 deletions(-) create mode 100644 packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/SetSpanOperation.java diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactBaseTextShadowNode.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactBaseTextShadowNode.java index 12c1c5e05728a9..b5811c7b502bba 100644 --- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactBaseTextShadowNode.java +++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactBaseTextShadowNode.java @@ -69,31 +69,6 @@ public abstract class ReactBaseTextShadowNode extends LayoutShadowNode { protected @Nullable ReactTextViewManagerCallback mReactTextViewManagerCallback; - private static class SetSpanOperation { - protected int start, end; - protected ReactSpan what; - - SetSpanOperation(int start, int end, ReactSpan what) { - this.start = start; - this.end = end; - this.what = what; - } - - public void execute(SpannableStringBuilder sb, int priority) { - // All spans will automatically extend to the right of the text, but not the left - except - // for spans that start at the beginning of the text. - int spanFlags = Spannable.SPAN_EXCLUSIVE_INCLUSIVE; - if (start == 0) { - spanFlags = Spannable.SPAN_INCLUSIVE_INCLUSIVE; - } - - spanFlags &= ~Spannable.SPAN_PRIORITY; - spanFlags |= (priority << Spannable.SPAN_PRIORITY_SHIFT) & Spannable.SPAN_PRIORITY; - - sb.setSpan(what, start, end, spanFlags); - } - } - private static void buildSpannedFromShadowNode( ReactBaseTextShadowNode textShadowNode, SpannableStringBuilder sb, @@ -276,8 +251,9 @@ protected Spannable spannedFromShadowNode( // While setting the Spans on the final text, we also check whether any of them are inline views // or images. - int priority = 0; - for (SetSpanOperation op : ops) { + for (int priorityIndex = 0; priorityIndex < ops.size(); priorityIndex++) { + final SetSpanOperation op = ops.get(ops.size() - priorityIndex - 1); + boolean isInlineImage = op.what instanceof TextInlineImageSpan; if (isInlineImage || op.what instanceof TextInlineViewPlaceholderSpan) { int height; @@ -304,9 +280,8 @@ protected Spannable spannedFromShadowNode( } // Actual order of calling {@code execute} does NOT matter, - // but the {@code priority} DOES matter. - op.execute(sb, priority); - priority++; + // but the {@code priorityIndex} DOES matter. + op.execute(sb, priorityIndex); } textShadowNode.mTextAttributes.setHeightOfTallestInlineViewOrImage( diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/SetSpanOperation.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/SetSpanOperation.java new file mode 100644 index 00000000000000..cccbe58d904e95 --- /dev/null +++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/SetSpanOperation.java @@ -0,0 +1,52 @@ +package com.facebook.react.views.text; + +import android.text.Spannable; +import android.text.SpannableStringBuilder; +import android.text.Spanned; +import com.facebook.common.logging.FLog; + +class SetSpanOperation { + private static final String TAG = "SetSpanOperation"; + static final int SPAN_MAX_PRIORITY = Spanned.SPAN_PRIORITY >> Spanned.SPAN_PRIORITY_SHIFT; + + protected int start, end; + protected ReactSpan what; + + SetSpanOperation(int start, int end, ReactSpan what) { + this.start = start; + this.end = end; + this.what = what; + } + + /** + * @param sb builder + * @param priorityIndex index of this operation in the topological sorting which puts operations + * with higher priority before operations with lower priority. + */ + public void execute(SpannableStringBuilder sb, int priorityIndex) { + assert priorityIndex >= 0; + + // All spans will automatically extend to the right of the text, but not the left - except + // for spans that start at the beginning of the text. + int spanFlags = Spannable.SPAN_EXCLUSIVE_INCLUSIVE; + if (start == 0) { + spanFlags = Spannable.SPAN_INCLUSIVE_INCLUSIVE; + } + + // Calculate priority, assigning the highest values to operations with the highest priority + final int priority = SPAN_MAX_PRIORITY - priorityIndex; + + if (priority < 0) { + FLog.w(TAG, "Text tree size exceeded the limit, styling may become unpredictable"); + } + + // If the computed priority doesn't fit in the flags, clamp it. The effect might not be correct + // in 100% of cases, but doing nothing (as we did in the past) leads to totally random results. + final int effectivePriority = Math.max(priority, 0); + + spanFlags &= ~Spannable.SPAN_PRIORITY; + spanFlags |= (effectivePriority << Spannable.SPAN_PRIORITY_SHIFT) & Spannable.SPAN_PRIORITY; + + sb.setSpan(what, start, end, spanFlags); + } +} diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManager.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManager.java index 6dae0fea51dc85..2f41183fd42b20 100644 --- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManager.java +++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManager.java @@ -213,12 +213,12 @@ private static Spannable createSpannableFromAttributedString( // TODO T31905686: add support for inline Images // While setting the Spans on the final text, we also check whether any of them are images. - int priority = 0; - for (SetSpanOperation op : ops) { + for (int priorityIndex = 0; priorityIndex < ops.size(); ++priorityIndex) { + final SetSpanOperation op = ops.get(ops.size() - priorityIndex - 1); + // Actual order of calling {@code execute} does NOT matter, - // but the {@code priority} DOES matter. - op.execute(sb, priority); - priority++; + // but the {@code priorityIndex} DOES matter. + op.execute(sb, priorityIndex); } if (reactTextViewManagerCallback != null) { @@ -551,30 +551,4 @@ public static WritableArray measureLines( hyphenationFrequency); return FontMetricsUtil.getFontMetrics(text, layout, sTextPaintInstance, context); } - - // TODO T31905686: This class should be private - public static class SetSpanOperation { - protected int start, end; - protected ReactSpan what; - - public SetSpanOperation(int start, int end, ReactSpan what) { - this.start = start; - this.end = end; - this.what = what; - } - - public void execute(Spannable sb, int priority) { - // All spans will automatically extend to the right of the text, but not the left - except - // for spans that start at the beginning of the text. - int spanFlags = Spannable.SPAN_EXCLUSIVE_INCLUSIVE; - if (start == 0) { - spanFlags = Spannable.SPAN_INCLUSIVE_INCLUSIVE; - } - - spanFlags &= ~Spannable.SPAN_PRIORITY; - spanFlags |= (priority << Spannable.SPAN_PRIORITY_SHIFT) & Spannable.SPAN_PRIORITY; - - sb.setSpan(what, start, end, spanFlags); - } - } } diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManagerMapBuffer.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManagerMapBuffer.java index 5cc8b14b3ba6b9..3945bacfc9faec 100644 --- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManagerMapBuffer.java +++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManagerMapBuffer.java @@ -227,12 +227,12 @@ private static Spannable createSpannableFromAttributedString( // TODO T31905686: add support for inline Images // While setting the Spans on the final text, we also check whether any of them are images. - int priority = 0; - for (SetSpanOperation op : ops) { + for (int priorityIndex = 0; priorityIndex < ops.size(); ++priorityIndex) { + final SetSpanOperation op = ops.get(ops.size() - priorityIndex - 1); + // Actual order of calling {@code execute} does NOT matter, - // but the {@code priority} DOES matter. - op.execute(sb, priority); - priority++; + // but the {@code priorityIndex} DOES matter. + op.execute(sb, priorityIndex); } if (reactTextViewManagerCallback != null) { @@ -570,30 +570,4 @@ public static WritableArray measureLines( hyphenationFrequency); return FontMetricsUtil.getFontMetrics(text, layout, sTextPaintInstance, context); } - - // TODO T31905686: This class should be private - public static class SetSpanOperation { - protected int start, end; - protected ReactSpan what; - - public SetSpanOperation(int start, int end, ReactSpan what) { - this.start = start; - this.end = end; - this.what = what; - } - - public void execute(Spannable sb, int priority) { - // All spans will automatically extend to the right of the text, but not the left - except - // for spans that start at the beginning of the text. - int spanFlags = Spannable.SPAN_EXCLUSIVE_INCLUSIVE; - if (start == 0) { - spanFlags = Spannable.SPAN_INCLUSIVE_INCLUSIVE; - } - - spanFlags &= ~Spannable.SPAN_PRIORITY; - spanFlags |= (priority << Spannable.SPAN_PRIORITY_SHIFT) & Spannable.SPAN_PRIORITY; - - sb.setSpan(what, start, end, spanFlags); - } - } }