react-native-tvos 0.77.1-0 → 0.77.2-1

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

@@ -15,7 +15,6 @@ 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
@@ -31,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
@@ -42,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
@@ -222,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/scroll/ReactHorizontalScrollView.java

@@ -154,7 +154,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
 
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (mScrollEnabled) {
+    if (!mScrollEnabled) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -400,6 +400,14 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
+    if (!mScrollEnabled) {
+      return 0;
+    }
+    return super.computeScrollDeltaToGetChildRectOnScreen(rect);
+  }
+
   @Override
   protected void onScrollChanged(int x, int y, int oldX, int oldY) {
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactScrollView.onScrollChanged");

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/TextLayoutManager.java

@@ -410,23 +410,26 @@ public class TextLayoutManager {
       if (widthYogaMeasureMode == YogaMeasureMode.EXACTLY) {
         desiredWidth = width;
       }
-
       int hintWidth = (int) Math.ceil(desiredWidth);
-      StaticLayout.Builder builder =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        StaticLayout.Builder builder =
           StaticLayout.Builder.obtain(text, 0, spanLength, paint, hintWidth)
-              .setAlignment(alignment)
-              .setLineSpacing(0.f, 1.f)
-              .setIncludePad(includeFontPadding)
-              .setBreakStrategy(textBreakStrategy)
-              .setHyphenationFrequency(hyphenationFrequency)
-              .setTextDirection(
-                  isScriptRTL ? TextDirectionHeuristics.RTL : TextDirectionHeuristics.LTR);
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-        builder.setUseLineSpacingFromFallbacks(true);
-      }
+            .setAlignment(alignment)
+            .setLineSpacing(0.f, 1.f)
+            .setIncludePad(includeFontPadding)
+            .setBreakStrategy(textBreakStrategy)
+            .setHyphenationFrequency(hyphenationFrequency)
+            .setTextDirection(
+              isScriptRTL ? TextDirectionHeuristics.RTL : TextDirectionHeuristics.LTR);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          builder.setUseLineSpacingFromFallbacks(true);
+        }
 
-      layout = builder.build();
+        layout = builder.build();
+      } else {
+        layout = new StaticLayout(text, paint, hintWidth, alignment, 1.0f, 0.0f, includeFontPadding);
+      }
 
     } else if (boring != null && (unconstrainedWidth || boring.width <= width)) {
       int boringLayoutWidth = boring.width;
@@ -445,25 +448,29 @@ public class TextLayoutManager {
               text, paint, boringLayoutWidth, alignment, 1.f, 0.f, boring, includeFontPadding);
     } else {
       // Is used for multiline, boring text and the width is known.
-      StaticLayout.Builder builder =
-          StaticLayout.Builder.obtain(text, 0, spanLength, paint, (int) Math.ceil(width))
-              .setAlignment(alignment)
-              .setLineSpacing(0.f, 1.f)
-              .setIncludePad(includeFontPadding)
-              .setBreakStrategy(textBreakStrategy)
-              .setHyphenationFrequency(hyphenationFrequency)
-              .setTextDirection(
-                  isScriptRTL ? TextDirectionHeuristics.RTL : TextDirectionHeuristics.LTR);
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        builder.setJustificationMode(justificationMode);
-      }
+      if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        StaticLayout.Builder builder =
+            StaticLayout.Builder.obtain(text, 0, spanLength, paint, (int) Math.ceil(width))
+                .setAlignment(alignment)
+                .setLineSpacing(0.f, 1.f)
+                .setIncludePad(includeFontPadding)
+                .setBreakStrategy(textBreakStrategy)
+                .setHyphenationFrequency(hyphenationFrequency)
+                .setTextDirection(
+                    isScriptRTL ? TextDirectionHeuristics.RTL : TextDirectionHeuristics.LTR);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          builder.setJustificationMode(justificationMode);
+        }
 
-      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();
+        layout = builder.build();
+      } else {
+        layout = new StaticLayout(text, paint, (int) Math.ceil(width), alignment, 1.0f, 0.0f, includeFontPadding);
+      }
     }
     return layout;
   }