react-native-tvos 0.74.5-0 → 0.75.2-0rc0

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

@@ -45,6 +45,7 @@ import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.fresco.ReactNetworkImageRequest;
 import com.facebook.react.uimanager.FloatUtil;
 import com.facebook.react.uimanager.PixelUtil;
@@ -133,6 +134,7 @@ public class ReactImageView extends GenericDraweeView {
   private int mFadeDurationMs = -1;
   private boolean mProgressiveRenderingEnabled;
   private ReadableMap mHeaders;
+  private float mResizeMultiplier = 1.0f;
 
   // We can't specify rounding in XML, so have to do so here
   private static GenericDraweeHierarchy buildHierarchy(Context context) {
@@ -306,6 +308,14 @@ public class ReactImageView extends GenericDraweeView {
     }
   }
 
+  public void setResizeMultiplier(float multiplier) {
+    boolean isNewMultiplier = Math.abs(mResizeMultiplier - multiplier) > 0.0001f;
+    if (isNewMultiplier) {
+      mResizeMultiplier = multiplier;
+      mIsDirty = true;
+    }
+  }
+
   public void setSource(@Nullable ReadableArray sources) {
     List<ImageSource> tmpSources = new LinkedList<>();
 
@@ -477,7 +487,7 @@ public class ReactImageView extends GenericDraweeView {
     }
     Postprocessor postprocessor = MultiPostprocessor.from(postprocessors);
 
-    ResizeOptions resizeOptions = doResize ? new ResizeOptions(getWidth(), getHeight()) : null;
+    ResizeOptions resizeOptions = doResize ? getResizeOptions() : null;
 
     ImageRequestBuilder imageRequestBuilder =
         ImageRequestBuilder.newBuilderWithSource(mImageSource.getUri())
@@ -578,8 +588,8 @@ public class ReactImageView extends GenericDraweeView {
     } else if (hasMultipleSources()) {
       MultiSourceResult multiSource =
           MultiSourceHelper.getBestSourceForSize(getWidth(), getHeight(), mSources);
-      mImageSource = multiSource.getBestResult();
-      mCachedImageSource = multiSource.getBestResultInCache();
+      mImageSource = multiSource.bestResult;
+      mCachedImageSource = multiSource.bestResultInCache;
       return;
     }
 
@@ -600,8 +610,26 @@ public class ReactImageView extends GenericDraweeView {
     }
   }
 
+  @Nullable
+  private ResizeOptions getResizeOptions() {
+    int width = Math.round((float) getWidth() * mResizeMultiplier);
+    int height = Math.round((float) getHeight() * mResizeMultiplier);
+    if (width <= 0 || height <= 0) {
+      return null;
+    }
+    return new ResizeOptions(width, height);
+  }
+
   private void warnImageSource(String uri) {
-    if (ReactBuildConfig.DEBUG) {
+    // TODO(T189014077): This code-path produces an infinite loop of js calls with logbox.
+    // This is an issue with Fabric view preallocation, react, and LogBox. Fix.
+    // The bug:
+    // 1. An app renders an <Image/>
+    // 2. Fabric preallocates <Image/>; sets a null src to ReactImageView (potential problem?).
+    // 3. ReactImageView detects the null src; displays a warning in LogBox (via this code).
+    // 3. LogBox renders an <Image/>, which fabric preallocates.
+    // 4. Rinse and repeat.
+    if (ReactBuildConfig.DEBUG && !ReactFeatureFlags.enableBridgelessArchitecture) {
       RNLog.w(
           (ReactContext) getContext(),
           "ReactImageView: Image source \"" + uri + "\" doesn't exist");

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

@@ -0,0 +1,41 @@
+/*
+ * 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.image
+
+import android.graphics.Matrix
+import android.graphics.Rect
+import com.facebook.drawee.drawable.ScalingUtils
+import com.facebook.drawee.drawable.ScalingUtils.AbstractScaleType
+import kotlin.math.min
+
+internal class ScaleTypeStartInside : AbstractScaleType() {
+  override fun getTransformImpl(
+      outTransform: Matrix,
+      parentRect: Rect,
+      childWidth: Int,
+      childHeight: Int,
+      focusX: Float,
+      focusY: Float,
+      scaleX: Float,
+      scaleY: Float
+  ) {
+    val scale = min(scaleX, scaleY).coerceAtMost(1.0f)
+    val dx = parentRect.left.toFloat()
+    val dy = parentRect.top.toFloat()
+    outTransform.setScale(scale, scale)
+    outTransform.postTranslate(Math.round(dx).toFloat(), Math.round(dy).toFloat())
+  }
+
+  override fun toString(): String {
+    return "start_inside"
+  }
+
+  companion object {
+    val INSTANCE: ScalingUtils.ScaleType = ScaleTypeStartInside()
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/imagehelper/ImageSource.kt

@@ -0,0 +1,73 @@
+/*
+ * 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.imagehelper
+
+import android.content.Context
+import android.net.Uri
+import java.util.Objects
+
+/** Class describing an image source (network URI or resource) and size. */
+public class ImageSource
+@JvmOverloads
+constructor(
+    context: Context,
+    /** Get the source of this image, as it was passed to the constructor. */
+    public val source: String?,
+    width: Double = 0.0,
+    height: Double = 0.0
+) {
+
+  /** Get the URI for this image - can be either a parsed network URI or a resource URI. */
+  public val uri: Uri = computeUri(context)
+  /** Get the area of this image. */
+  public val size: Double = width * height
+  /** Get whether this image source represents an Android resource or a network URI. */
+  public var isResource: Boolean = false
+    private set
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) {
+      return true
+    }
+
+    if (other == null || javaClass != other.javaClass) {
+      return false
+    }
+
+    val that = other as ImageSource
+    return java.lang.Double.compare(that.size, size) == 0 &&
+        isResource == that.isResource &&
+        uri == that.uri &&
+        source == that.source
+  }
+
+  override fun hashCode(): Int = Objects.hash(uri, source, size, isResource)
+
+  private fun computeUri(context: Context): Uri =
+      try {
+        val uri = Uri.parse(source)
+        // Verify scheme is set, so that relative uri (used by static resources) are not handled.
+        if (uri.scheme == null) computeLocalUri(context) else uri
+      } catch (e: NullPointerException) {
+        computeLocalUri(context)
+      }
+
+  private fun computeLocalUri(context: Context): Uri {
+    isResource = true
+    return ResourceDrawableIdHelper.instance.getResourceDrawableUri(context, source)
+  }
+
+  public companion object {
+    private const val TRANSPARENT_BITMAP_URI =
+        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
+
+    @JvmStatic
+    public fun getTransparentBitmapImageSource(context: Context): ImageSource =
+        ImageSource(context, TRANSPARENT_BITMAP_URI)
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/imagehelper/MultiSourceHelper.kt

@@ -0,0 +1,89 @@
+/*
+ * 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.imagehelper
+
+import com.facebook.imagepipeline.core.ImagePipelineFactory
+
+/** Helper class for dealing with multisource images. */
+public object MultiSourceHelper {
+  @JvmStatic
+  public fun getBestSourceForSize(
+      width: Int,
+      height: Int,
+      sources: List<ImageSource>
+  ): MultiSourceResult = getBestSourceForSize(width, height, sources, 1.0)
+
+  /**
+   * Chooses the image source with the size closest to the target image size.
+   *
+   * @param width the width of the view that will be used to display this image
+   * @param height the height of the view that will be used to display this image
+   * @param sources the list of potential image sources to choose from
+   * @param multiplier the area of the view will be multiplied by this number before calculating the
+   *   best source; this is useful if the image will be displayed bigger than the view (e.g. zoomed)
+   */
+  @JvmStatic
+  public fun getBestSourceForSize(
+      width: Int,
+      height: Int,
+      sources: List<ImageSource>,
+      multiplier: Double
+  ): MultiSourceResult {
+    // no sources
+    if (sources.isEmpty()) {
+      return MultiSourceResult(null, null)
+    }
+
+    // single source
+    if (sources.size == 1) {
+      return MultiSourceResult(sources[0], null)
+    }
+
+    // For multiple sources, we first need the view's size in order to determine the best source to
+    // load. If we haven't been measured yet, return null and wait for onSizeChanged.
+    if (width <= 0 || height <= 0) {
+      return MultiSourceResult(null, null)
+    }
+    val imagePipeline = ImagePipelineFactory.getInstance().imagePipeline
+    var best: ImageSource? = null
+    var bestCached: ImageSource? = null
+    val viewArea = width * height * multiplier
+    var bestPrecision = Double.MAX_VALUE
+    var bestCachePrecision = Double.MAX_VALUE
+    for (source in sources) {
+      val precision = Math.abs(1.0 - source.size / viewArea)
+      if (precision < bestPrecision) {
+        bestPrecision = precision
+        best = source
+      }
+      if (precision < bestCachePrecision &&
+          (imagePipeline.isInBitmapMemoryCache(source.uri) ||
+              imagePipeline.isInDiskCacheSync(source.uri))) {
+        bestCachePrecision = precision
+        bestCached = source
+      }
+    }
+    if (bestCached != null && best != null && bestCached.source == best.source) {
+      bestCached = null
+    }
+    return MultiSourceResult(best, bestCached)
+  }
+
+  public class MultiSourceResult(
+      /**
+       * Get the best result overall (closest in size to the view's size). Can be null if there were
+       * no sources to choose from, or if there were more than 1 sources but width/height were 0.
+       */
+      @JvmField public val bestResult: ImageSource?,
+      /**
+       * Get the best result (closest in size to the view's size) that is also in cache. If this
+       * would be the same as the source from [.getBestResult], this will return `null` instead.
+       */
+      @JvmField public val bestResultInCache: ImageSource?
+  )
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/imagehelper/ResourceDrawableIdHelper.kt

@@ -0,0 +1,81 @@
+/*
+ * 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.imagehelper
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import androidx.core.content.res.ResourcesCompat
+import javax.annotation.concurrent.ThreadSafe
+
+/** Helper class for obtaining information about local images. */
+@ThreadSafe
+public class ResourceDrawableIdHelper private constructor() {
+  private val resourceDrawableIdMap: MutableMap<String, Int> = HashMap()
+
+  @Synchronized
+  public fun clear() {
+    resourceDrawableIdMap.clear()
+  }
+
+  public fun getResourceDrawableId(context: Context, name: String?): Int {
+    if (name.isNullOrEmpty()) {
+      return 0
+    }
+    val normalizedName = name.lowercase().replace("-", "_")
+
+    // name could be a resource id.
+    try {
+      return normalizedName.toInt()
+    } catch (e: NumberFormatException) {
+      // Do nothing.
+    }
+
+    synchronized(this) {
+      return resourceDrawableIdMap.get(normalizedName) ?: addDrawableId(context, normalizedName)
+    }
+  }
+
+  private fun addDrawableId(context: Context, normalizedName: String): Int {
+    val newId = context.resources.getIdentifier(normalizedName, "drawable", context.packageName)
+    resourceDrawableIdMap[normalizedName] = newId
+    return newId
+  }
+
+  public fun getResourceDrawable(context: Context, name: String?): Drawable? {
+    val resId = getResourceDrawableId(context, name)
+    return if (resId > 0) ResourcesCompat.getDrawable(context.resources, resId, null) else null
+  }
+
+  public fun getResourceDrawableUri(context: Context, name: String?): Uri {
+    val resId = getResourceDrawableId(context, name)
+    return if (resId > 0) {
+      Uri.Builder().scheme(LOCAL_RESOURCE_SCHEME).path(resId.toString()).build()
+    } else {
+      Uri.EMPTY
+    }
+  }
+
+  public companion object {
+    private const val LOCAL_RESOURCE_SCHEME = "res"
+    private val resourceDrawableIdHelper: ResourceDrawableIdHelper = ResourceDrawableIdHelper()
+    @JvmStatic
+    public val instance: ResourceDrawableIdHelper
+      get() = resourceDrawableIdHelper
+
+    /**
+     * We're just re-adding this to reduce a breaking change for libraries in React Native 0.75.
+     *
+     * @deprecated Use instance instead
+     */
+    @Deprecated("Use .instance instead, this API is for backward compat", ReplaceWith("instance"))
+    @JvmName(
+        "DEPRECATED\$getInstance") // We intentionally don't want to expose this accessor to Java.
+    public fun getInstance(): ResourceDrawableIdHelper = instance
+  }
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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.modal
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Point
+import android.view.WindowManager
+
+/** Helper class for Modals. */
+internal object ModalHostHelper {
+  private val MIN_POINT = Point()
+  private val MAX_POINT = Point()
+  private val SIZE_POINT = Point()
+
+  /**
+   * To get the size of the screen, we use information from the WindowManager and default Display.
+   * We don't use DisplayMetricsHolder, or Display#getSize() because they return values that include
+   * the status bar. We only want the values of what will actually be shown on screen. We use
+   * Display#getSize() to determine if the screen is in portrait or landscape. We don't use
+   * getRotation because the 'natural' rotation will be portrait on phones and landscape on tablets.
+   * This should only be called on the native modules/shadow nodes thread.
+   */
+  @Suppress("DEPRECATION")
+  @JvmStatic
+  fun getModalHostSize(context: Context): Point {
+    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    val display = wm.defaultDisplay
+    // getCurrentSizeRange will return the min and max width and height that the window can be
+    display.getCurrentSizeRange(MIN_POINT, MAX_POINT)
+    // getSize will return the dimensions of the screen in its current orientation
+    display.getSize(SIZE_POINT)
+
+    val attrs = intArrayOf(android.R.attr.windowFullscreen)
+    val theme = context.theme
+    val ta = theme.obtainStyledAttributes(attrs)
+    val windowFullscreen = ta.getBoolean(0, false)
+
+    // We need to add the status bar height to the height if we have a fullscreen window,
+    // because Display.getCurrentSizeRange doesn't include it.
+    val resources = context.resources
+    @SuppressLint("DiscouragedApi", "InternalInsetResource")
+    val statusBarId = resources.getIdentifier("status_bar_height", "dimen", "android")
+    var statusBarHeight = 0
+    if (windowFullscreen && statusBarId > 0) {
+      statusBarHeight = resources.getDimension(statusBarId).toInt()
+    }
+
+    return if (SIZE_POINT.x < SIZE_POINT.y) {
+      // If we are vertical the width value comes from min width and height comes from max height
+      Point(MIN_POINT.x, MAX_POINT.y + statusBarHeight)
+    } else {
+      // If we are horizontal the width value comes from max width and height comes from min height
+      Point(MAX_POINT.x, MIN_POINT.y + statusBarHeight)
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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.modal
+
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ReactShadowNodeImpl
+import com.facebook.react.views.modal.ModalHostHelper.getModalHostSize
+
+/**
+ * We implement the Modal by using an Android Dialog. That will fill the entire window of the
+ * application. To get layout to work properly, we need to layout all the elements within the
+ * Modal's inner content view as if they can fill the entire window. To do that, we need to
+ * explicitly set the styleWidth and styleHeight on the LayoutShadowNode of the child of this node
+ * to be the window size. This will then cause the children of the Modal to layout as if they can
+ * fill the window.
+ */
+internal class ModalHostShadowNode : LayoutShadowNode() {
+  /**
+   * We need to set the styleWidth and styleHeight of the one child (represented by the
+   * <View></View> within the <RCTModalHostView></RCTModalHostView> in Modal.js. This needs to fill
+   * the entire window.
+   */
+  override fun addChildAt(child: ReactShadowNodeImpl, i: Int) {
+    super.addChildAt(child, i)
+    val modalSize = getModalHostSize(themedContext)
+    child.setStyleWidth(modalSize.x.toFloat())
+    child.setStyleHeight(modalSize.y.toFloat())
+  }
+}

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

@@ -0,0 +1,149 @@
+/*
+ * 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.modal
+
+import android.content.DialogInterface.OnShowListener
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.ModalHostViewManagerDelegate
+import com.facebook.react.viewmanagers.ModalHostViewManagerInterface
+import com.facebook.react.views.modal.ModalHostHelper.getModalHostSize
+import com.facebook.react.views.modal.ReactModalHostView.OnRequestCloseListener
+
+/** View manager for [ReactModalHostView] components. */
+@ReactModule(name = ReactModalHostManager.REACT_CLASS)
+public class ReactModalHostManager :
+    ViewGroupManager<ReactModalHostView>(), ModalHostViewManagerInterface<ReactModalHostView> {
+  private val delegate: ViewManagerDelegate<ReactModalHostView> = ModalHostViewManagerDelegate(this)
+
+  public override fun getName(): String = REACT_CLASS
+
+  protected override fun createViewInstance(reactContext: ThemedReactContext): ReactModalHostView =
+      ReactModalHostView(reactContext)
+
+  public override fun createShadowNodeInstance(): LayoutShadowNode = ModalHostShadowNode()
+
+  public override fun getShadowNodeClass(): Class<out LayoutShadowNode> =
+      ModalHostShadowNode::class.java
+
+  public override fun onDropViewInstance(view: ReactModalHostView) {
+    super.onDropViewInstance(view)
+    view.onDropInstance()
+  }
+
+  @ReactProp(name = "animationType")
+  public override fun setAnimationType(view: ReactModalHostView, animationType: String?) {
+    if (animationType != null) {
+      view.animationType = animationType
+    }
+  }
+
+  @ReactProp(name = "transparent")
+  public override fun setTransparent(view: ReactModalHostView, transparent: Boolean) {
+    view.transparent = transparent
+  }
+
+  @ReactProp(name = "statusBarTranslucent")
+  public override fun setStatusBarTranslucent(
+    view: ReactModalHostView,
+    statusBarTranslucent: Boolean
+  ) {
+    view.statusBarTranslucent = statusBarTranslucent
+  }
+
+  @ReactProp(name = "hardwareAccelerated")
+  public override fun setHardwareAccelerated(
+    view: ReactModalHostView,
+    hardwareAccelerated: Boolean
+  ) {
+    view.hardwareAccelerated = hardwareAccelerated
+  }
+
+  @ReactProp(name = "visible")
+  public override fun setVisible(view: ReactModalHostView, visible: Boolean) {
+    // iOS only
+  }
+
+  @ReactProp(name = "presentationStyle")
+  public override fun setPresentationStyle(view: ReactModalHostView, value: String?): Unit = Unit
+
+  @ReactProp(name = "animated")
+  public override fun setAnimated(view: ReactModalHostView, value: Boolean): Unit = Unit
+
+  @ReactProp(name = "supportedOrientations")
+  public override fun setSupportedOrientations(
+    view: ReactModalHostView,
+    value: ReadableArray?
+  ): Unit = Unit
+
+  @ReactProp(name = "identifier")
+  public override fun setIdentifier(view: ReactModalHostView, value: Int): Unit = Unit
+
+  protected override fun addEventEmitters(
+      reactContext: ThemedReactContext,
+      view: ReactModalHostView
+  ) {
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+    if (dispatcher != null) {
+      view.onRequestCloseListener = OnRequestCloseListener {
+        dispatcher.dispatchEvent(
+            RequestCloseEvent(UIManagerHelper.getSurfaceId(reactContext), view.id))
+      }
+      view.onShowListener = OnShowListener {
+        dispatcher.dispatchEvent(ShowEvent(UIManagerHelper.getSurfaceId(reactContext), view.id))
+      }
+      view.eventDispatcher = dispatcher
+    }
+  }
+
+  public override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> =
+      (super.getExportedCustomDirectEventTypeConstants() ?: mutableMapOf()).apply {
+        putAll(
+            MapBuilder.builder<String, Any>()
+                .put(
+                    RequestCloseEvent.EVENT_NAME,
+                    MapBuilder.of("registrationName", "onRequestClose"))
+                .put(ShowEvent.EVENT_NAME, MapBuilder.of("registrationName", "onShow")) // iOS only
+                .put("topDismiss", MapBuilder.of("registrationName", "onDismiss")) // iOS only
+                .put(
+                    "topOrientationChange",
+                    MapBuilder.of("registrationName", "onOrientationChange"))
+                .build())
+      }
+
+  protected override fun onAfterUpdateTransaction(view: ReactModalHostView) {
+    super.onAfterUpdateTransaction(view)
+    view.showOrUpdate()
+  }
+
+  public override fun updateState(
+    view: ReactModalHostView,
+    props: ReactStylesDiffMap,
+    stateWrapper: StateWrapper
+  ): Any? {
+    view.stateWrapper = stateWrapper
+    val modalSize = getModalHostSize(view.context)
+    view.updateState(modalSize.x, modalSize.y)
+    return null
+  }
+
+  public override fun getDelegate(): ViewManagerDelegate<ReactModalHostView> = delegate
+
+  public companion object {
+    public const val REACT_CLASS: String = "RCTModalHostView"
+  }
+}