react-native-tvos 0.79.3-0 → 0.80.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/text/frescosupport/FrescoBasedReactTextInlineImageSpan.kt

@@ -0,0 +1,174 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.text.frescosupport
+
+import android.content.res.Resources
+import android.graphics.BlendMode
+import android.graphics.BlendModeColorFilter
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.os.Build
+import android.widget.TextView
+import com.facebook.drawee.controller.AbstractDraweeControllerBuilder
+import com.facebook.drawee.generic.GenericDraweeHierarchy
+import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder
+import com.facebook.drawee.view.DraweeHolder
+import com.facebook.imagepipeline.request.ImageRequest
+import com.facebook.imagepipeline.request.ImageRequestBuilder
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.fresco.ReactNetworkImageRequest
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.views.image.ImageResizeMode
+import com.facebook.react.views.text.internal.span.TextInlineImageSpan
+
+/**
+ * FrescoBasedTextInlineImageSpan is a span for Images that are inside <Text/>. It computes its size
+ * based on the input size. When it is time to draw, it will use the Fresco framework to get the
+ * right Drawable and let that draw.
+ *
+ * Since Fresco needs to callback to the TextView that contains this, in the ViewManager, you must
+ * tell the Span about the TextView
+ *
+ * Note: It borrows code from DynamicDrawableSpan and if that code updates how it computes size or
+ * draws, we need to update this as well.
+ */
+internal class FrescoBasedReactTextInlineImageSpan(
+    resources: Resources,
+    height: Int,
+    width: Int,
+    private val tintColor: Int,
+    uri: Uri?,
+    private val headers: ReadableMap?,
+    private val draweeControllerBuilder: AbstractDraweeControllerBuilder<*, ImageRequest, *, *>,
+    private val callerContext: Any?,
+    private val resizeMode: String?
+) : TextInlineImageSpan() {
+
+  private var textView: TextView? = null
+  private val _uri: Uri = uri ?: Uri.EMPTY
+  private val _width: Int = PixelUtil.toPixelFromDIP(width.toDouble()).toInt()
+  private val _height: Int = PixelUtil.toPixelFromDIP(height.toDouble()).toInt()
+  private val draweeHolder: DraweeHolder<GenericDraweeHierarchy> =
+      DraweeHolder(GenericDraweeHierarchyBuilder.newInstance(resources).build())
+
+  override val width: Int
+    get() = _width
+
+  override val height: Int
+    get() = _height
+
+  override var drawable: Drawable? = null
+    private set
+
+  /**
+   * The ReactTextView that holds this ImageSpan is responsible for passing these methods on so that
+   * we can do proper lifetime management for Fresco
+   */
+  public override fun onDetachedFromWindow() {
+    draweeHolder.onDetach()
+  }
+
+  public override fun onStartTemporaryDetach() {
+    draweeHolder.onDetach()
+  }
+
+  public override fun onAttachedToWindow() {
+    draweeHolder.onAttach()
+  }
+
+  public override fun onFinishTemporaryDetach() {
+    draweeHolder.onAttach()
+  }
+
+  public override fun getSize(
+      paint: Paint,
+      text: CharSequence,
+      start: Int,
+      end: Int,
+      fm: Paint.FontMetricsInt?
+  ): Int {
+    // NOTE: This getSize code is copied from DynamicDrawableSpan and modified
+    // to not use a Drawable
+
+    fm?.let { fm ->
+      fm.ascent = -_height
+      fm.descent = 0
+
+      fm.top = fm.ascent
+      fm.bottom = 0
+    }
+
+    return _width
+  }
+
+  public override fun setTextView(textView: TextView?) {
+    this.textView = textView
+  }
+
+  public override fun draw(
+      canvas: Canvas,
+      text: CharSequence,
+      start: Int,
+      end: Int,
+      x: Float,
+      top: Int,
+      y: Int,
+      bottom: Int,
+      paint: Paint
+  ) {
+    if (drawable == null) {
+      val imageRequestBuilder = ImageRequestBuilder.newBuilderWithSource(_uri)
+      val imageRequest: ImageRequest =
+          ReactNetworkImageRequest.fromBuilderWithHeaders(imageRequestBuilder, headers)
+
+      draweeHolder.hierarchy.setActualImageScaleType(ImageResizeMode.toScaleType(resizeMode))
+
+      draweeControllerBuilder.reset()
+      draweeControllerBuilder.oldController = draweeHolder.controller
+
+      callerContext?.let { draweeControllerBuilder.setCallerContext(it) }
+
+      draweeControllerBuilder.setImageRequest(imageRequest)
+
+      val draweeController = draweeControllerBuilder.build()
+      draweeHolder.controller = draweeController
+      draweeControllerBuilder.reset()
+
+      checkNotNull(draweeHolder.topLevelDrawable).apply {
+        setBounds(0, 0, _width, _height)
+        if (tintColor != 0) {
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            colorFilter = BlendModeColorFilter(tintColor, BlendMode.SRC_IN)
+          } else {
+            colorFilter = PorterDuffColorFilter(tintColor, PorterDuff.Mode.SRC_IN)
+          }
+        }
+        callback = textView
+        drawable = this
+      }
+    }
+
+    // NOTE: This drawing code is copied from DynamicDrawableSpan
+
+    canvas.save()
+
+    // Align to center
+    val _drawable = checkNotNull(drawable)
+    val fontHeight = (paint.descent() - paint.ascent()).toInt()
+    val centerY = y + paint.descent().toInt() - fontHeight / 2
+    val transY = centerY - _drawable.bounds.height() / 2
+
+    canvas.translate(x, transY.toFloat())
+    _drawable.draw(canvas)
+    canvas.restore()
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/frescosupport/FrescoBasedReactTextInlineImageViewManager.kt

@@ -10,6 +10,7 @@ package com.facebook.react.views.text.frescosupport
 import android.view.View
 import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.drawee.controller.AbstractDraweeControllerBuilder
+import com.facebook.imagepipeline.request.ImageRequest
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.BaseViewManager
 import com.facebook.react.uimanager.ThemedReactContext
@@ -24,7 +25,7 @@ internal class FrescoBasedReactTextInlineImageViewManager
 constructor(
     private val draweeControllerBuilder:
         @JvmSuppressWildcards
-        AbstractDraweeControllerBuilder<*, *, *, *>? =
+        AbstractDraweeControllerBuilder<*, ImageRequest, *, *>? =
         null,
     private val callerContext: Any? = null
 ) : BaseViewManager<View, FrescoBasedReactTextInlineImageShadowNode>() {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/CustomLetterSpacingSpan.kt

@@ -16,12 +16,13 @@ import android.text.style.MetricAffectingSpan
  * The letter spacing is specified in pixels, which are converted to ems at paint time; this span
  * must therefore be applied after any spans affecting font size.
  */
-public class CustomLetterSpacingSpan(public val spacing: Float) : MetricAffectingSpan(), ReactSpan {
-  public override fun updateDrawState(paint: TextPaint) {
+internal class CustomLetterSpacingSpan(public val spacing: Float) :
+    MetricAffectingSpan(), ReactSpan {
+  override fun updateDrawState(paint: TextPaint) {
     apply(paint)
   }
 
-  public override fun updateMeasureState(paint: TextPaint) {
+  override fun updateMeasureState(paint: TextPaint) {
     apply(paint)
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/CustomLineHeightSpan.kt

@@ -17,10 +17,10 @@ import kotlin.math.floor
  * LineHeightSpan.Standard which only effects space between the baselines of adjacent line boxes
  * (does not impact space before the first line or after the last).
  */
-public class CustomLineHeightSpan(height: Float) : LineHeightSpan, ReactSpan {
-  public val lineHeight: Int = ceil(height.toDouble()).toInt()
+internal class CustomLineHeightSpan(height: Float) : LineHeightSpan, ReactSpan {
+  val lineHeight: Int = ceil(height.toDouble()).toInt()
 
-  public override fun chooseHeight(
+  override fun chooseHeight(
       text: CharSequence,
       start: Int,
       end: Int,

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/CustomStyleSpan.kt

@@ -27,22 +27,22 @@ import com.facebook.react.views.text.ReactTypefaceUtils
  * appropriate default typeface depending on the style. Fonts are retrieved and cached using the
  * [ReactFontManager]
  */
-public class CustomStyleSpan(
+internal class CustomStyleSpan(
     private val privateStyle: Int,
     private val privateWeight: Int,
-    public val fontFeatureSettings: String?,
-    public val fontFamily: String?,
+    val fontFeatureSettings: String?,
+    val fontFamily: String?,
     private val assetManager: AssetManager
 ) : MetricAffectingSpan(), ReactSpan {
-  public override fun updateDrawState(ds: TextPaint) {
+  override fun updateDrawState(ds: TextPaint) {
     apply(ds, privateStyle, privateWeight, fontFeatureSettings, fontFamily, assetManager)
   }
 
-  public override fun updateMeasureState(paint: TextPaint) {
+  override fun updateMeasureState(paint: TextPaint) {
     apply(paint, privateStyle, privateWeight, fontFeatureSettings, fontFamily, assetManager)
   }
 
-  public val style: Int
+  val style: Int
     get() =
         if (privateStyle == ReactConstants.UNSET) {
           Typeface.NORMAL
@@ -50,7 +50,7 @@ public class CustomStyleSpan(
           privateStyle
         }
 
-  public val weight: Int
+  val weight: Int
     get() =
         if (privateWeight == ReactConstants.UNSET) {
           ReactFontManager.TypefaceStyle.NORMAL
@@ -58,7 +58,7 @@ public class CustomStyleSpan(
           privateWeight
         }
 
-  public companion object {
+  companion object {
     private fun apply(
         paint: Paint,
         style: Int,

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactAbsoluteSizeSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.style.AbsoluteSizeSpan
 
 /** Wraps [AbsoluteSizeSpan] as a [ReactSpan]. */
-public class ReactAbsoluteSizeSpan(size: Int) : AbsoluteSizeSpan(size), ReactSpan
+internal class ReactAbsoluteSizeSpan(size: Int) : AbsoluteSizeSpan(size), ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactBackgroundColorSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.style.BackgroundColorSpan
 
 /** Wraps [BackgroundColorSpan] as a [ReactSpan]. */
-public class ReactBackgroundColorSpan(color: Int) : BackgroundColorSpan(color), ReactSpan
+internal class ReactBackgroundColorSpan(color: Int) : BackgroundColorSpan(color), ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactClickableSpan.kt

@@ -14,6 +14,7 @@ import android.view.View
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.text.ReactTextView
+import com.facebook.react.views.text.TextLayoutManager
 import com.facebook.react.views.view.ViewGroupClickEvent
 
 /**
@@ -35,18 +36,18 @@ import com.facebook.react.views.view.ViewGroupClickEvent
  * (TalkBack announces that the text has links available, and the links are exposed in the context
  * menu).
  */
-public class ReactClickableSpan(public val reactTag: Int) : ClickableSpan(), ReactSpan {
-  public var isKeyboardFocused: Boolean = false
-  public var focusBgColor: Int = Color.TRANSPARENT
+internal class ReactClickableSpan(val reactTag: Int) : ClickableSpan(), ReactSpan {
+  var isKeyboardFocused: Boolean = false
+  var focusBgColor: Int = Color.TRANSPARENT
 
-  public override fun onClick(view: View) {
+  override fun onClick(view: View) {
     val context = view.context as ReactContext
     val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, reactTag)
     eventDispatcher?.dispatchEvent(
         ViewGroupClickEvent(UIManagerHelper.getSurfaceId(context), reactTag))
   }
 
-  public override fun updateDrawState(ds: TextPaint) {
+  override fun updateDrawState(ds: TextPaint) {
     // no super call so we don't change the link color or add an underline by default, as the
     // superclass does.
     if (isKeyboardFocused) {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactForegroundColorSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.style.ForegroundColorSpan
 
 /** Wraps [ForegroundColorSpan] as a [ReactSpan]. */
-public class ReactForegroundColorSpan(color: Int) : ForegroundColorSpan(color), ReactSpan
+internal class ReactForegroundColorSpan(color: Int) : ForegroundColorSpan(color), ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactOpacitySpan.kt

@@ -14,7 +14,7 @@ import android.text.style.UpdateAppearance
 import kotlin.math.roundToInt
 
 /** Multiplies foreground and background alpha channels by given opacity */
-public class ReactOpacitySpan(public val opacity: Float) :
+internal class ReactOpacitySpan(val opacity: Float) :
     CharacterStyle(), UpdateAppearance, ReactSpan {
 
   override fun updateDrawState(paint: TextPaint) {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactSpan.kt

@@ -11,4 +11,4 @@ package com.facebook.react.views.text.internal.span
  * Enables us to distinguish between spans that were added by React Native and spans that were added
  * by something else. All spans that React Native adds should implement this interface.
  */
-public interface ReactSpan
+internal interface ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactStrikethroughSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.style.StrikethroughSpan
 
 /** Wraps [StrikethroughSpan] as a [ReactSpan]. */
-public class ReactStrikethroughSpan : StrikethroughSpan(), ReactSpan
+internal class ReactStrikethroughSpan : StrikethroughSpan(), ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactTagSpan.kt

@@ -9,6 +9,6 @@ package com.facebook.react.views.text.internal.span
 
 /**
  * Instances of this class are used to place reactTag information of nested text react nodes into
- * spannable text rendered by single [TextView]
+ * spannable text rendered by single [android.widget.TextView]
  */
-public class ReactTagSpan(public val reactTag: Int) : ReactSpan
+internal class ReactTagSpan(val reactTag: Int) : ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactTextPaintHolderSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.TextPaint
 
 /** Associates a TextPaint instance with a Spannable for convenience */
-public data class ReactTextPaintHolderSpan(public val textPaint: TextPaint) : ReactSpan
+internal data class ReactTextPaintHolderSpan(val textPaint: TextPaint) : ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ReactUnderlineSpan.kt

@@ -10,4 +10,4 @@ package com.facebook.react.views.text.internal.span
 import android.text.style.UnderlineSpan
 
 /** Wraps [UnderlineSpan] as a [ReactSpan]. */
-public class ReactUnderlineSpan : UnderlineSpan(), ReactSpan
+internal class ReactUnderlineSpan : UnderlineSpan(), ReactSpan

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/SetSpanOperation.kt

@@ -13,17 +13,17 @@ import android.text.Spanned
 import com.facebook.common.logging.FLog
 import kotlin.math.max
 
-public class SetSpanOperation(
+internal class SetSpanOperation(
     private val start: Int,
     private val end: Int,
-    @JvmField public val what: ReactSpan
+    @JvmField val what: ReactSpan
 ) {
   /**
    * @param builder Spannable string builder
    * @param priorityIndex index of this operation in the topological sorting which puts operations
    *   with higher priority before operations with lower priority.
    */
-  public fun execute(builder: SpannableStringBuilder, priorityIndex: Int) {
+  fun execute(builder: SpannableStringBuilder, priorityIndex: Int) {
     check(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.
@@ -51,8 +51,8 @@ public class SetSpanOperation(
     builder.setSpan(what, start, end, spanFlags)
   }
 
-  public companion object {
+  companion object {
     private const val TAG = "SetSpanOperation"
-    public const val SPAN_MAX_PRIORITY: Int = Spanned.SPAN_PRIORITY shr Spanned.SPAN_PRIORITY_SHIFT
+    const val SPAN_MAX_PRIORITY: Int = Spanned.SPAN_PRIORITY shr Spanned.SPAN_PRIORITY_SHIFT
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/ShadowStyleSpan.kt

@@ -10,13 +10,13 @@ package com.facebook.react.views.text.internal.span
 import android.text.TextPaint
 import android.text.style.CharacterStyle
 
-public class ShadowStyleSpan(
+internal class ShadowStyleSpan(
     private val dx: Float,
     private val dy: Float,
     private val radius: Float,
-    public val color: Int
+    val color: Int
 ) : CharacterStyle(), ReactSpan {
-  public override fun updateDrawState(textPaint: TextPaint) {
+  override fun updateDrawState(textPaint: TextPaint) {
     textPaint.setShadowLayer(radius, dx, dy, color)
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/TextInlineImageSpan.kt

@@ -14,32 +14,32 @@ import android.view.View
 import android.widget.TextView
 
 /** Base class for inline image spans. */
-public abstract class TextInlineImageSpan : ReplacementSpan(), ReactSpan {
+internal abstract class TextInlineImageSpan : ReplacementSpan(), ReactSpan {
   /** Get the drawable that is span represents. */
-  public abstract val drawable: Drawable?
+  abstract val drawable: Drawable?
 
   /** Called by the text view from [View.onDetachedFromWindow], */
-  public abstract fun onDetachedFromWindow()
+  abstract fun onDetachedFromWindow()
 
   /** Called by the text view from [View.onStartTemporaryDetach]. */
-  public abstract fun onStartTemporaryDetach()
+  abstract fun onStartTemporaryDetach()
 
   /** Called by the text view from [View.onAttachedToWindow]. */
-  public abstract fun onAttachedToWindow()
+  abstract fun onAttachedToWindow()
 
   /** Called by the text view from [View.onFinishTemporaryDetach]. */
-  public abstract fun onFinishTemporaryDetach()
+  abstract fun onFinishTemporaryDetach()
 
   /** Set the textview that will contain this span. */
-  public abstract fun setTextView(textView: TextView?)
+  abstract fun setTextView(textView: TextView?)
 
   /** Get the width of the span. */
-  public abstract val width: Int
+  abstract val width: Int
 
   /** Get the height of the span. */
-  public abstract val height: Int
+  abstract val height: Int
 
-  public companion object {
+  companion object {
     /**
      * For TextInlineImageSpan we need to update the Span to know that the window is attached and
      * the TextView that we will set as the callback on the Drawable.
@@ -48,7 +48,7 @@ public abstract class TextInlineImageSpan : ReplacementSpan(), ReactSpan {
      * @param view The view which will be set as the callback for the Drawable
      */
     @JvmStatic
-    public fun possiblyUpdateInlineImageSpans(spannable: Spannable, view: TextView?) {
+    fun possiblyUpdateInlineImageSpans(spannable: Spannable, view: TextView?) {
       spannable.getSpans(0, spannable.length, TextInlineImageSpan::class.java).forEach { s ->
         s.onAttachedToWindow()
         s.setTextView(view)

package/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/TextInlineViewPlaceholderSpan.kt

@@ -16,12 +16,9 @@ import android.text.style.ReplacementSpan
  * TextInlineViewPlaceholderSpan is a span for inlined views that are inside <Text></Text>. It
  * computes its size based on the input size. It contains no draw logic, just positioning logic.
  */
-public class TextInlineViewPlaceholderSpan(
-    public val reactTag: Int,
-    public val width: Int,
-    public val height: Int
-) : ReplacementSpan(), ReactSpan {
-  public override fun getSize(
+internal class TextInlineViewPlaceholderSpan(val reactTag: Int, val width: Int, val height: Int) :
+    ReplacementSpan(), ReactSpan {
+  override fun getSize(
       paint: Paint,
       text: CharSequence?,
       start: Int,
@@ -38,7 +35,7 @@ public class TextInlineViewPlaceholderSpan(
     return width
   }
 
-  public override fun draw(
+  override fun draw(
       canvas: Canvas,
       text: CharSequence?,
       start: Int,

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactContentSizeChangedEvent.kt

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.textinput
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.uimanager.events.Event
+
+/** Event emitted by EditText native view when content size changes. */
+internal class ReactContentSizeChangedEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val contentWidth: Float,
+    private val contentHeight: Float
+) : Event<ReactTextChangedEvent>(surfaceId, viewId) {
+  @Deprecated(
+      "Use the constructor with surfaceId instead",
+      ReplaceWith(
+          "ReactContentSizeChangedEvent(surfaceId, viewId, contentSizeWidth, contentSizeHeight)"))
+  constructor(
+      viewId: Int,
+      contentSizeWidth: Float,
+      contentSizeHeight: Float
+  ) : this(ViewUtil.NO_SURFACE_ID, viewId, contentSizeWidth, contentSizeHeight)
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    val contentSize =
+        Arguments.createMap().apply {
+          putDouble("width", contentWidth.toDouble())
+          putDouble("height", contentHeight.toDouble())
+        }
+
+    return Arguments.createMap().apply {
+      putMap("contentSize", contentSize)
+      putInt("target", viewTag)
+    }
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "topContentSizeChange"
+  }
+}