@depup/react-native 0.85.0-depup.1 → 0.86.0-depup.49

package/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java

@@ -10,14 +10,12 @@ package com.facebook.react;
 import static com.facebook.infer.annotation.ThreadConfined.UI;
 import static com.facebook.react.uimanager.BlendModeHelper.needsIsolatedLayer;
 import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
-import static com.facebook.react.uimanager.common.UIManagerType.LEGACY;
 import static com.facebook.systrace.Systrace.TRACE_TAG_REACT;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.BlendMode;
 import android.graphics.Canvas;
-import android.graphics.Insets;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.Rect;
@@ -25,18 +23,18 @@ import android.os.Build;
 import android.os.Bundle;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
-import android.view.DisplayCutout;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
-import android.view.WindowInsets;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 import androidx.annotation.Nullable;
-import androidx.annotation.RequiresApi;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
@@ -52,6 +50,7 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.common.annotations.internal.LegacyArchitecture;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.appregistry.AppRegistry;
@@ -70,7 +69,6 @@ import com.facebook.react.uimanager.RootView;
 import com.facebook.react.uimanager.RootViewUtil;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.common.UIManagerType;
-import com.facebook.react.uimanager.common.ViewUtil;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.systrace.Systrace;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -117,7 +115,6 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   private int mLastHeight = 0;
   private int mLastOffsetX = Integer.MIN_VALUE;
   private int mLastOffsetY = Integer.MIN_VALUE;
-  private @UIManagerType int mUIManagerType = LEGACY;
   private final AtomicInteger mState = new AtomicInteger(STATE_STOPPED);
 
   public ReactRootView(Context context) {
@@ -308,9 +305,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
 
     BlendMode mixBlendMode = null;
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
-        && ViewUtil.getUIManagerType(this) == UIManagerType.FABRIC
-        && needsIsolatedLayer(this)) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && needsIsolatedLayer(this)) {
       mixBlendMode = (BlendMode) child.getTag(R.id.mix_blend_mode);
       if (mixBlendMode != null) {
         Paint p = new Paint();
@@ -475,7 +470,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   }
 
   private boolean isFabric() {
-    return getUIManagerType() == FABRIC;
+    return true;
   }
 
   @Override
@@ -647,9 +642,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     final ReactContext reactApplicationContext = getCurrentReactContext();
 
     if (reactApplicationContext != null) {
-      @Nullable
-      UIManager uiManager =
-          UIManagerHelper.getUIManager(reactApplicationContext, getUIManagerType());
+      @Nullable UIManager uiManager = UIManagerHelper.getUIManager(reactApplicationContext, FABRIC);
       // Ignore calling updateRootLayoutSpecs if UIManager is not properly initialized.
       if (uiManager != null) {
         // In Fabric only, get position of view within screen
@@ -801,11 +794,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
   @VisibleForTesting
   /* package */ void simulateCheckForKeyboardForTesting() {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      getCustomGlobalLayoutListener().checkForKeyboardEvents();
-    } else {
-      getCustomGlobalLayoutListener().checkForKeyboardEventsLegacy();
-    }
+    getCustomGlobalLayoutListener().checkForKeyboardEvents();
   }
 
   private CustomGlobalLayoutListener getCustomGlobalLayoutListener() {
@@ -868,6 +857,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
             + " or in the onDestroyView() of your hosting Fragment.");
   }
 
+  @Override
   public int getRootViewTag() {
     return mRootViewTag;
   }
@@ -876,6 +866,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     return mRootViewTag != 0 && mRootViewTag != NO_ID;
   }
 
+  @Override
   public void setRootViewTag(int rootViewTag) {
     mRootViewTag = rootViewTag;
   }
@@ -890,15 +881,18 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     getCurrentReactContext().handleException(e);
   }
 
+  @LegacyArchitecture
+  @Deprecated
   public void setIsFabric(boolean isFabric) {
-    mUIManagerType = isFabric ? FABRIC : LEGACY;
+    /* noop */
   }
 
   @Override
   public @UIManagerType int getUIManagerType() {
-    return mUIManagerType;
+    return FABRIC;
   }
 
