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

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/ReactEventEmitter.kt

@@ -0,0 +1,130 @@
+/*
+ * 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.
+ */
+
+// RCTEventEmitter usage throughout:
+@file:Suppress("DEPRECATION")
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactNoCrashSoftException
+import com.facebook.react.bridge.ReactSoftExceptionLogger.logSoftException
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
+
+internal class ReactEventEmitter(private val reactContext: ReactApplicationContext) :
+    RCTModernEventEmitter {
+  /** Corresponds to [com.facebook.react.fabric.events.FabricEventEmitter] */
+  private var fabricEventEmitter: RCTModernEventEmitter? = null
+
+  /** Corresponds to (Paper) EventEmitter, which is a JS interface */
+  private var defaultEventEmitter: RCTEventEmitter? = null
+
+  fun register(@UIManagerType uiManagerType: Int, eventEmitter: RCTModernEventEmitter?) {
+    check(uiManagerType == UIManagerType.FABRIC)
+    fabricEventEmitter = eventEmitter
+  }
+
+  fun register(@UIManagerType uiManagerType: Int, eventEmitter: RCTEventEmitter?) {
+    check(uiManagerType == UIManagerType.DEFAULT)
+    defaultEventEmitter = eventEmitter
+  }
+
+  fun unregister(@UIManagerType uiManagerType: Int) {
+    if (uiManagerType == UIManagerType.DEFAULT) {
+      defaultEventEmitter = null
+    } else {
+      fabricEventEmitter = null
+    }
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveEvent(targetTag: Int, eventName: String, params: WritableMap?) {
+    receiveEvent(-1, targetTag, eventName, params)
+  }
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      params: WritableMap?
+  ) {
+    // We assume this event can't be coalesced. `customCoalesceKey` has no meaning in Fabric.
+    receiveEvent(surfaceId, targetTag, eventName, false, 0, params, EventCategoryDef.UNSPECIFIED)
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveTouches(
+      eventName: String,
+      touches: WritableArray,
+      changedIndices: WritableArray
+  ) {
+    /*
+     * This method should be unused by default processing pipeline, but leaving it here to make sure
+     * that any custom code using it in legacy renderer is compatible
+     */
+    check(touches.size() > 0)
+
+    val reactTag = touches.getMap(0)?.getInt(TouchesHelper.TARGET_KEY) ?: 0
+    @UIManagerType val uiManagerType = getUIManagerType(reactTag)
+    if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.receiveTouches(eventName, touches, changedIndices)
+    }
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveTouches(event: TouchEvent) {
+    @UIManagerType val uiManagerType = getUIManagerType(event.viewTag, event.surfaceId)
+    if (uiManagerType == UIManagerType.FABRIC) {
+      fabricEventEmitter?.let { TouchesHelper.sendTouchEvent(it, event) }
+    } else if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.let { TouchesHelper.sendTouchesLegacy(it, event) }
+    }
+  }
+
+  /**
+   * Get default/Paper event emitter. Callers should have verified that this is not an event for a
+   * View managed by Fabric
+   */
+  private fun ensureDefaultEventEmitter(): RCTEventEmitter? {
+    if (defaultEventEmitter == null) {
+      if (reactContext.hasActiveReactInstance()) {
+        defaultEventEmitter = reactContext.getJSModule(RCTEventEmitter::class.java)
+      } else {
+        logSoftException(
+            TAG,
+            ReactNoCrashSoftException(
+                "Cannot get RCTEventEmitter from Context, no active Catalyst instance!"))
+      }
+    }
+    return defaultEventEmitter
+  }
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      canCoalesceEvent: Boolean,
+      customCoalesceKey: Int,
+      params: WritableMap?,
+      @EventCategoryDef category: Int
+  ) {
+    @UIManagerType val uiManagerType = getUIManagerType(targetTag, surfaceId)
+    if (uiManagerType == UIManagerType.FABRIC) {
+      fabricEventEmitter?.receiveEvent(
+          surfaceId, targetTag, eventName, canCoalesceEvent, customCoalesceKey, params, category)
+    } else if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.receiveEvent(targetTag, eventName, params)
+    }
+  }
+
+  companion object {
+    private const val TAG = "ReactEventEmitter"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/TouchEvent.kt

@@ -126,7 +126,7 @@ public class TouchEvent private constructor() : Event<TouchEvent>() {
     }
   }
 
