@depup/react-native 0.85.0-depup.1 → 0.86.2-depup.0

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/SurfaceMountingManager.kt

@@ -8,12 +8,16 @@
 package com.facebook.react.fabric.mounting
 
 import android.annotation.SuppressLint
+import android.graphics.Bitmap
+import android.os.SystemClock
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewParent
 import androidx.annotation.AnyThread
 import androidx.annotation.UiThread
+import androidx.collection.MutableIntObjectMap
 import androidx.collection.SparseArrayCompat
+import androidx.core.graphics.drawable.toDrawable
 import com.facebook.common.logging.FLog
 import com.facebook.infer.annotation.ThreadConfined
 import com.facebook.react.bridge.GuardedRunnable
@@ -53,7 +57,10 @@ import java.util.ArrayDeque
 import java.util.LinkedList
 import java.util.Queue
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.Volatile
+import kotlin.concurrent.read
+import kotlin.concurrent.write
 
 /** Returns true if the collection contains [key]. */
 private operator fun <T> SparseArrayCompat<T>.contains(key: Int): Boolean = containsKey(key)
@@ -81,7 +88,20 @@ internal constructor(
   public var context: ThemedReactContext? = reactContext
     private set
 
-  private val tagToViewState: ConcurrentHashMap<Int, ViewState> = ConcurrentHashMap() // any thread
+  private val tagToViewState: ConcurrentHashMap<Int, ViewState>?
+  private val optimizedTagToViewState: MutableIntObjectMap<ViewState>?
+  private val registryLock = ReentrantReadWriteLock()
+
+  init {
+    if (ReactNativeFeatureFlags.useOptimizedViewRegistryOnAndroid()) {
+      tagToViewState = null
+      optimizedTagToViewState = MutableIntObjectMap()
+    } else {
+      tagToViewState = ConcurrentHashMap()
+      optimizedTagToViewState = null
+    }
+  }
+
   private val onViewAttachMountItems: Queue<MountItem> = ArrayDeque()
 
   // These are all non-null, until StopSurface is called
@@ -123,7 +143,7 @@ internal constructor(
       return
     }
 
-    tagToViewState[surfaceId] = ViewState(surfaceId, rootView, rootViewManager, true)
+    registryPut(surfaceId, ViewState(surfaceId, rootView, rootViewManager, true))
 
     val runnable: Runnable =
         object : GuardedRunnable(checkNotNull(context)) {
@@ -187,7 +207,7 @@ internal constructor(
     if (tagSetForStoppedSurface?.containsKey(tag) == true) {
       return true
     }
-    return tagToViewState.containsKey(tag)
+    return registryContains(tag)
   }
 
   @UiThread
@@ -233,7 +253,7 @@ internal constructor(
     // Reset all StateWrapper objects
     // Since this can happen on any thread, is it possible to race between StateWrapper destruction
     // and some accesses from View classes in the UI thread?
-    for (viewState in tagToViewState.values) {
+    registryForEachValue { viewState ->
       viewState.stateWrapper?.destroyState()
       viewState.stateWrapper = null
 
@@ -245,15 +265,30 @@ internal constructor(
       if (ReactNativeFeatureFlags.enableViewRecycling()) {
         viewManagerRegistry?.onSurfaceStopped(surfaceId)
       }
-      val tagSetForStoppedSurface =
-          SparseArrayCompat<Any>().also { this.tagSetForStoppedSurface = it }
-      for ((key, value) in tagToViewState) {
-        // Using this as a placeholder value in the map. We're using SparseArrayCompat
-        // since it can efficiently represent the list of pending tags
-        tagSetForStoppedSurface[key] = this
-
-        // We must call `onDropViewInstance` on all remaining Views
-        onViewStateDeleted(value)
+
+      if (optimizedTagToViewState != null) {
+        val viewStatesToDelete: ArrayList<ViewState>
+        registryLock.write {
+          val tagSetForStoppedSurface =
+              SparseArrayCompat<Any>().also { this.tagSetForStoppedSurface = it }
+          viewStatesToDelete = ArrayList(optimizedTagToViewState.size)
+          optimizedTagToViewState.forEach { key, value ->
+            tagSetForStoppedSurface[key] = this@SurfaceMountingManager
+            viewStatesToDelete.add(value)
+          }
+          optimizedTagToViewState.clear()
+        }
+        for (viewState in viewStatesToDelete) {
+          onViewStateDeleted(viewState)
+        }
+      } else {
+        val tagSetForStoppedSurface =
+            SparseArrayCompat<Any>().also { this.tagSetForStoppedSurface = it }
+        for ((key, value) in tagToViewState!!) {
+          tagSetForStoppedSurface[key] = this
+          onViewStateDeleted(value)
+        }
+        tagToViewState!!.clear()
       }
 
       // Evict all views from cache and memory
@@ -261,7 +296,6 @@ internal constructor(
       rootViewManager = null
       mountItemExecutor = null
       context = null
-      tagToViewState.clear()
       onViewAttachMountItems.clear()
       tagToSynchronousMountProps.clear()
       FLog.e(TAG, "Surface [$surfaceId] was stopped on SurfaceMountingManager.")
@@ -281,7 +315,14 @@ internal constructor(
       return
     }
 
-    val parentViewState = getViewState(parentTag)
+    val parentViewState = getNullableViewState(parentTag)
+    if (parentViewState == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.SURFACE_MOUNTING_MANAGER_MISSING_VIEWSTATE,
+          ReactNoCrashSoftException("Unable to find viewState for tag: [$parentTag] for addViewAt"),
+      )
+      return
+    }
     if (parentViewState.view !is ViewGroup) {
       val message =
           "Unable to add a view into a view that is not a ViewGroup. ParentTag: $parentTag - Tag: $tag - Index: $index"
@@ -289,7 +330,14 @@ internal constructor(
       throw IllegalStateException(message)
     }
     val parentView = parentViewState.view as ViewGroup
-    val viewState = getViewState(tag)
+    val viewState = getNullableViewState(tag)
+    if (viewState == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.SURFACE_MOUNTING_MANAGER_MISSING_VIEWSTATE,
+          ReactNoCrashSoftException("Unable to find viewState for tag: [$tag] for addViewAt"),
+      )
+      return
+    }
     val view = viewState.view
     checkNotNull(view) { "Unable to find view for viewState $viewState and tag $tag" }
 
@@ -555,7 +603,7 @@ internal constructor(
             this.stateWrapper = stateWrapper
             this.eventEmitter = eventEmitterWrapper
           }
-      tagToViewState[reactTag] = viewState
+      registryPut(reactTag, viewState)
 
       if (isLayoutable) {
         @Suppress("UNCHECKED_CAST")
@@ -578,14 +626,15 @@ internal constructor(
 
   public fun storeSynchronousMountPropsOverride(reactTag: Int, props: ReadableMap): Unit {
     if (ReactNativeFeatureFlags.overrideBySynchronousMountPropsAtMountingAndroid()) {
-      val propsMap = getMapFromPropsReadableMap(props)
-      var synchronousMountProps = tagToSynchronousMountProps[reactTag]
-      if (synchronousMountProps != null) {
-        synchronousMountProps.putAll(propsMap)
+      val propsMap = getAnimatedPropsMap(props)
+      val synchronousMountProps = tagToSynchronousMountProps[reactTag] ?: mutableMapOf()
+      clearAnimatedNullPropsMapKeys(props, synchronousMountProps)
+      synchronousMountProps.putAll(propsMap)
+      if (synchronousMountProps.isEmpty()) {
+        tagToSynchronousMountProps.remove(reactTag)
       } else {
-        synchronousMountProps = propsMap
+        tagToSynchronousMountProps[reactTag] = synchronousMountProps
       }
-      tagToSynchronousMountProps[reactTag] = synchronousMountProps
     }
   }
 
@@ -607,7 +656,14 @@ internal constructor(
       return
     }
 
-    val viewState = getViewState(reactTag)
+    val viewState = getNullableViewState(reactTag)
+    if (viewState == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.SURFACE_MOUNTING_MANAGER_MISSING_VIEWSTATE,
+          ReactNoCrashSoftException("Unable to find viewState for tag $reactTag for updateProps"),
+      )
+      return
+    }
 
     if (
         ReactNativeFeatureFlags.overrideBySynchronousMountPropsAtMountingAndroid() &&
@@ -623,7 +679,7 @@ internal constructor(
       viewState.currentProps = ReactStylesDiffMap(props)
     }
 
-    val view: View = checkNotNull(viewState.view) { "Unable to find view for tag [$reactTag]" }
+    val view: View = viewState.view ?: return
     checkNotNull(viewState.viewManager).updateProperties(view, viewState.currentProps)
   }
 
@@ -738,13 +794,20 @@ internal constructor(
       return
     }
 
-    val viewState = getViewState(reactTag)
+    val viewState = getNullableViewState(reactTag)
+    if (viewState == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.SURFACE_MOUNTING_MANAGER_MISSING_VIEWSTATE,
+          ReactNoCrashSoftException("Unable to find viewState for tag $reactTag for updateLayout"),
+      )
+      return
+    }
     // Do not layout Root Views
     if (viewState.isRoot) {
       return
     }
 
-    val viewToUpdate = checkNotNull(viewState.view) { "Unable to find View for tag: $reactTag" }
+    val viewToUpdate = viewState.view ?: return
 
     viewToUpdate.layoutDirection =
         when (layoutDirection) {
@@ -890,13 +953,19 @@ internal constructor(
       return
     }
 
-    var viewState = tagToViewState[reactTag]
-    if (viewState == null) {
-      // TODO T62717437 - Use a flag to determine that these event emitters belong to virtual nodes
-      // only.
-      viewState = ViewState(reactTag)
-      tagToViewState[reactTag] = viewState
-    }
+    // TODO T62717437 - Use a flag to determine that these event emitters belong to virtual nodes
+    // only.
+    val viewState: ViewState =
+        if (optimizedTagToViewState != null) {
+          registryLock.write { optimizedTagToViewState.getOrPut(reactTag) { ViewState(reactTag) } }
+        } else {
+          var vs = tagToViewState!![reactTag]
+          if (vs == null) {
+            vs = ViewState(reactTag)
+            tagToViewState!![reactTag] = vs
+          }
+          vs
+        }
     val previousEventEmitterWrapper = viewState.eventEmitter
     viewState.eventEmitter = eventEmitter
 
@@ -1001,14 +1070,14 @@ internal constructor(
       // If the view that went offscreen is still being touched, we can't delete it yet.
       // We have to delay the deletion till the touch is completed.
       // This is causing bugs like those otherwise:
-      // - https://github.com/facebook/react-native/issues/44610
-      // - https://github.com/facebook/react-native/issues/45126
+      // - https://github.com/react/react-native/issues/44610
+      // - https://github.com/react/react-native/issues/45126
       viewsToDeleteAfterTouchFinishes.add(reactTag)
     } else {
       // To delete we simply remove the tag from the registry.
       // We want to rely on the correct set of MountInstructions being sent to the platform,
       // or StopSurface being called, so we do not handle deleting descendants of the View.
-      tagToViewState.remove(reactTag)
+      registryRemove(reactTag)
 
       onViewStateDeleted(viewState)
     }
@@ -1053,16 +1122,63 @@ internal constructor(
   }
 
   private fun getViewState(reactTag: Int): ViewState =
-      tagToViewState[reactTag]
+      registryGet(reactTag)
           ?: throw RetryableMountingLayerException(
               "Unable to find viewState for tag $reactTag. Surface stopped: $isStopped"
           )
 
-  private fun getNullableViewState(reactTag: Int): ViewState? = tagToViewState[reactTag]
+  private fun getNullableViewState(reactTag: Int): ViewState? = registryGet(reactTag)
+
+  private fun registryGet(tag: Int): ViewState? {
+    return if (optimizedTagToViewState != null) {
+      registryLock.read { optimizedTagToViewState[tag] }
+    } else {
+      tagToViewState!![tag]
+    }
+  }
+
+  private fun registryPut(tag: Int, state: ViewState) {
+    if (optimizedTagToViewState != null) {
+      registryLock.write { optimizedTagToViewState[tag] = state }
+    } else {
+      tagToViewState!![tag] = state
+    }
+  }
+
+  private fun registryRemove(tag: Int) {
+    if (optimizedTagToViewState != null) {
+      registryLock.write { optimizedTagToViewState.remove(tag) }
+    } else {
+      tagToViewState!!.remove(tag)
+    }
+  }
+
+  private fun registryContains(tag: Int): Boolean {
+    return if (optimizedTagToViewState != null) {
+      registryLock.read { optimizedTagToViewState.containsKey(tag) }
+    } else {
+      tagToViewState!!.containsKey(tag)
+    }
+  }
+
+  private inline fun registryForEachValue(action: (ViewState) -> Unit) {
+    if (optimizedTagToViewState != null) {
+      registryLock.read { optimizedTagToViewState.forEachValue(action) }
+    } else {
+      tagToViewState!!.values.forEach(action)
+    }
+  }
+
+  /** Applies a bitmap as the background of the view with the given tag, if it exists. */
+  @UiThread
+  public fun applyViewSnapshot(tag: Int, bitmap: Bitmap) {
+    val view = getNullableViewState(tag)?.view ?: return
+    view.background = bitmap.toDrawable(view.resources)
+  }
 
   public fun printSurfaceState(): Unit {
     FLog.e(TAG, "Views created for surface $surfaceId:")
-    for (viewState in tagToViewState.values) {
+    registryForEachValue { viewState ->
       val viewManagerName = viewState.viewManager?.name
       val view = viewState.view
       val parent = if (view != null) view.parent as View? else null
@@ -1082,17 +1198,37 @@ internal constructor(
       canCoalesceEvent: Boolean,
       params: WritableMap?,
       @EventCategoryDef eventCategory: Int,
+  ): Unit {
+    enqueuePendingEvent(
+        reactTag,
+        eventName,
+        canCoalesceEvent,
+        params,
+        eventCategory,
+        SystemClock.uptimeMillis(),
+    )
+  }
+
+  @AnyThread
+  public fun enqueuePendingEvent(
+      reactTag: Int,
+      eventName: String,
+      canCoalesceEvent: Boolean,
+      params: WritableMap?,
+      @EventCategoryDef eventCategory: Int,
+      eventTimestamp: Long,
   ): Unit {
     // When the surface stopped we will reset the view state map. We are not going to enqueue
     // pending events as they are not expected to be dispatched anyways.
-    val viewState = tagToViewState[reactTag]
+    val viewState = registryGet(reactTag)
 
     if (viewState == null) {
       // Cannot queue event without view state. Do nothing here.
       return
     }
 
-    val viewEvent = PendingViewEvent(eventName, params, eventCategory, canCoalesceEvent)
+    val viewEvent =
+        PendingViewEvent(eventName, params, eventCategory, canCoalesceEvent, eventTimestamp)
     UiThreadUtil.runOnUiThread {
       val eventEmitter = viewState.eventEmitter
       if (eventEmitter != null) {
@@ -1145,12 +1281,13 @@ internal constructor(
       private val params: WritableMap?,
       @field:EventCategoryDef private val eventCategory: Int,
       private val canCoalesceEvent: Boolean,
+      private val eventTimestamp: Long,
   ) {
     fun dispatch(eventEmitter: EventEmitterWrapper) {
       if (canCoalesceEvent) {
-        eventEmitter.dispatchUnique(eventName, params)
+        eventEmitter.dispatchUnique(eventName, params, eventTimestamp)
       } else {
-        eventEmitter.dispatch(eventName, params, eventCategory)
+        eventEmitter.dispatch(eventName, params, eventCategory, eventTimestamp)
       }
     }
   }
@@ -1192,7 +1329,11 @@ internal constructor(
       for ((propKey, propValue) in patchMap) {
         if (outputReadableMap.hasKey(propKey)) {
           if (propKey == PROP_TRANSFORM) {
-            assert(outputReadableMap.getType(propKey) == ReadableType.Array && propValue is List<*>)
+            val outputType = outputReadableMap.getType(propKey)
+            assert(
+                (outputType == ReadableType.Array || outputType == ReadableType.Null) &&
+                    propValue is List<*>
+            )
             val array = WritableNativeArray()
             for (item in propValue as List<*>) {
               if (item is Map<*, *>) {
@@ -1210,14 +1351,18 @@ internal constructor(
             }
             outputReadableMap.putArray(propKey, array)
           } else if (propKey == PROP_OPACITY) {
-            assert(outputReadableMap.getType(propKey) == ReadableType.Number && propValue is Number)
+            val outputType = outputReadableMap.getType(propKey)
+            assert(
+                (outputType == ReadableType.Number || outputType == ReadableType.Null) &&
+                    propValue is Number
+            )
             outputReadableMap.putDouble(propKey, (propValue as Number).toDouble())
           }
         }
       }
     }
 
-    private fun getMapFromPropsReadableMap(readableMap: ReadableMap): MutableMap<String, Any> {
+    private fun getAnimatedPropsMap(readableMap: ReadableMap): MutableMap<String, Any> {
       val outputMap = mutableMapOf<String, Any>()
 
       if (
@@ -1247,6 +1392,25 @@ internal constructor(
       return outputMap
     }
 
+    private fun clearAnimatedNullPropsMapKeys(
+        readableMap: ReadableMap,
+        outputMap: MutableMap<String, Any>,
+    ) {
+      // Native Animated uses synchronous null updates to restore animated-managed props.
+      // Keep this scoped to props stored by this override path today.
+      if (
+          readableMap.hasKey(PROP_TRANSFORM) &&
+              readableMap.getType(PROP_TRANSFORM) == ReadableType.Null
+      ) {
+        outputMap.remove(PROP_TRANSFORM)
+      }
+      if (
+          readableMap.hasKey(PROP_OPACITY) && readableMap.getType(PROP_OPACITY) == ReadableType.Null
+      ) {
+        outputMap.remove(PROP_OPACITY)
+      }
+    }
+
     // prevents unchecked conversion warn of the <ViewGroup> type
     private fun getViewGroupManager(viewState: ViewState): IViewGroupManager<View> {
       val viewManager =

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/mountitems/PreAllocateViewMountItem.kt

@@ -59,7 +59,7 @@ internal class PreAllocateViewMountItem(
     if (FabricUIManager.IS_DEVELOPMENT_ENVIRONMENT) {
       result
           .append(" props: ")
-          .append(props?.toString() ?: "<null>")
+          .append(props.toString() ?: "<null>")
           .append(" state: ")
           .append(stateWrapper?.toString() ?: "<null>")
     }

package/ReactAndroid/src/main/java/com/facebook/react/interfaces/ExtraWindowEventListener.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.interfaces
+
+import android.view.Window
+
+/**
+ * Listener for receiving extra window creation and destruction events.
+ *
+ * This allows modules to react to new windows being added or removed, such as Dialog windows
+ * registered by Modal components. Modules like StatusBarModule can implement this interface to
+ * apply their configuration to all active windows.
+ *
+ * Third-party libraries can both implement this listener and emit window events through
+ * [ReactContext.onExtraWindowCreate] and [ReactContext.onExtraWindowDestroy].
+ */
+public interface ExtraWindowEventListener {
+
+  /** Called when a new [Window] is created (e.g. a Dialog window for a Modal). */
+  public fun onExtraWindowCreate(window: Window)
+
+  /** Called when a [Window] is destroyed (e.g. on Dialog window dismiss). */
+  public fun onExtraWindowDestroy(window: Window)
+}