react-native-tvos 0.77.1-0 → 0.78.0-0

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,6 +25,7 @@ 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
@@ -214,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
@@ -309,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()
@@ -397,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
@@ -437,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
@@ -541,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
 }

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

@@ -26,6 +26,7 @@ import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityNodeInfo;
 import android.widget.HorizontalScrollView;
 import android.widget.OverScroller;
 import androidx.annotation.Nullable;
@@ -33,6 +34,7 @@ import androidx.core.view.ViewCompat;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.R;
 import com.facebook.react.animated.NativeAnimatedModule;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.common.ReactConstants;
@@ -143,6 +145,20 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     setClipChildren(false);
   }
 
+  @Override
+  public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+    super.onInitializeAccessibilityNodeInfo(info);
+
+    // Expose the testID prop as the resource-id name of the view. Black-box E2E/UI testing
+    // frameworks, which interact with the UI through the accessibility framework, do not have
+    // access to view tags. This allows developers/testers to avoid polluting the
+    // content-description with test identifiers.
+    final String testId = (String) this.getTag(R.id.react_test_id);
+    if (testId != null) {
+      info.setViewIdResourceName(testId);
+    }
+  }
+
   public boolean getScrollEnabled() {
     return mScrollEnabled;
   }

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

@@ -112,7 +112,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   }
 
   @ReactProp(name = "snapToAlignment")
-  public void setSnapToAlignment(ReactHorizontalScrollView view, String alignment) {
+  public void setSnapToAlignment(ReactHorizontalScrollView view, @Nullable String alignment) {
     view.setSnapToAlignment(ReactScrollViewHelper.parseSnapToAlignment(alignment));
   }
 
@@ -169,7 +169,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
    * @param scrollPerfTag
    */
   @ReactProp(name = "scrollPerfTag")
-  public void setScrollPerfTag(ReactHorizontalScrollView view, String scrollPerfTag) {
+  public void setScrollPerfTag(ReactHorizontalScrollView view, @Nullable String scrollPerfTag) {
     view.setScrollPerfTag(scrollPerfTag);
   }
 
@@ -180,7 +180,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
 
   /** Controls overScroll behaviour */
   @ReactProp(name = "overScrollMode")
-  public void setOverScrollMode(ReactHorizontalScrollView view, String value) {
+  public void setOverScrollMode(ReactHorizontalScrollView view, @Nullable String value) {
     view.setOverScrollMode(ReactScrollViewHelper.parseOverScrollMode(value));
   }
 

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

@@ -0,0 +1,136 @@
+/*
+ * 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.scroll
+
+import android.view.View
+import android.view.ViewGroup
+import android.view.accessibility.AccessibilityEvent
+import androidx.core.view.AccessibilityDelegateCompat
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
+import com.facebook.react.R
+import com.facebook.react.bridge.AssertionException
+import com.facebook.react.bridge.ReactSoftExceptionLogger
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ReactAccessibilityDelegate
+import com.facebook.react.uimanager.ReactAccessibilityDelegate.AccessibilityRole
+
+internal class ReactScrollViewAccessibilityDelegate : AccessibilityDelegateCompat() {
+
+  private val TAG: String = ReactScrollViewAccessibilityDelegate::class.java.simpleName
+
+  override fun onInitializeAccessibilityEvent(host: View, event: AccessibilityEvent) {
+    super.onInitializeAccessibilityEvent(host, event)
+    if (host is ReactScrollView || host is ReactHorizontalScrollView) {
+      onInitializeAccessibilityEventInternal(host, event)
+    } else {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          AssertionException(
+              "ReactScrollViewAccessibilityDelegate should only be used with ReactScrollView or ReactHorizontalScrollView, not with class: ${host.javaClass.simpleName}"))
+    }
+  }
+
+  override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
+    super.onInitializeAccessibilityNodeInfo(host, info)
+    if (host is ReactScrollView || host is ReactHorizontalScrollView) {
+      onInitializeAccessibilityNodeInfoInternal(host, info)
+    } else {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          AssertionException(
+              "ReactScrollViewAccessibilityDelegate should only be used with ReactScrollView or ReactHorizontalScrollView, not with class: ${host.javaClass.simpleName}"))
+    }
+  }
+
+  private fun onInitializeAccessibilityEventInternal(view: View, event: AccessibilityEvent) {
+    val accessibilityCollection =
+        view.getTag(R.id.accessibility_collection) as? ReadableMap ?: return
+
+    event.itemCount = accessibilityCollection.getInt("itemCount")
+
+    val contentView = (view as? ViewGroup)?.getChildAt(0) as? ViewGroup ?: return
+
+    var firstVisibleIndex: Int? = null
+    var lastVisibleIndex: Int? = null
+
+    for (index in 0..<contentView.childCount) {
+      val nextChild = contentView.getChildAt(index)
+      val isVisible: Boolean =
+          if (view is ReactScrollView) {
+            view.isPartiallyScrolledInView(nextChild)
+          } else if (view is ReactHorizontalScrollView) {
+            view.isPartiallyScrolledInView(nextChild)
+          } else {
+            return
+          }
+      var accessibilityCollectionItem: ReadableMap? =
+          nextChild.getTag(R.id.accessibility_collection_item) as ReadableMap
+
+      if (nextChild !is ViewGroup) {
+        return
+      }
+
+      // If this child's accessibilityCollectionItem is null, we'll check one more
+      // nested child.
+      // Happens when getItemLayout is not passed in FlatList which adds an additional
+      // View in the hierarchy.
+      if (nextChild.childCount > 0 && accessibilityCollectionItem == null) {
+        val nestedNextChild = nextChild.getChildAt(0)
+        if (nestedNextChild != null) {
+          val nestedChildAccessibility =
+              nestedNextChild.getTag(R.id.accessibility_collection_item) as? ReadableMap
+          if (nestedChildAccessibility != null) {
+            accessibilityCollectionItem = nestedChildAccessibility
+          }
+        }
+      }
+
+      if (isVisible && accessibilityCollectionItem != null) {
+        if (firstVisibleIndex == null) {
+          firstVisibleIndex = accessibilityCollectionItem.getInt("itemIndex")
+        }
+        lastVisibleIndex = accessibilityCollectionItem.getInt("itemIndex")
+      }
+
+      if (firstVisibleIndex != null && lastVisibleIndex != null) {
+        event.fromIndex = firstVisibleIndex
+        event.toIndex = lastVisibleIndex
+      }
+    }
+  }
+
+  private fun onInitializeAccessibilityNodeInfoInternal(
+      view: View,
+      info: AccessibilityNodeInfoCompat
+  ) {
+    val accessibilityRole = AccessibilityRole.fromViewTag(view)
+
+    if (accessibilityRole != null) {
+      ReactAccessibilityDelegate.setRole(info, accessibilityRole, view.context)
+    }
+
+    val accessibilityCollection = view.getTag(R.id.accessibility_collection) as? ReadableMap
+
+    if (accessibilityCollection != null) {
+      val rowCount = accessibilityCollection.getInt("rowCount")
+      val columnCount = accessibilityCollection.getInt("columnCount")
+      val hierarchical = accessibilityCollection.getBoolean("hierarchical")
+
+      val collectionInfoCompat =
+          AccessibilityNodeInfoCompat.CollectionInfoCompat.obtain(
+              rowCount, columnCount, hierarchical)
+      info.setCollectionInfo(collectionInfoCompat)
+    }
+
+    if (view is ReactScrollView) {
+      info.isScrollable = view.scrollEnabled
+    } else if (view is ReactHorizontalScrollView) {
+      info.isScrollable = view.scrollEnabled
+    }
+  }
+}