-  protected override fun getEventCategory(): Int {
+  public override fun getEventCategory(): Int {
     val type = touchEventType ?: return EventCategoryDef.UNSPECIFIED
     return when (type) {
       TouchEventType.START -> EventCategoryDef.CONTINUOUS_START

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/TouchEventCoalescingKeyHelper.kt

@@ -0,0 +1,77 @@
+/*
+ * 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.uimanager.events
+
+import android.util.SparseIntArray
+
+/**
+ * Utility for determining coalescing keys for TouchEvents. To preserve proper ordering of events,
+ * move events should only be coalesced if there has been no up/down event between them (this
+ * basically only applies to multitouch since for single touches an up would signal the end of the
+ * gesture). To illustrate to kind of coalescing we want, imagine we are coalescing the following
+ * touch stream:
+ *
+ * (U = finger up, D = finger down, M = move) D MMMMM D MMMMMMMMMMMMMM U MMMMM D MMMMMM U U
+ *
+ * We want to make sure to coalesce this as
+ *
+ * D M D M U M D U U
+ *
+ * and *not*
+ *
+ * D D U M D U U
+ *
+ * To accomplish this, this class provides a way to initialize a coalescing key for a gesture and
+ * then increment it for every pointer up/down that occurs during that single gesture.
+ *
+ * We identify a single gesture based on [android.view.MotionEvent.getDownTime] which will stay
+ * constant for a given set of related touches on a single view.
+ *
+ * NB: even though down time is a long, we cast as an int using the least significant bits as the
+ * identifier. In practice, we will not be coalescing over a time range where the most significant
+ * bits of that time range matter. This would require a gesture that lasts Integer.MAX_VALUE * 2 ms,
+ * or ~48 days.
+ *
+ * NB: we assume two gestures cannot begin at the same time.
+ *
+ * NB: this class should only be used from the UI thread.
+ */
+public class TouchEventCoalescingKeyHelper {
+  private val downTimeToCoalescingKey = SparseIntArray()
+
+  /** Starts tracking a new coalescing key corresponding to the gesture with this down time. */
+  public fun addCoalescingKey(downTime: Long) {
+    downTimeToCoalescingKey.put(downTime.toInt(), 0)
+  }
+
+  /** Increments the coalescing key corresponding to the gesture with this down time. */
+  public fun incrementCoalescingKey(downTime: Long) {
+    val currentValue = downTimeToCoalescingKey[downTime.toInt(), -1]
+    if (currentValue == -1) {
+      throw RuntimeException("Tried to increment non-existent cookie")
+    }
+    downTimeToCoalescingKey.put(downTime.toInt(), currentValue + 1)
+  }
+
+  /** Gets the coalescing key corresponding to the gesture with this down time. */
+  public fun getCoalescingKey(downTime: Long): Short {
+    val currentValue = downTimeToCoalescingKey[downTime.toInt(), -1]
+    if (currentValue == -1) {
+      throw RuntimeException("Tried to get non-existent cookie")
+    }
+    return ((0xffff and currentValue).toShort())
+  }
+
+  /** Stops tracking a new coalescing key corresponding to the gesture with this down time. */
+  public fun removeCoalescingKey(downTime: Long) {
+    downTimeToCoalescingKey.delete(downTime.toInt())
+  }
+
+  public fun hasCoalescingKey(downTime: Long): Boolean =
+      downTimeToCoalescingKey[downTime.toInt(), -1] != -1
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/TouchesHelper.kt

@@ -0,0 +1,196 @@
+/*
+ * 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.uimanager.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.events.TouchEventType.Companion.getJSEventName
+import com.facebook.systrace.Systrace
+
+/** Class responsible for generating catalyst touch events based on android [MotionEvent]. */
+public object TouchesHelper {
+  @JvmField @Deprecated("Not used in New Architecture") public val TARGET_KEY: String = "target"
+
+  private const val TARGET_SURFACE_KEY = "targetSurface"
+  private const val CHANGED_TOUCHES_KEY = "changedTouches"
+  private const val TOUCHES_KEY = "touches"
+  private const val PAGE_X_KEY = "pageX"
+  private const val PAGE_Y_KEY = "pageY"
+  private const val TIMESTAMP_KEY = "timestamp"
+  private const val POINTER_IDENTIFIER_KEY = "identifier"
+
+  private const val LOCATION_X_KEY = "locationX"
+  private const val LOCATION_Y_KEY = "locationY"
+
+  /**
+   * Creates catalyst pointers array in format that is expected by RCTEventEmitter JS module from
+   * given {@param event} instance. This method use {@param reactTarget} parameter to set as a
+   * target view id associated with current gesture.
+   */
+  private fun createPointersArray(event: TouchEvent): Array<WritableMap?> {
+    val motionEvent = event.getMotionEvent()
+    val touches = arrayOfNulls<WritableMap>(motionEvent.pointerCount)
+
+    // Calculate the coordinates for the target view.
+    // The MotionEvent contains the X,Y of the touch in the coordinate space of the root view
+    // The TouchEvent contains the X,Y of the touch in the coordinate space of the target view
+    // Subtracting them allows us to get the coordinates of the target view's top left corner
+    // We then use this when computing the view specific touches below
+    // Since only one view is actually handling even multiple touches, the values are all relative
+    // to this one target view.
+    val targetViewCoordinateX = motionEvent.x - event.viewX
+    val targetViewCoordinateY = motionEvent.y - event.viewY
+
+    for (index in 0 until motionEvent.pointerCount) {
+      val touch = Arguments.createMap()
+
+      // pageX,Y values are relative to the RootReactView
+      // the motionEvent already contains coordinates in that view
+      touch.putDouble(PAGE_X_KEY, motionEvent.getX(index).pxToDp().toDouble())
+      touch.putDouble(PAGE_Y_KEY, motionEvent.getY(index).pxToDp().toDouble())
+
+      // locationX,Y values are relative to the target view
+      // To compute the values for the view, we subtract that views location from the event X,Y
+      val locationX = motionEvent.getX(index) - targetViewCoordinateX
+      val locationY = motionEvent.getY(index) - targetViewCoordinateY
+      touch.putDouble(LOCATION_X_KEY, locationX.pxToDp().toDouble())
+      touch.putDouble(LOCATION_Y_KEY, locationY.pxToDp().toDouble())
+
+      touch.putInt(TARGET_SURFACE_KEY, event.surfaceId)
+      @Suppress("DEPRECATION") touch.putInt(TARGET_KEY, event.viewTag)
+      touch.putDouble(TIMESTAMP_KEY, event.timestampMs.toDouble())
+      touch.putDouble(POINTER_IDENTIFIER_KEY, motionEvent.getPointerId(index).toDouble())
+
+      touches[index] = touch
+    }
+
+    return touches
+  }
+
+  /**
+   * Generate and send touch event to RCTEventEmitter JS module associated with the given {@param *
+   * context} for legacy renderer. Touch event can encode multiple concurrent touches (pointers).
+   *
+   * @param rctEventEmitter Event emitter used to execute JS module call
+   * @param touchEvent native touch event to read pointers count and coordinates from
+   */
+  @Suppress("DEPRECATION")
+  @JvmStatic
+  public fun sendTouchesLegacy(rctEventEmitter: RCTEventEmitter, touchEvent: TouchEvent) {
+    val type = touchEvent.getTouchEventType()
+
+    val pointers = getWritableArray(/* copyObjects */ false, createPointersArray(touchEvent))
+    val motionEvent = touchEvent.getMotionEvent()
+
+    // For START and END events send only index of the pointer that is associated with that event
+    // For MOVE and CANCEL events 'changedIndices' array should contain all the pointers indices
+    val changedIndices = Arguments.createArray()
+    if (type == TouchEventType.MOVE || type == TouchEventType.CANCEL) {
+      for (i in 0 until motionEvent.pointerCount) {
+        changedIndices.pushInt(i)
+      }
+    } else if (type == TouchEventType.START || type == TouchEventType.END) {
+      changedIndices.pushInt(motionEvent.actionIndex)
+    } else {
+      throw RuntimeException("Unknown touch type: $type")
+    }
+
+    @Suppress("DEPRECATION")
+    rctEventEmitter.receiveTouches(getJSEventName(type), pointers, changedIndices)
+  }
+
+  /**
+   * Generate touch event data to match JS expectations. Combines logic in [sendTouchEvent] and
+   * [FabricEventEmitter] to create the same data structure in a more efficient manner.
+   *
+   * Touches have to be dispatched as separate events for each changed pointer to make JS process
+   * them correctly. To avoid allocations, we preprocess touch events in Java world and then convert
+   * them to native before dispatch.
+   *
+   * @param eventEmitter emitter to dispatch event to
+   * @param event the touch event to extract data from
+   */
+  @JvmStatic
+  public fun sendTouchEvent(eventEmitter: RCTModernEventEmitter, event: TouchEvent) {
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+        "TouchesHelper.sentTouchEventModern(" + event.eventName + ")")
+    try {
+      val type = event.getTouchEventType()
+      val motionEvent = event.getMotionEvent()
+      var touches = createPointersArray(event)
+      var changedTouches: Array<WritableMap?>? = null
+
+      when (type) {
+        TouchEventType.START -> {
+          val newPointerIndex = motionEvent.actionIndex
+
+          changedTouches = arrayOf(touches[newPointerIndex]?.copy())
+        }
+        TouchEventType.END -> {
+          val finishedPointerIndex = motionEvent.actionIndex
+          /*
+           * Clear finished pointer index for compatibility with W3C touch "end" events, where the
+           * active touches don't include the set that has just been "ended".
+           */
+          val finishedPointer = touches[finishedPointerIndex]
+          touches[finishedPointerIndex] = null
+
+          changedTouches = arrayOf(finishedPointer)
+        }
+        TouchEventType.MOVE -> {
+          changedTouches = arrayOfNulls(touches.size)
+          var i = 0
+          while (i < touches.size) {
+            changedTouches[i] = touches[i]?.copy()
+            i++
+          }
+        }
+        TouchEventType.CANCEL -> {
+          changedTouches = touches
+          touches = arrayOfNulls(0)
+        }
+      }
+
+      for (touchData in changedTouches) {
+        val eventData =
+            touchData?.let { td ->
+              val ed = td.copy()
+              val changedTouchesArray = getWritableArray(/* copyObjects */ true, changedTouches)
+              val touchesArray = getWritableArray(/* copyObjects */ true, touches)
+              ed.putArray(CHANGED_TOUCHES_KEY, changedTouchesArray)
+              ed.putArray(TOUCHES_KEY, touchesArray)
+              ed
+            }
+
+        eventEmitter.receiveEvent(
+            event.surfaceId,
+            event.viewTag,
+            event.eventName,
+            event.canCoalesce(),
+            0,
+            eventData,
+            event.eventCategory)
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+    }
+  }
+
+  private fun getWritableArray(copyObjects: Boolean, objects: Array<WritableMap?>): WritableArray {
+    val result = Arguments.createArray()
+    for (obj in objects) {
+      if (obj != null) {
+        result.pushMap(if (copyObjects) obj.copy() else obj)
+      }
+    }
+    return result
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/style/BorderRadiusStyle.kt

@@ -178,33 +178,32 @@ public data class BorderRadiusStyle(
       width: Float,
       height: Float
   ): ComputedBorderRadius {
-    val leftInset = topLeft.horizontal + bottomLeft.horizontal
-    val topInset = topLeft.vertical + topRight.vertical
-    val rightInset = topRight.horizontal + bottomRight.horizontal
-    val bottomInset = bottomLeft.vertical + bottomRight.vertical
+    val leftEdgeRadii = topLeft.vertical + bottomLeft.vertical
+    val topEdgeRadii = topLeft.horizontal + topRight.horizontal
+    val rightEdgeRadii = topRight.vertical + bottomRight.vertical
+    val bottomEdgeRadii = bottomLeft.horizontal + bottomRight.horizontal
 
-    val leftInsetScale = if (leftInset > 0) minOf(1.0f, height / leftInset) else 0f
-    val topInsetScale = if (topInset > 0) minOf(1.0f, width / topInset) else 0f
-    val rightInsetScale = if (rightInset > 0) minOf(1.0f, height / rightInset) else 0f
-    val bottomInsetScale = if (bottomInset > 0) minOf(1.0f, width / bottomInset) else 0f
+    val leftEdgeRadiiScale = if (leftEdgeRadii > 0) minOf(height / leftEdgeRadii, 1f) else 0f
+    val topEdgeRadiiScale = if (topEdgeRadii > 0) minOf(width / topEdgeRadii, 1f) else 0f
+    val rightEdgeRadiiScale = if (rightEdgeRadii > 0) minOf(height / rightEdgeRadii, 1f) else 0f
+    val bottomEdgeRadiiScale = if (bottomEdgeRadii > 0) minOf(width / bottomEdgeRadii, 1f) else 0f
 
     return ComputedBorderRadius(
         topLeft =
             CornerRadii(
-                topLeft.horizontal * minOf(topInsetScale, leftInsetScale),
-                topLeft.vertical * minOf(topInsetScale, leftInsetScale)),
+                topLeft.horizontal * minOf(topEdgeRadiiScale, leftEdgeRadiiScale),
+                topLeft.vertical * minOf(topEdgeRadiiScale, leftEdgeRadiiScale)),
         topRight =
             CornerRadii(
-                topRight.horizontal * minOf(topInsetScale, rightInsetScale),
-                topRight.vertical * minOf(topInsetScale, rightInsetScale)),
+                topRight.horizontal * minOf(rightEdgeRadiiScale, topEdgeRadiiScale),
+                topRight.vertical * minOf(rightEdgeRadiiScale, topEdgeRadiiScale)),
         bottomLeft =
             CornerRadii(
-                bottomLeft.horizontal * minOf(bottomInsetScale, leftInsetScale),
-                bottomLeft.vertical * minOf(bottomInsetScale, leftInsetScale)),
+                bottomLeft.horizontal * minOf(bottomEdgeRadiiScale, leftEdgeRadiiScale),
+                bottomLeft.vertical * minOf(bottomEdgeRadiiScale, leftEdgeRadiiScale)),
         bottomRight =
             CornerRadii(
-                bottomRight.horizontal * minOf(bottomInsetScale, rightInsetScale),
-                bottomRight.vertical * minOf(bottomInsetScale, rightInsetScale)),
-    )
+                bottomRight.horizontal * minOf(bottomEdgeRadiiScale, rightEdgeRadiiScale),
+                bottomRight.vertical * minOf(bottomEdgeRadiiScale, rightEdgeRadiiScale)))
   }
 }

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

