react-native-tvos 0.77.0-0rc5 → 0.77.2-0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/CompositeBackgroundDrawable.kt

@@ -15,7 +15,7 @@ import android.graphics.drawable.Drawable
 import android.graphics.drawable.LayerDrawable
 import android.os.Build
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.style.BorderInsets
 import com.facebook.react.uimanager.style.BorderRadiusStyle
 
@@ -30,10 +30,10 @@ internal class CompositeBackgroundDrawable(
      * Any non-react-managed background already part of the view, like one set as Android style on a
      * TextInput
      */
-    public val originalBackground: Drawable? = null,
+    val originalBackground: Drawable? = null,
 
     /** Non-inset box shadows */
-    outerShadows: LayerDrawable? = null,
+    val outerShadows: List<Drawable> = emptyList(),
 
     /**
      * CSS background layer and border rendering
@@ -41,147 +41,144 @@ internal class CompositeBackgroundDrawable(
      * TODO: we should extract path logic from here, and fast-path to using simpler drawables like
      *   ColorDrawable in the common cases
      */
-    public val cssBackground: CSSBackgroundDrawable? = null,
+    val cssBackground: CSSBackgroundDrawable? = null,
 
     /** Background rendering Layer */
-    background: BackgroundDrawable? = null,
+    val background: BackgroundDrawable? = null,
 
     /** Border rendering Layer */
-    border: BorderDrawable? = null,
+    val border: BorderDrawable? = null,
 
     /** TouchableNativeFeeback set selection background, like "SelectableBackground" */
-    feedbackUnderlay: Drawable? = null,
+    val feedbackUnderlay: Drawable? = null,
 
     /** Inset box-shadows */
-    innerShadows: LayerDrawable? = null,
+    val innerShadows: List<Drawable> = emptyList(),
 
     /** Outline */
-    outline: OutlineDrawable? = null,
-) : LayerDrawable(emptyArray()) {
-  public var outerShadows: LayerDrawable? = outerShadows
-    private set
+    val outline: OutlineDrawable? = null,
 
-  public var background: BackgroundDrawable? = background
-    private set
+    // Holder value for currently set insets
+    var borderInsets: BorderInsets? = null,
 
-  public var border: BorderDrawable? = border
-    private set
-
-  public var feedbackUnderlay: Drawable? = feedbackUnderlay
-    private set
-
-  public var innerShadows: LayerDrawable? = innerShadows
-    private set
-
-  public var outline: OutlineDrawable? = outline
-    private set
-
-  // Holder value for currently set insets
-  public var borderInsets: BorderInsets? = null
-
-  // Holder value for currently set border radius
-  public var borderRadius: BorderRadiusStyle? = null
+    // Holder value for currently set border radius
+    var borderRadius: BorderRadiusStyle? = null,
+) :
+  com.facebook.react.uimanager.drawable.LayerDrawable(
+        createLayersArray(
+            originalBackground,
+            outerShadows,
+            cssBackground,
+            background,
+            border,
+            feedbackUnderlay,
+            innerShadows,
+            outline)) {
 
   init {
     // We want to overlay drawables, instead of placing future drawables within the content area of
     // previous ones. E.g. an EditText style may set padding on a TextInput, but we don't want to
     // constrain background color to the area inside of the padding.
     setPaddingMode(LayerDrawable.PADDING_MODE_STACK)
-
-    addLayer(originalBackground, ORIGINAL_BACKGROUND_ID)
-    addLayer(outerShadows, OUTER_SHADOWS_ID)
-    addLayer(cssBackground, CSS_BACKGROUND_ID)
-    addLayer(background, BACKGROUND_ID)
-    addLayer(border, BORDER_ID)
-    addLayer(feedbackUnderlay, FEEDBACK_UNDERLAY_ID)
-    addLayer(innerShadows, INNER_SHADOWS_ID)
-    addLayer(outline, OUTLINE_ID)
   }
 
-  public fun withNewCssBackground(
-      cssBackground: CSSBackgroundDrawable?
-  ): CompositeBackgroundDrawable {
+  fun withNewCssBackground(cssBackground: CSSBackgroundDrawable?): CompositeBackgroundDrawable {
     return CompositeBackgroundDrawable(
-            context,
-            originalBackground,
-            outerShadows,
-            cssBackground,
-            background,
-            border,
-            feedbackUnderlay,
-            innerShadows,
-            outline)
-        .also { composite ->
-          composite.borderInsets = this.borderInsets
-          composite.borderRadius = this.borderRadius
-        }
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  public fun withNewOuterShadow(outerShadows: LayerDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(outerShadows, OUTER_SHADOWS_ID, this::outerShadows::set)
-
-  public fun withNewBackground(background: BackgroundDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(background, BACKGROUND_ID, this::background::set)
-
-  public fun withNewBorder(border: BorderDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(border, BORDER_ID, this::border::set)
-
-  public fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable =
-      withNewLayer(newUnderlay, FEEDBACK_UNDERLAY_ID, this::feedbackUnderlay::set)
-
-  public fun withNewInnerShadow(innerShadows: LayerDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(innerShadows, INNER_SHADOWS_ID, this::innerShadows::set)
-
-  public fun withNewOutline(outline: OutlineDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(outline, OUTLINE_ID, this::outline::set)
-
-  /** @return true if the layer was updated, false if it was not */
-  private fun updateLayer(layer: Drawable?, id: Int): Boolean {
-    if (layer == null) {
-      return findDrawableByLayerId(id) == null
-    }
-
-    if (findDrawableByLayerId(id) == null) {
-      insertNewLayer(layer, id)
-    } else {
-      setDrawableByLayerId(id, layer)
-    }
-    invalidateSelf()
-    return true
+  fun withNewBackground(background: BackgroundDrawable?): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  private fun insertNewLayer(layer: Drawable?, id: Int) {
-    layer ?: return
-
-    if (numberOfLayers == 0) {
-      addLayer(layer, id)
-      return
-    }
+  fun withNewShadows(
+      outerShadows: List<Drawable>,
+      innerShadows: List<Drawable>
+  ): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
+  }
 
-    for (i in 0..<numberOfLayers) {
-      if (id < getId(i)) {
-        val tempDrawable: Drawable = getDrawable(i)
-        val tempId = getId(i)
-        setDrawable(i, layer)
-        setId(i, id)
-        insertNewLayer(tempDrawable, tempId)
-        return
-      } else if (i == numberOfLayers - 1) {
-        addLayer(layer, id)
-        return
-      }
-    }
+  fun withNewBorder(border: BorderDrawable): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  private fun addLayer(layer: Drawable?, id: Int) {
-    if (layer == null) {
-      return
-    }
+  fun withNewOutline(outline: OutlineDrawable): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
+  }
 
-    addLayer(layer)
-    layer.callback = this
-    setId(numberOfLayers - 1, id)
-    invalidateSelf()
+  fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        newUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
   /* Android's elevation implementation requires this to be implemented to know where to draw the
@@ -200,14 +197,14 @@ internal class CompositeBackgroundDrawable(
         pathForOutline.addRoundRect(
             RectF(bounds),
             floatArrayOf(
-                it.topLeft.horizontal + (computedBorderInsets?.left ?: 0f),
-                it.topLeft.vertical + (computedBorderInsets?.top ?: 0f),
-                it.topRight.horizontal + (computedBorderInsets?.right ?: 0f),
-                it.topRight.vertical + (computedBorderInsets?.top ?: 0f),
-                it.bottomRight.horizontal + (computedBorderInsets?.right ?: 0f),
-                it.bottomRight.vertical + (computedBorderInsets?.bottom ?: 0f),
-                it.bottomLeft.horizontal + (computedBorderInsets?.left ?: 0f),
-                it.bottomLeft.vertical) + (computedBorderInsets?.bottom ?: 0f),
+                (it.topLeft.horizontal + (computedBorderInsets?.left ?: 0f)).dpToPx(),
+                (it.topLeft.vertical + (computedBorderInsets?.top ?: 0f)).dpToPx(),
+                (it.topRight.horizontal + (computedBorderInsets?.right ?: 0f)).dpToPx(),
+                (it.topRight.vertical + (computedBorderInsets?.top ?: 0f)).dpToPx(),
+                (it.bottomRight.horizontal + (computedBorderInsets?.right ?: 0f)).dpToPx(),
+                (it.bottomRight.vertical + (computedBorderInsets?.bottom ?: 0f)).dpToPx(),
+                (it.bottomLeft.horizontal + (computedBorderInsets?.left ?: 0f)).dpToPx(),
+                (it.bottomLeft.vertical + (computedBorderInsets?.bottom ?: 0f)).dpToPx()),
             Path.Direction.CW)
       }
 
@@ -221,41 +218,27 @@ internal class CompositeBackgroundDrawable(
     }
   }
 
-  private fun <T> withNewLayer(
-      newLayer: T,
-      id: Int,
-      setNewLayer: (T) -> Unit,
-  ): CompositeBackgroundDrawable where T : Drawable? {
-    setNewLayer(newLayer)
-    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
-      if (updateLayer(newLayer, id)) {
-        return this
-      }
+  companion object {
+    private fun createLayersArray(
+        originalBackground: Drawable?,
+        outerShadows: List<Drawable>,
+        cssBackground: CSSBackgroundDrawable?,
+        background: BackgroundDrawable?,
+        border: BorderDrawable?,
+        feedbackUnderlay: Drawable?,
+        innerShadows: List<Drawable>,
+        outline: OutlineDrawable?
+    ): Array<Drawable?> {
+      val layers = mutableListOf<Drawable?>()
+      originalBackground?.let { layers.add(it) }
+      layers.addAll(outerShadows.asReversed())
+      cssBackground?.let { layers.add(it) }
+      background?.let { layers.add(it) }
+      border?.let { layers.add(it) }
+      feedbackUnderlay?.let { layers.add(it) }
+      layers.addAll(innerShadows.asReversed())
+      outline?.let { layers.add(it) }
+      return layers.toTypedArray()
     }
-    return CompositeBackgroundDrawable(
-            context,
-            originalBackground,
-            outerShadows,
-            cssBackground,
-            background,
-            border,
-            feedbackUnderlay,
-            innerShadows,
-            outline)
-        .also { composite ->
-          composite.borderInsets = this.borderInsets
-          composite.borderRadius = this.borderRadius
-        }
-  }
-
-  private companion object {
-    private const val ORIGINAL_BACKGROUND_ID: Int = 0
-    private const val OUTER_SHADOWS_ID: Int = 1
-    private const val CSS_BACKGROUND_ID: Int = 2
-    private const val BACKGROUND_ID: Int = 3
-    private const val BORDER_ID: Int = 4
-    private const val FEEDBACK_UNDERLAY_ID: Int = 5
-    private const val INNER_SHADOWS_ID: Int = 6
-    private const val OUTLINE_ID: Int = 7
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/Drawable.kt

@@ -0,0 +1,17 @@
+package com.facebook.react.uimanager.drawable
+
+import android.annotation.TargetApi
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.view.View
+
+internal abstract class Drawable: Drawable() {
+  @TargetApi(Build.VERSION_CODES.M)
+  override fun getLayoutDirection(): Int {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      return super.getLayoutDirection()
+    }
+
+    return View.LAYOUT_DIRECTION_LTR;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/LayerDrawable.kt

@@ -0,0 +1,19 @@
+package com.facebook.react.uimanager.drawable
+
+import android.annotation.TargetApi
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.LayerDrawable
+import android.os.Build
+import android.view.View
+
+
+internal abstract class LayerDrawable(layers: Array<Drawable?>) : LayerDrawable(layers) {
+  @TargetApi(Build.VERSION_CODES.M)
+  override fun getLayoutDirection(): Int {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      return super.getLayoutDirection()
+    }
+
+    return View.LAYOUT_DIRECTION_LTR;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/OutlineDrawable.kt

@@ -17,7 +17,6 @@ import android.graphics.Path
 import android.graphics.PathEffect
 import android.graphics.PixelFormat
 import android.graphics.RectF
-import android.graphics.drawable.Drawable
 import com.facebook.react.uimanager.PixelUtil.pxToDp
 import com.facebook.react.uimanager.style.BorderRadiusStyle
 import com.facebook.react.uimanager.style.ComputedBorderRadius

package/ReactAndroid/src/main/java/com/facebook/react/views/image/ReactImageManager.kt

@@ -124,7 +124,7 @@ public constructor(
     }
   }
 
-  @ReactProp(name = "defaultSource", customType = "ImageSource")
+  @ReactProp(name = "defaultSource")
   public fun setDefaultSource(view: ReactImageView, source: String?) {
     view.setDefaultSource(source)
   }

package/ReactAndroid/src/main/java/com/facebook/react/views/modal/ReactModalHostView.kt

@@ -29,6 +29,7 @@ import android.widget.FrameLayout
 import androidx.annotation.UiThread
 import com.facebook.common.logging.FLog
 import com.facebook.react.R
+import com.facebook.react.ReactActivity
 import com.facebook.react.bridge.GuardedRunnable
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactContext
@@ -275,12 +276,31 @@ public class ReactModalHostView(context: ThemedReactContext) :
                 // activity expects to receive those events and react to them, ie. in the case of
                 // the dev menu
                 val innerCurrentActivity =
-                    (this@ReactModalHostView.context as ReactContext).currentActivity
+                    (this@ReactModalHostView.context as ReactContext).currentActivity as? ReactActivity
                 if (innerCurrentActivity != null) {
-                  return innerCurrentActivity.onKeyUp(keyCode, event)
+                  return innerCurrentActivity.onDialogKeyUp(keyCode, event)
                 }
               }
             }
+
+            // @see https://github.com/react-native-tvos/react-native-tvos/issues/829
+            if (event.action == KeyEvent.ACTION_DOWN) {
+              // Allow BACK and ESCAPE keys to propagate to the dialog's activity.
+              // Returning false ensures these keys are not consumed here, so they
+              // can be processed during the ACTION_UP event where their functionality
+              // is handled by JavaScript.
+              if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_ESCAPE) {
+                return false
+              }
+
+              // Redirect all other key down events to the current activity.
+              val innerCurrentActivity =
+                (this@ReactModalHostView.context as ReactContext).currentActivity as? ReactActivity
+              if (innerCurrentActivity != null) {
+                return innerCurrentActivity.onDialogKeyDown(keyCode, event)
+              }
+            }
+
             return false
           }
         })

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactBaseTextShadowNode.java

@@ -7,6 +7,7 @@
 
 package com.facebook.react.views.text;
 
+import android.annotation.TargetApi;
 import android.graphics.Color;
 import android.graphics.Typeface;
 import android.os.Build;
@@ -66,6 +67,7 @@ import java.util.Map;
  * <p>This also node calculates {@link Spannable} object based on subnodes of the same type, which
  * can be used in concrete classes to feed native views and compute layout.
  */
+@TargetApi(Build.VERSION_CODES.M)
 public abstract class ReactBaseTextShadowNode extends LayoutShadowNode {
 
   // Use a direction weak character so the placeholder doesn't change the direction of the previous
@@ -330,8 +332,10 @@ public abstract class ReactBaseTextShadowNode extends LayoutShadowNode {
 
   protected int mNumberOfLines = ReactConstants.UNSET;
   protected int mTextAlign = Gravity.NO_GRAVITY;
-  protected int mTextBreakStrategy = Layout.BREAK_STRATEGY_HIGH_QUALITY;
-  protected int mHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE;
+  protected int mTextBreakStrategy =
+    (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? Layout.BREAK_STRATEGY_SIMPLE : Layout.BREAK_STRATEGY_HIGH_QUALITY;
+  protected int mHyphenationFrequency =
+    (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? Layout.BREAK_STRATEGY_SIMPLE : Layout.HYPHENATION_FREQUENCY_NONE;
   protected int mJustificationMode =
       (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) ? 0 : Layout.JUSTIFICATION_MODE_NONE;
 
@@ -573,6 +577,10 @@ public abstract class ReactBaseTextShadowNode extends LayoutShadowNode {
 
   @ReactProp(name = ViewProps.TEXT_BREAK_STRATEGY)
   public void setTextBreakStrategy(@Nullable String textBreakStrategy) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      return;
+    }
+
     if (textBreakStrategy == null || "highQuality".equals(textBreakStrategy)) {
       mTextBreakStrategy = Layout.BREAK_STRATEGY_HIGH_QUALITY;
     } else if ("simple".equals(textBreakStrategy)) {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.java

@@ -224,21 +224,26 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
       // Is used when the width is not known and the text is not boring, ie. if it contains
       // unicode characters.
       int hintWidth = (int) Math.ceil(desiredWidth);
-      StaticLayout.Builder builder =
-          StaticLayout.Builder.obtain(text, 0, text.length(), textPaint, hintWidth)
-              .setAlignment(alignment)
-              .setLineSpacing(0.f, 1.f)
-              .setIncludePad(mIncludeFontPadding)
-              .setBreakStrategy(mTextBreakStrategy)
-              .setHyphenationFrequency(mHyphenationFrequency);
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        builder.setJustificationMode(mJustificationMode);
-      }
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-        builder.setUseLineSpacingFromFallbacks(true);
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        StaticLayout.Builder builder =
+          StaticLayout.Builder.obtain(text, 0, text.length(), textPaint, (int) width)
+            .setAlignment(alignment)
+            .setLineSpacing(0.f, 1.f)
+            .setIncludePad(mIncludeFontPadding)
+            .setBreakStrategy(mTextBreakStrategy)
+            .setHyphenationFrequency(mHyphenationFrequency);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          builder.setJustificationMode(mJustificationMode);
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          builder.setUseLineSpacingFromFallbacks(true);
+        }
+        layout = builder.build();
+      } else {
+        layout = new StaticLayout(text, textPaint, (int) width, alignment, 1.f, 0.f, mIncludeFontPadding);
       }
-      layout = builder.build();
 
     } else if (boring != null && (unconstrainedWidth || boring.width <= width)) {
       // Is used for single-line, boring text when the width is either unknown or bigger
@@ -262,22 +267,26 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
         width = (float) Math.ceil(width);
       }
 
-      StaticLayout.Builder builder =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        StaticLayout.Builder builder =
           StaticLayout.Builder.obtain(text, 0, text.length(), textPaint, (int) width)
-              .setAlignment(alignment)
-              .setLineSpacing(0.f, 1.f)
-              .setIncludePad(mIncludeFontPadding)
-              .setBreakStrategy(mTextBreakStrategy)
-              .setHyphenationFrequency(mHyphenationFrequency);
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        builder.setJustificationMode(mJustificationMode);
-      }
+            .setAlignment(alignment)
+            .setLineSpacing(0.f, 1.f)
+            .setIncludePad(mIncludeFontPadding)
+            .setBreakStrategy(mTextBreakStrategy)
+            .setHyphenationFrequency(mHyphenationFrequency);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          builder.setJustificationMode(mJustificationMode);
+        }
 
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-        builder.setUseLineSpacingFromFallbacks(true);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          builder.setUseLineSpacingFromFallbacks(true);
+        }
+        layout = builder.build();
+      } else {
+        layout = new StaticLayout(text, textPaint, (int) width, alignment, 1.f, 0.f, mIncludeFontPadding);
       }
-      layout = builder.build();
     }
     return layout;
   }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextView.java

@@ -377,8 +377,8 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
             mMinimumFontSize,
             mNumberOfLines,
             getIncludeFontPadding(),
-            getBreakStrategy(),
-            getHyphenationFrequency(),
+            (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? -1 :getBreakStrategy(),
+            (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? -1 : getHyphenationFrequency(),
             // always passing ALIGN_NORMAL here should be fine, since this method doesn't depend on
             // how exactly lines are aligned, just their width
             Layout.Alignment.ALIGN_NORMAL,
@@ -441,7 +441,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
       if (nextTextAlign != getGravityHorizontal()) {
         setGravityHorizontal(nextTextAlign);
       }
-      if (getBreakStrategy() != update.getTextBreakStrategy()) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && getBreakStrategy() != update.getTextBreakStrategy()) {
         setBreakStrategy(update.getTextBreakStrategy());
       }
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java

@@ -61,6 +61,7 @@ public class TextAttributeProps {
   public static final short TA_KEY_LINE_BREAK_STRATEGY = 25;
   public static final short TA_KEY_ROLE = 26;
   public static final short TA_KEY_TEXT_TRANSFORM = 27;
+  public static final short TA_KEY_MAX_FONT_SIZE_MULTIPLIER = 29;
 
   public static final int UNSET = -1;
 
@@ -81,6 +82,7 @@ public class TextAttributeProps {
   protected float mLineHeight = Float.NaN;
   protected boolean mIsColorSet = false;
   protected boolean mAllowFontScaling = true;
+  protected float mMaxFontSizeMultiplier = Float.NaN;
   protected int mColor;
   protected boolean mIsBackgroundColorSet = false;
   protected int mBackgroundColor;
@@ -227,6 +229,9 @@ public class TextAttributeProps {
         case TA_KEY_TEXT_TRANSFORM:
           result.setTextTransform(entry.getStringValue());
           break;
+        case TA_KEY_MAX_FONT_SIZE_MULTIPLIER:
+          result.setMaxFontSizeMultiplier((float) entry.getDoubleValue());
+          break;
       }
     }
 
@@ -243,6 +248,8 @@ public class TextAttributeProps {
     result.setLineHeight(getFloatProp(props, ViewProps.LINE_HEIGHT, ReactConstants.UNSET));
     result.setLetterSpacing(getFloatProp(props, ViewProps.LETTER_SPACING, Float.NaN));
     result.setAllowFontScaling(getBooleanProp(props, ViewProps.ALLOW_FONT_SCALING, true));
+    result.setMaxFontSizeMultiplier(
+        getFloatProp(props, ViewProps.MAX_FONT_SIZE_MULTIPLIER, Float.NaN));
     result.setFontSize(getFloatProp(props, ViewProps.FONT_SIZE, ReactConstants.UNSET));
     result.setColor(props.hasKey(ViewProps.COLOR) ? props.getInt(ViewProps.COLOR, 0) : null);
     result.setColor(
@@ -411,7 +418,14 @@ public class TextAttributeProps {
       mAllowFontScaling = allowFontScaling;
       setFontSize(mFontSizeInput);
       setLineHeight(mLineHeightInput);
-      setLetterSpacing(mLetterSpacingInput);
+    }
+  }
+
+  private void setMaxFontSizeMultiplier(float maxFontSizeMultiplier) {
+    if (maxFontSizeMultiplier != mMaxFontSizeMultiplier) {
+      mMaxFontSizeMultiplier = maxFontSizeMultiplier;
+      setFontSize(mFontSizeInput);
+      setLineHeight(mLineHeightInput);
     }
   }
 
@@ -420,7 +434,7 @@ public class TextAttributeProps {
     if (fontSize != ReactConstants.UNSET) {
       fontSize =
           mAllowFontScaling
-              ? (float) Math.ceil(PixelUtil.toPixelFromSP(fontSize))
+              ? (float) Math.ceil(PixelUtil.toPixelFromSP(fontSize, mMaxFontSizeMultiplier))
               : (float) Math.ceil(PixelUtil.toPixelFromDIP(fontSize));
     }
     mFontSize = (int) fontSize;