+  @LegacyArchitecture
   @Nullable
   public ReactInstanceManager getReactInstanceManager() {
     return mReactInstanceManager;
@@ -932,16 +926,14 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
   private class CustomGlobalLayoutListener implements ViewTreeObserver.OnGlobalLayoutListener {
     private final Rect mVisibleViewArea;
-    private final int mMinKeyboardHeightDetected;
 
     private boolean mKeyboardIsVisible = false;
-    private int mKeyboardHeight = 0; // Only used in checkForKeyboardEventsLegacy path
+    private int mKeyboardHeight = 0;
     private int mDeviceRotation = 0;
 
     /* package */ CustomGlobalLayoutListener() {
       DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(getContext().getApplicationContext());
       mVisibleViewArea = new Rect();
-      mMinKeyboardHeightDetected = (int) PixelUtil.toPixelFromDIP(60);
     }
 
     @Override
@@ -950,32 +942,30 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
         return;
       }
 
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        checkForKeyboardEvents();
-      } else {
-        checkForKeyboardEventsLegacy();
-      }
-
+      checkForKeyboardEvents();
       checkForDeviceOrientationChanges();
       checkForDeviceDimensionsChanges();
     }
 
-    @RequiresApi(api = Build.VERSION_CODES.R)
     private void checkForKeyboardEvents() {
       getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
-      WindowInsets rootInsets = getRootView().getRootWindowInsets();
+      WindowInsetsCompat rootInsets = ViewCompat.getRootWindowInsets(getRootView());
       if (rootInsets == null) {
         return;
       }
 
-      boolean keyboardIsVisible = rootInsets.isVisible(WindowInsets.Type.ime());
-      if (keyboardIsVisible != mKeyboardIsVisible) {
-        mKeyboardIsVisible = keyboardIsVisible;
+      boolean keyboardIsVisible = rootInsets.isVisible(WindowInsetsCompat.Type.ime());
+      Insets barInsets = rootInsets.getInsets(WindowInsetsCompat.Type.systemBars());
+
+      if (keyboardIsVisible) {
+        Insets imeInsets = rootInsets.getInsets(WindowInsetsCompat.Type.ime());
+        int height = imeInsets.bottom - barInsets.bottom;
 
-        if (keyboardIsVisible) {
-          Insets imeInsets = rootInsets.getInsets(WindowInsets.Type.ime());
-          Insets barInsets = rootInsets.getInsets(WindowInsets.Type.systemBars());
-          int height = imeInsets.bottom - barInsets.bottom;
+        // Re-emit on height change while keyboard stays visible (e.g., emoji
+        // panel toggle); JS consumers cache endCoordinates from keyboardDidShow.
+        if (!mKeyboardIsVisible || height != mKeyboardHeight) {
+          mKeyboardIsVisible = true;
+          mKeyboardHeight = height;
 
           ViewGroup.LayoutParams rootLayoutParams = getRootView().getLayoutParams();
           Assertions.assertCondition(rootLayoutParams instanceof WindowManager.LayoutParams);
@@ -993,60 +983,15 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
                   PixelUtil.toDIPFromPixel(mVisibleViewArea.left),
                   PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
                   PixelUtil.toDIPFromPixel(height)));
-        } else {
-          sendEvent(
-              "keyboardDidHide",
-              createKeyboardEventPayload(
-                  PixelUtil.toDIPFromPixel(mVisibleViewArea.height()),
-                  0,
-                  PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
-                  0));
         }
-      }
-    }
-
-    private void checkForKeyboardEventsLegacy() {
-      getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
-
-      int notchHeight = 0;
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-        WindowInsets insets = getRootView().getRootWindowInsets();
-        if (insets != null) {
-          DisplayCutout displayCutout = insets.getDisplayCutout();
-          if (displayCutout != null) {
-            notchHeight = displayCutout.getSafeInsetTop();
-          }
-        }
-      }
-      final int heightDiff =
-          DisplayMetricsHolder.getWindowDisplayMetrics().heightPixels
-              - mVisibleViewArea.bottom
-              + notchHeight;
-
-      boolean isKeyboardShowingOrKeyboardHeightChanged =
-          mKeyboardHeight != heightDiff && heightDiff > mMinKeyboardHeightDetected;
-
-      if (isKeyboardShowingOrKeyboardHeightChanged) {
-        mKeyboardHeight = heightDiff;
-        mKeyboardIsVisible = true;
-        sendEvent(
-            "keyboardDidShow",
-            createKeyboardEventPayload(
-                PixelUtil.toDIPFromPixel(mVisibleViewArea.bottom),
-                PixelUtil.toDIPFromPixel(mVisibleViewArea.left),
-                PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
-                PixelUtil.toDIPFromPixel(mKeyboardHeight)));
-        return;
-      }
-
-      boolean isKeyboardHidden = mKeyboardHeight != 0 && heightDiff <= mMinKeyboardHeightDetected;
-      if (isKeyboardHidden) {
-        mKeyboardHeight = 0;
+      } else if (mKeyboardIsVisible) {
         mKeyboardIsVisible = false;
+        mKeyboardHeight = 0;
+
         sendEvent(
             "keyboardDidHide",
             createKeyboardEventPayload(
-                PixelUtil.toDIPFromPixel(mVisibleViewArea.height()),
+                PixelUtil.toDIPFromPixel(mVisibleViewArea.bottom + barInsets.bottom),
                 0,
                 PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
                 0));

package/ReactAndroid/src/main/java/com/facebook/react/animated/EventAnimationDriver.kt

@@ -22,6 +22,7 @@ internal class EventAnimationDriver(
     private val eventPath: List<String>,
     @JvmField internal var valueNode: ValueAnimatedNode,
 ) : RCTModernEventEmitter {
+  @Deprecated("Use the overload with eventTimestamp parameter instead.")
   override fun receiveEvent(
       surfaceId: Int,
       targetTag: Int,

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.kt

@@ -23,14 +23,11 @@ import com.facebook.react.bridge.UIManagerListener
 import com.facebook.react.bridge.buildReadableMap
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.common.annotations.VisibleForTesting
-import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.ReactChoreographer
 import com.facebook.react.uimanager.GuardedFrameCallback
-import com.facebook.react.uimanager.UIBlock
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil
 import java.util.ArrayList
 import java.util.Queue
 import java.util.concurrent.ConcurrentLinkedQueue
@@ -207,11 +204,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   @Volatile private var currentBatchNumber: Long = 0
 
   private var initializedForFabric = false
-  private var initializedForNonFabric = false
-
-  @UIManagerType private var uiManagerType = UIManagerType.LEGACY
-  private var numFabricAnimations = 0
-  private var numNonFabricAnimations = 0
 
   /**
    * This method is used to notify the JS side that the user has stopped scrolling. With natively
@@ -285,10 +277,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   // For FabricUIManager only
   @UiThread
   override fun didDispatchMountItems(uiManager: UIManager) {
-    if (uiManagerType != UIManagerType.FABRIC) {
-      return
-    }
-
     var batchNumber = currentBatchNumber - 1
 
     // TODO T71377544: delete this when the JS method is confirmed safe
@@ -313,33 +301,10 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
     operations.executeBatch(batchNumber, nodesManager)
   }
 
-  // For non-FabricUIManager only
-  @Suppress("DEPRECATION")
+  // For non-FabricUIManager only (no-op since Fabric is the only supported UIManager)
   @UiThread
   override fun willDispatchViewUpdates(uiManager: UIManager) {
-    if (operations.isEmpty && preOperations.isEmpty) {
-      return
-    }
-    if (
-        uiManagerType == UIManagerType.FABRIC ||
-            ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE
-    ) {
-      return
-    }
-
-    // The following code ONLY executes for non-fabric
-    // When ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE is true, the folowing code
-    // might be stripped out.
-    val frameNo = currentBatchNumber++
-
-    val preOperationsUIBlock = UIBlock { preOperations.executeBatch(frameNo, nodesManager) }
-
-    val operationsUIBlock = UIBlock { operations.executeBatch(frameNo, nodesManager) }
-
-    assert(uiManager is com.facebook.react.uimanager.UIManagerModule)
-    val uiManagerModule = uiManager as com.facebook.react.uimanager.UIManagerModule
-    uiManagerModule.prependUIBlock(preOperationsUIBlock)
-    uiManagerModule.addUIBlock(operationsUIBlock)
+    // No-op: Fabric is the only supported UIManager
   }
 
   override fun onHostPause() {
@@ -411,23 +376,15 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   }
 
   /**
-   * Given a viewTag, detect if we're running in Fabric or non-Fabric and attach an event listener
-   * to the correct UIManager, if necessary. This is expected to only be called from the native
-   * module thread, and not concurrently.
+   * Given a viewTag, attach an event listener to the Fabric UIManager if necessary. This is
+   * expected to only be called from the native module thread, and not concurrently.
    *
    * @param viewTag
    */
   private fun initializeLifecycleEventListenersForViewTag(viewTag: Int) {
-    uiManagerType = ViewUtil.getUIManagerType(viewTag)
-    if (uiManagerType == UIManagerType.FABRIC) {
-      numFabricAnimations++
-    } else {
-      numNonFabricAnimations++
-    }
-
     val nodesManager = this.nodesManager
     if (nodesManager != null) {
-      nodesManager.initializeEventListenerForUIManagerType(uiManagerType)
+      nodesManager.initializeEventListenerForUIManagerType(UIManagerType.FABRIC)
     } else {
       ReactSoftExceptionLogger.logSoftException(
           NAME,
@@ -437,62 +394,21 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       )
     }
 
-    // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
-    val initialized =
-        if (uiManagerType == UIManagerType.FABRIC) initializedForFabric else initializedForNonFabric
-    if (initialized) {
+    // Subscribe to Fabric UIManager lifecycle events if we haven't yet
+    if (initializedForFabric) {
       return
     }
 
     val reactApplicationContext = reactApplicationContextIfActiveOrWarn
     if (reactApplicationContext != null) {
-      val uiManager = UIManagerHelper.getUIManager(reactApplicationContext, uiManagerType)
+      val uiManager = UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.FABRIC)
       if (uiManager != null) {
         uiManager.addUIManagerEventListener(this)
-        if (uiManagerType == UIManagerType.FABRIC) {
-          initializedForFabric = true
-        } else {
-          initializedForNonFabric = true
-        }
+        initializedForFabric = true
       }
     }
   }
 
-  /**
-   * Given a viewTag and the knowledge that a "disconnect" or "stop"-type imperative command is
-   * being executed, decrement the number of inflight animations and possibly switch UIManager
-   * modes.
-   *
-   * @param viewTag
-   */
-  private fun decrementInFlightAnimationsForViewTag(viewTag: Int) {
-    @UIManagerType val animationManagerType = ViewUtil.getUIManagerType(viewTag)
-    if (animationManagerType == UIManagerType.FABRIC) {
-      numFabricAnimations--
-    } else {
-      numNonFabricAnimations--
-    }
-
-    // Should we switch to a different animation mode?
-    // This can be useful when navigating between Fabric and non-Fabric screens:
-    // If there are ongoing Fabric animations from a previous screen,
-    // and we tear down the current non-Fabric screen, we should expect
-    // the animation mode to switch back - and vice-versa.
-    if (
-        numNonFabricAnimations == 0 &&
-            numFabricAnimations > 0 &&
-            uiManagerType != UIManagerType.FABRIC
-    ) {
-      uiManagerType = UIManagerType.FABRIC
-    } else if (
-        numFabricAnimations == 0 &&
-            numNonFabricAnimations > 0 &&
-            uiManagerType != UIManagerType.LEGACY
-    ) {
-      uiManagerType = UIManagerType.LEGACY
-    }
-  }
-
   override fun startOperationBatch() {
     batchingControlledByJS = true
     currentBatchNumber++
@@ -804,8 +720,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       FLog.d(NAME, "queue disconnectAnimatedNodeFromView: $animatedNodeTag viewTag: $viewTag")
     }
 
-    decrementInFlightAnimationsForViewTag(viewTag)
-
     addOperation(
         object : UIThreadOperation() {
           override fun execute(animatedNodesManager: NativeAnimatedNodesManager) {
@@ -883,8 +797,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       )
     }
 
-    decrementInFlightAnimationsForViewTag(viewTag)
-
     addOperation(
         object : UIThreadOperation() {
           override fun execute(animatedNodesManager: NativeAnimatedNodesManager) {
@@ -1085,7 +997,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
                 BatchExecutionOpCodes.OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW -> {
                   val animatedNodeTag = opsAndArgs.getInt(i++)
                   viewTag = opsAndArgs.getInt(i++)
-                  decrementInFlightAnimationsForViewTag(viewTag)
                   animatedNodesManager.disconnectAnimatedNodeFromView(animatedNodeTag, viewTag)
                 }
 
@@ -1104,7 +1015,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
 
                 BatchExecutionOpCodes.OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW -> {
                   viewTag = opsAndArgs.getInt(i++)
-                  decrementInFlightAnimationsForViewTag(viewTag)
                   animatedNodesManager.removeAnimatedEventFromView(
                       viewTag,
                       checkNotNull(opsAndArgs.getString(i++)),

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.kt

@@ -61,25 +61,17 @@ public class NativeAnimatedNodesManager(
   private val runUpdateNodeList: MutableList<AnimatedNode> = LinkedList()
 
   private var eventListenerInitializedForFabric = false
-  private var eventListenerInitializedForNonFabric = false
 
   private var warnedAboutGraphTraversal = false
 
   /**
-   * Initialize event listeners for Fabric UIManager or non-Fabric UIManager, exactly once. Once
-   * Fabric is the only UIManager, this logic can be simplified. This is expected to only be called
-   * from the native module thread.
+   * Initialize event listeners for Fabric UIManager exactly once. This is expected to only be
+   * called from the native module thread.
    *
    * @param uiManagerType
    */
   public fun initializeEventListenerForUIManagerType(@UIManagerType uiManagerType: Int) {
-    val isEventListenerInitialized =
-        when (uiManagerType) {
-          UIManagerType.FABRIC -> eventListenerInitializedForFabric
-          else -> eventListenerInitializedForNonFabric
-        }
-
-    if (isEventListenerInitialized) {
+    if (eventListenerInitializedForFabric) {
       return
     }
 
@@ -87,11 +79,7 @@ public class NativeAnimatedNodesManager(
         UIManagerHelper.getUIManager(checkNotNull(reactApplicationContext), uiManagerType)
     if (uiManager != null) {
       uiManager.eventDispatcher.addListener(this)
-      if (uiManagerType == UIManagerType.FABRIC) {
-        eventListenerInitializedForFabric = true
-      } else {
-        eventListenerInitializedForNonFabric = true
-      }
+      eventListenerInitializedForFabric = true
     }
   }
 
@@ -763,7 +751,6 @@ public class NativeAnimatedNodesManager(
         FLog.e(TAG, node.prettyPrintWithChildren())
       }
 
-      // If we're running only in non-Fabric, we still throw an exception.
       // In Fabric, it seems that animations enter an inconsistent state fairly often.
       // We detect if the inconsistency is due to a cycle (a fatal error for which we must crash)
       // or disconnected regions, indicating a partially-set-up animation graph, which is not
@@ -773,17 +760,9 @@ public class NativeAnimatedNodesManager(
           IllegalStateException(
               ("Looks like animated nodes graph has ${reason}, there are $activeNodesCount but toposort visited only $updatedNodesCount")
           )
-      if (eventListenerInitializedForFabric && cyclesDetected == 0) {
-        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
-        // or fix the root cause
-        ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
-      } else if (eventListenerInitializedForFabric) {
-        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
-        // or fix the root cause
-        ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
-      } else {
-        throw ex
-      }
+      // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
+      // or fix the root cause
+      ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
     } else {
       warnedAboutGraphTraversal = false
     }

package/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.kt

@@ -12,8 +12,6 @@ import com.facebook.react.bridge.JSApplicationIllegalArgumentException
 import com.facebook.react.bridge.JavaOnlyMap
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UIManager
-import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
 
 /**
  * Animated node that represents view properties. There is a special handling logic implemented for
@@ -67,23 +65,8 @@ internal class PropsAnimatedNode(
   }
 
   fun restoreDefaultValues() {
-    // Cannot restore default values if this view has already been disconnected.
-    if (connectedViewTag == -1) {
-      return
-    }
-    // Don't restore default values in Fabric.
-    // In Non-Fabric this had the effect of "restore the value to whatever the value was on the
-    // ShadowNode instead of in the View hierarchy". However, "synchronouslyUpdateViewOnUIThread"
-    // will not have that impact on Fabric, because the FabricUIManager doesn't have access to the
-    // ShadowNode layer.
-    if (getUIManagerType(connectedViewTag) == UIManagerType.FABRIC) {
-      return
-    }
-    val it = propMap.keySetIterator()
-    while (it.hasNextKey()) {
-      propMap.putNull(it.nextKey())
-    }
-    connectedViewUIManager?.synchronouslyUpdateViewOnUIThread(connectedViewTag, propMap)
+    // In Fabric, we don't restore default values since the FabricUIManager doesn't have access
+    // to the ShadowNode layer. This method was only relevant for the legacy Paper renderer.
   }
 
   fun updateView() {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JavaModuleWrapper.kt

@@ -25,15 +25,9 @@ import java.lang.reflect.Method
 @DoNotStrip
 @InteropLegacyArchitecture
 internal class JavaModuleWrapper(
-    @Suppress("DEPRECATION") private val jsInstance: JSInstance,
+    @Suppress("DEPRECATION", "unused") private val jsInstance: JSInstance,
     private val moduleHolder: ModuleHolder,
 ) {
-  interface NativeMethod {
-    @Suppress("DEPRECATION") fun invoke(jsInstance: JSInstance, parameters: ReadableArray)
-
-    val type: String
-  }
-
   @DoNotStrip
   class MethodDescriptor {
     @DoNotStrip var method: Method? = null
@@ -45,7 +39,6 @@ internal class JavaModuleWrapper(
     @DoNotStrip var type: String? = null
   }
 
-  private val methods = ArrayList<NativeMethod>()
   private val descs = ArrayList<MethodDescriptor>()
 
   @get:DoNotStrip
@@ -63,26 +56,26 @@ internal class JavaModuleWrapper(
     var classForMethods: Class<*> = moduleHolder.module.javaClass
     val superClass = classForMethods.superclass
     if (superClass != null && TurboModule::class.java.isAssignableFrom(superClass)) {
-      // For java module that is based on generated flow-type spec, inspect the
-      // spec abstract class instead, which is the super class of the given Java
-      // module.
       classForMethods = superClass
     }
 
     val targetMethods = classForMethods.declaredMethods
     for (targetMethod in targetMethods) {
       targetMethod.getAnnotation(ReactMethod::class.java)?.let { annotation ->
-        val methodName = targetMethod.name
         val md = MethodDescriptor()
-        @Suppress("DEPRECATION")
-        val method = JavaMethodWrapper(this, targetMethod, annotation.isBlockingSynchronousMethod)
-        md.name = methodName
-        md.type = method.type
+        md.name = targetMethod.name
+        md.type =
+            when {
+              annotation.isBlockingSynchronousMethod -> BaseJavaModule.METHOD_TYPE_SYNC
+              targetMethod.parameterTypes.let { params ->
+                params.isNotEmpty() && params.last() == Promise::class.java
+              } -> BaseJavaModule.METHOD_TYPE_PROMISE
+              else -> BaseJavaModule.METHOD_TYPE_ASYNC
+            }
         if (BaseJavaModule.METHOD_TYPE_SYNC == md.type) {
-          md.signature = method.signature
+          md.signature = ""
           md.method = targetMethod
         }
-        methods.add(method)
         descs.add(md)
       }
     }
@@ -128,11 +121,10 @@ internal class JavaModuleWrapper(
 
   @DoNotStrip
   fun invoke(methodId: Int, parameters: ReadableNativeArray) {
-    if (methodId >= methods.size) {
-      return
-    }
-
-    methods[methodId].invoke(jsInstance, parameters)
+    throw UnsupportedOperationException(
+        "JavaModuleWrapper.invoke() is no longer supported. " +
+            "Use TurboModule interop instead (ReactNativeFeatureFlags.useTurboModuleInterop)."
+    )
   }
 
   private companion object {