@@ -93,6 +93,11 @@ public class ReactModalHostManager :
   @ReactProp(name = "identifier")
   public override fun setIdentifier(view: ReactModalHostView, value: Int): Unit = Unit
 
+  public override fun setTestId(view: ReactModalHostView, value: String?) {
+    super.setTestId(view, value)
+    view.setDialogRootViewGroupTestId(value)
+  }
+
   protected override fun addEventEmitters(
       reactContext: ThemedReactContext,
       view: ReactModalHostView

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

@@ -25,10 +25,12 @@ import android.view.Window
 import android.view.WindowInsetsController
 import android.view.WindowManager
 import android.view.accessibility.AccessibilityEvent
+import android.view.accessibility.AccessibilityNodeInfo
 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
@@ -213,6 +215,15 @@ public class ReactModalHostView(context: ThemedReactContext) :
 
   private fun getCurrentActivity(): Activity? = (context as ThemedReactContext).currentActivity
 
+  private fun isFlagSecureSet(activity: Activity?): Boolean {
+    if (activity == null) {
+      return false
+    }
+
+    val flags = activity.window.attributes.flags
+    return (flags and WindowManager.LayoutParams.FLAG_SECURE) != 0
+  }
+
   /**
    * showOrUpdate will display the Dialog. It is called by the manager once all properties are set
    * because we need to know all of them before creating the Dialog. It is also smart during updates
@@ -275,12 +286,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
           }
         })
@@ -289,6 +319,11 @@ public class ReactModalHostView(context: ThemedReactContext) :
     if (hardwareAccelerated) {
       newDialog.window?.addFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED)
     }
+    val flagSecureSet = isFlagSecureSet(currentActivity)
+    if (flagSecureSet) {
+      newDialog.window?.setFlags(
+          WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE)
+    }
     if (currentActivity?.isFinishing == false) {
       newDialog.show()
       updateSystemAppearance()
@@ -377,6 +412,15 @@ public class ReactModalHostView(context: ThemedReactContext) :
     }
   }
 
+  /**
+   * Sets the testID on the DialogRootViewGroup. Since the accessibility events are not triggered on
+   * the on the ReactModalHostView, the testID is forwarded to the DialogRootViewGroup to set the
+   * resource-id.
+   */
+  public fun setDialogRootViewGroupTestId(testId: String?) {
+    dialogRootViewGroup.setTag(R.id.react_test_id, testId)
+  }
+
   // This listener is called when the user presses KeyEvent.KEYCODE_BACK
   // An event is then passed to JS which can either close or not close the Modal by setting the
   // visible property
@@ -417,6 +461,15 @@ public class ReactModalHostView(context: ThemedReactContext) :
       }
     }
 
+    override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
+      super.onInitializeAccessibilityNodeInfo(info)
+
+      val testId = getTag(R.id.react_test_id) as String?
+      if (testId != null) {
+        info.viewIdResourceName = testId
+      }
+    }
+
     override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
       super.onSizeChanged(w, h, oldw, oldh)
       viewWidth = w
@@ -521,7 +574,7 @@ public class ReactModalHostView(context: ThemedReactContext) :
       return super.onHoverEvent(event)
     }
 
-    override fun onChildStartedNativeGesture(childView: View, ev: MotionEvent) {
+    override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
       eventDispatcher?.let { eventDispatcher ->
         jSTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher)
         jSPointerDispatcher?.onChildStartedNativeGesture(childView, ev, eventDispatcher)

package/ReactAndroid/src/main/java/com/facebook/react/views/progressbar/ProgressBarContainerView.kt

@@ -10,8 +10,10 @@ package com.facebook.react.views.progressbar
 import android.content.Context
 import android.graphics.PorterDuff
 import android.view.ViewGroup
+import android.view.accessibility.AccessibilityNodeInfo
 import android.widget.FrameLayout
 import android.widget.ProgressBar
+import com.facebook.react.R
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException
 
 /**
@@ -27,6 +29,15 @@ internal class ProgressBarContainerView(context: Context) : FrameLayout(context)
 
   private var progressBar: ProgressBar? = null
 
+  override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
+    super.onInitializeAccessibilityNodeInfo(info)
+
+    val testId = getTag(R.id.react_test_id) as String?
+    if (testId != null) {
+      info.viewIdResourceName = testId
+    }
+  }
+
   internal fun apply() {
     this.progressBar?.let { progressBar ->
       progressBar.isIndeterminate = indeterminate

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/{FpsListener.java → FpsListener.kt}

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.views.scroll;
+package com.facebook.react.views.scroll
 
 public interface FpsListener {
 
@@ -14,7 +14,7 @@ public interface FpsListener {
    *
    * @param tag
    */
-  void enable(String tag);
+  public fun enable(tag: String)
 
   /**
    * Clients should call this method when they want the listener to stop recording data. The
@@ -24,8 +24,8 @@ public interface FpsListener {
    *
    * @param tag
    */
-  void disable(String tag);
+  public fun disable(tag: String)
 
   /** Reports whether this listener is recording data. */
-  boolean isEnabled();
+  public fun isEnabled(): Boolean
 }