react-native-tvos 0.80.1-0 → 0.81.0-0

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

@@ -0,0 +1,340 @@
+/*
+ * 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.view.KeyEvent
+import android.view.MotionEvent
+import androidx.core.util.Pools.SynchronizedPool
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactSoftExceptionLogger.logSoftException
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
+import com.facebook.react.uimanager.TouchTargetHelper.ViewTarget
+import com.facebook.react.uimanager.events.Event.EventAnimationDriverMatchSpec
+import com.facebook.react.uimanager.events.PointerEventHelper.getButtonChange
+import com.facebook.react.uimanager.events.PointerEventHelper.getButtons
+import com.facebook.react.uimanager.events.PointerEventHelper.getEventCategory
+import com.facebook.react.uimanager.events.PointerEventHelper.getPressure
+import com.facebook.react.uimanager.events.PointerEventHelper.getW3CPointerType
+import com.facebook.react.uimanager.events.PointerEventHelper.isBubblingEvent
+
+internal class PointerEvent private constructor() : Event<PointerEvent>() {
+  private var motionEvent: MotionEvent? = null
+  private lateinit var _eventName: String
+  private var coalescingKey = UNSET_COALESCING_KEY
+  private var pointersEventData: List<WritableMap>? = null
+  private lateinit var eventState: PointerEventState
+
+  private fun init(
+      eventName: String,
+      targetTag: Int,
+      eventState: PointerEventState,
+      motionEventToCopy: MotionEvent,
+      coalescingKey: Short
+  ) {
+    super.init(eventState.getSurfaceId(), targetTag, motionEventToCopy.eventTime)
+    this._eventName = eventName
+    this.motionEvent = MotionEvent.obtain(motionEventToCopy)
+    this.coalescingKey = coalescingKey
+    this.eventState = eventState
+  }
+
+  override fun getEventName(): String = _eventName
+
+  private val isClickEvent: Boolean
+    get() = _eventName == PointerEventHelper.CLICK
+
+  @Deprecated("Prefer to override getEventData instead")
+  @Suppress("DEPRECATION")
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    if (motionEvent == null) {
+      logSoftException(
+          TAG,
+          IllegalStateException(
+              "Cannot dispatch a Pointer that has no MotionEvent; the PointerEvent has been" +
+                  " recycled"))
+      return
+    }
+    if (pointersEventData == null) {
+      pointersEventData = createPointersEventData()
+    }
+
+    val data = pointersEventData ?: return // No relevant MotionEvent to dispatch
+
+    val shouldCopy = data.size > 1
+    for (pointerEventData in data) {
+      val eventData = if (shouldCopy) pointerEventData.copy() else pointerEventData
+      rctEventEmitter.receiveEvent(viewTag, _eventName, eventData)
+    }
+    return
+  }
+
+  override val eventAnimationDriverMatchSpec: EventAnimationDriverMatchSpec by
+      lazy(LazyThreadSafetyMode.NONE) {
+        EventAnimationDriverMatchSpec { viewTag, eventName ->
+          if (eventName != _eventName) {
+            return@EventAnimationDriverMatchSpec false
+          }
+          if (isBubblingEvent(eventName)) {
+            for (viewTarget in eventState.hitPathForActivePointer) {
+              if (viewTarget.getViewId() == viewTag) {
+                return@EventAnimationDriverMatchSpec true
+              }
+            }
+            false
+          } else {
+            this.viewTag == viewTag
+          }
+        }
+      }
+
+  override fun onDispose() {
+    pointersEventData = null
+    val motionEvent = motionEvent
+    this.motionEvent = null
+    motionEvent?.recycle()
+
+    // Either `this` is in the event pool, or motionEvent
+    // is null. It is in theory not possible for a PointerEvent to
+    // be in the EVENTS_POOL but for motionEvent to be null. However,
+    // out of an abundance of caution and to avoid memory leaks or
+    // other crashes at all costs, we attempt to release here and log
+    // a soft exception here if release throws an IllegalStateException
+    // due to `this` being over-released. This may indicate that there is
+    // a logic error in our events system or pooling mechanism.
+    try {
+      EVENTS_POOL.release(this)
+    } catch (e: IllegalStateException) {
+      logSoftException(TAG, e)
+    }
+  }
+
+  private fun createW3CPointerEvents(): List<WritableMap> {
+    val w3cPointerEvents = ArrayList<WritableMap>()
+    for (index in 0..<checkNotNull(motionEvent).pointerCount) {
+      w3cPointerEvents.add(createW3CPointerEvent(index))
+    }
+
+    return w3cPointerEvents
+  }
+
+  private fun addModifierKeyData(pointerEvent: WritableMap, modifierKeyMask: Int) {
+    pointerEvent.putBoolean("ctrlKey", (modifierKeyMask and KeyEvent.META_CTRL_ON) != 0)
+    pointerEvent.putBoolean("shiftKey", (modifierKeyMask and KeyEvent.META_SHIFT_ON) != 0)
+    pointerEvent.putBoolean("altKey", (modifierKeyMask and KeyEvent.META_ALT_ON) != 0)
+    pointerEvent.putBoolean("metaKey", (modifierKeyMask and KeyEvent.META_META_ON) != 0)
+  }
+
+  private fun createW3CPointerEvent(index: Int): WritableMap {
+    val pointerEvent = Arguments.createMap()
+    val motionEvent = checkNotNull(motionEvent)
+    val pointerId = motionEvent.getPointerId(index)
+
+    // https://www.w3.org/TR/pointerevents/#pointerevent-interface
+    pointerEvent.putDouble("pointerId", pointerId.toDouble())
+
+    val pointerType = getW3CPointerType(motionEvent.getToolType(index))
+    pointerEvent.putString("pointerType", pointerType)
+
+    val isPrimary =
+        !isClickEvent // compatibility click events should not be considered primary
+        && (eventState.supportsHover(pointerId) || pointerId == eventState.primaryPointerId)
+    pointerEvent.putBoolean("isPrimary", isPrimary)
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
+    // Client refers to upper left edge of the content area (viewport)
+    // We define the viewport to be ReactRootView
+    val eventCoords = checkNotNull(eventState.eventCoordinatesByPointerId[pointerId])
+    val clientX = toDIPFromPixel(eventCoords[0]).toDouble()
+    val clientY = toDIPFromPixel(eventCoords[1]).toDouble()
+    pointerEvent.putDouble("clientX", clientX)
+    pointerEvent.putDouble("clientY", clientY)
+
+    val screenCoords = checkNotNull(eventState.screenCoordinatesByPointerId[pointerId])
+    val screenX = toDIPFromPixel(screenCoords[0]).toDouble()
+    val screenY = toDIPFromPixel(screenCoords[1]).toDouble()
+    pointerEvent.putDouble("screenX", screenX)
+    pointerEvent.putDouble("screenY", screenY)
+
+    // x,y values are aliases of clientX, clientY
+    pointerEvent.putDouble("x", clientX)
+    pointerEvent.putDouble("y", clientY)
+
+    // page values in react-native are equivalent to client values since rootview is not scrollable
+    pointerEvent.putDouble("pageX", clientX)
+    pointerEvent.putDouble("pageY", clientY)
+
+    // Offset refers to upper left edge of the target view
+    val offsetCoords = checkNotNull(eventState.offsetByPointerId[pointerId])
+    pointerEvent.putDouble("offsetX", toDIPFromPixel(offsetCoords[0]).toDouble())
+    pointerEvent.putDouble("offsetY", toDIPFromPixel(offsetCoords[1]).toDouble())
+
+    pointerEvent.putInt("target", viewTag)
+    pointerEvent.putDouble("timestamp", timestampMs.toDouble())
+
+    pointerEvent.putInt("detail", 0)
+    pointerEvent.putDouble("tiltX", 0.0)
+    pointerEvent.putDouble("tiltY", 0.0)
+
+    pointerEvent.putInt("twist", 0)
+    // note: click events should have width = height = 1
+    if (pointerType == PointerEventHelper.POINTER_TYPE_MOUSE || isClickEvent) {
+      pointerEvent.putDouble("width", 1.0)
+      pointerEvent.putDouble("height", 1.0)
+    } else {
+      val majorAxis = toDIPFromPixel(motionEvent.getTouchMajor(index))
+      pointerEvent.putDouble("width", majorAxis.toDouble())
+      pointerEvent.putDouble("height", majorAxis.toDouble())
+    }
+
+    val buttonState = motionEvent.buttonState
+    pointerEvent.putInt(
+        "button", getButtonChange(pointerType, eventState.lastButtonState, buttonState))
+    pointerEvent.putInt("buttons", getButtons(_eventName, pointerType, buttonState))
+
+    val pressure =
+        if (isClickEvent) {
+          0.0 // click events need pressure=0
+        } else {
+          getPressure(pointerEvent.getInt("buttons"), _eventName)
+        }
+
+    pointerEvent.putDouble("pressure", pressure)
+    pointerEvent.putDouble("tangentialPressure", 0.0)
+
+    addModifierKeyData(pointerEvent, motionEvent.metaState)
+
+    return pointerEvent
+  }
+
+  private fun createPointersEventData(): List<WritableMap>? {
+    val activePointerIndex = checkNotNull(motionEvent).actionIndex
+    var pointersEventData: List<WritableMap>? = null
+    when (_eventName) {
+      PointerEventHelper.POINTER_MOVE,
+      PointerEventHelper.POINTER_CANCEL -> {
+        pointersEventData = createW3CPointerEvents()
+      }
+      PointerEventHelper.POINTER_ENTER,
+      PointerEventHelper.POINTER_DOWN,
+      PointerEventHelper.POINTER_UP,
+      PointerEventHelper.POINTER_LEAVE,
+      PointerEventHelper.POINTER_OUT,
+      PointerEventHelper.POINTER_OVER,
+      PointerEventHelper.CLICK -> {
+        pointersEventData = listOf(createW3CPointerEvent(activePointerIndex))
+      }
+    }
+    return pointersEventData
+  }
+
+  override fun getCoalescingKey(): Short = coalescingKey
+
+  override fun dispatchModern(rctEventEmitter: RCTModernEventEmitter) {
+    if (motionEvent == null) {
+      logSoftException(
+          TAG,
+          IllegalStateException(
+              "Cannot dispatch a Pointer that has no MotionEvent; the PointerEvent has been recycled"))
+      return
+    }
+
+    if (pointersEventData == null) {
+      pointersEventData = createPointersEventData()
+    }
+
+    if (pointersEventData == null) {
+      // No relevant MotionEvent to dispatch
+      return
+    }
+
+    val pointersEventData = checkNotNull(pointersEventData)
+    val shouldCopy = pointersEventData.size > 1
+    for (singleData in pointersEventData) {
+      val eventData = if (shouldCopy) singleData.copy() else singleData
+      rctEventEmitter.receiveEvent(
+          surfaceId,
+          viewTag,
+          _eventName,
+          coalescingKey != UNSET_COALESCING_KEY,
+          coalescingKey.toInt(),
+          eventData,
+          getEventCategory(_eventName))
+    }
+  }
+
+  class PointerEventState(
+      val primaryPointerId: Int,
+      val activePointerId: Int,
+      val lastButtonState: Int,
+      private val surfaceId: Int,
+      val offsetByPointerId: Map<Int, FloatArray>,
+      val hitPathByPointerId: Map<Int, List<ViewTarget>>,
+      val eventCoordinatesByPointerId: Map<Int, FloatArray>,
+      val screenCoordinatesByPointerId: Map<Int, FloatArray>,
+      hoveringPointerIds: Set<Int>
+  ) {
+    val hoveringPointerIds: Set<Int> = HashSet(hoveringPointerIds)
+
+    fun getSurfaceId(): Int = surfaceId
+
+    fun supportsHover(pointerId: Int): Boolean = hoveringPointerIds.contains(pointerId)
+
+    val hitPathForActivePointer: List<ViewTarget>
+      get() = checkNotNull(hitPathByPointerId[activePointerId])
+  }
+
+  companion object {
+    private val TAG: String = PointerEvent::class.java.simpleName
+    private const val POINTER_EVENTS_POOL_SIZE = 6
+    private val EVENTS_POOL = SynchronizedPool<PointerEvent>(POINTER_EVENTS_POOL_SIZE)
+    private const val UNSET_COALESCING_KEY: Short = -1
+
+    @JvmStatic
+    fun obtain(
+        eventName: String,
+        targetTag: Int,
+        eventState: PointerEventState,
+        motionEventToCopy: MotionEvent?
+    ): PointerEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = PointerEvent()
+      }
+      event.init(
+          eventName,
+          targetTag,
+          eventState,
+          Assertions.assertNotNull(motionEventToCopy),
+          0.toShort())
+      return event
+    }
+
+    @JvmStatic
+    fun obtain(
+        eventName: String,
+        targetTag: Int,
+        eventState: PointerEventState,
+        motionEventToCopy: MotionEvent?,
+        coalescingKey: Short
+    ): PointerEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = PointerEvent()
+      }
+      event.init(
+          eventName,
+          targetTag,
+          eventState,
+          Assertions.assertNotNull(motionEventToCopy),
+          coalescingKey)
+      return event
+    }
+  }
+}

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

@@ -86,7 +86,7 @@ internal object TouchesHelper {
    */
   @Suppress("DEPRECATION")
   @JvmStatic
-  public fun sendTouchesLegacy(rctEventEmitter: RCTEventEmitter, touchEvent: TouchEvent) {
+  fun sendTouchesLegacy(rctEventEmitter: RCTEventEmitter, touchEvent: TouchEvent) {
     val type = touchEvent.getTouchEventType()
 
     val pointers = getWritableArray(/* copyObjects */ false, createPointersArray(touchEvent))
@@ -122,7 +122,7 @@ internal object TouchesHelper {
    * @param event the touch event to extract data from
    */
   @JvmStatic
-  public fun sendTouchEvent(eventEmitter: RCTModernEventEmitter, event: TouchEvent) {
+  fun sendTouchEvent(eventEmitter: RCTModernEventEmitter, event: TouchEvent) {
     Systrace.beginSection(
         Systrace.TRACE_TAG_REACT,
         "TouchesHelper.sentTouchEventModern(" + event.getEventName() + ")")

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/internal/LegacyArchitectureShadowNodeLogger.kt

@@ -18,8 +18,9 @@ import com.facebook.yoga.YogaMeasureFunction
 /**
  * Logger class to track usage of ShadowNodes in Legacy Architecture.
  *
- * This class is similar to [LegacyArchitectureLogger] but focuses only on ShadowNodes warning for
- * users.
+ * This class is similar to
+ * [com.facebook.react.common.annotations.internal.LegacyArchitectureLogger] but focuses only on
+ * ShadowNodes warning for users.
  */
 public object LegacyArchitectureShadowNodeLogger {
 

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/AbstractLayoutAnimation.kt

@@ -26,7 +26,7 @@ import com.facebook.react.uimanager.IllegalViewOperationException
  * Class responsible for parsing and converting layout animation data into native [Animation] in
  * order to animate layout when a valid configuration has been supplied by the application.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal abstract class AbstractLayoutAnimation {
   var interpolator: Interpolator? = null
   var delayMs: Int = 0
@@ -100,7 +100,7 @@ internal abstract class AbstractLayoutAnimation {
   companion object {
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "AbstractLayoutAnimation", LegacyArchitectureLogLevel.WARNING)
+          "AbstractLayoutAnimation", LegacyArchitectureLogLevel.ERROR)
     }
 
     // Forces animation to be playing 10x slower, used for debug purposes.

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/AnimatedPropertyType.kt

@@ -8,12 +8,13 @@
 package com.facebook.react.uimanager.layoutanimation
 
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 
 /**
  * Enum representing the different view properties that can be used when animating layout for view
  * creation.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal enum class AnimatedPropertyType {
   OPACITY,
   SCALE_X,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/BaseLayoutAnimation.kt

@@ -16,7 +16,7 @@ import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 import com.facebook.react.uimanager.IllegalViewOperationException
 
 /** Class responsible for default layout animation, i.e animation of view creation and deletion. */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal abstract class BaseLayoutAnimation : AbstractLayoutAnimation() {
   abstract fun isReverse(): Boolean
 
@@ -79,7 +79,7 @@ internal abstract class BaseLayoutAnimation : AbstractLayoutAnimation() {
   private companion object {
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "BaseLayoutAnimation", LegacyArchitectureLogLevel.WARNING)
+          "BaseLayoutAnimation", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/InterpolatorType.kt

@@ -8,11 +8,12 @@
 package com.facebook.react.uimanager.layoutanimation
 
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 
 /**
  * Enum representing the different interpolators that can be used in layout animation configuration.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal enum class InterpolatorType {
   LINEAR,
   EASE_IN,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutAnimationController.kt

@@ -28,7 +28,7 @@ import javax.annotation.concurrent.NotThreadSafe
  * performing an animation.
  */
 @NotThreadSafe
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 public open class LayoutAnimationController {
   private val layoutCreateAnimation: AbstractLayoutAnimation = LayoutCreateAnimation()
   private val layoutUpdateAnimation: AbstractLayoutAnimation = LayoutUpdateAnimation()
@@ -219,7 +219,7 @@ public open class LayoutAnimationController {
 
   private companion object {
     init {
-      assertLegacyArchitecture("LayoutAnimationController", LegacyArchitectureLogLevel.WARNING)
+      assertLegacyArchitecture("LayoutAnimationController", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutAnimationListener.kt

@@ -8,9 +8,10 @@
 package com.facebook.react.uimanager.layoutanimation
 
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 
 /** Listener invoked when a layout animation has completed. */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 public fun interface LayoutAnimationListener {
   public fun onAnimationEnd()
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutAnimationType.kt

@@ -14,7 +14,7 @@ import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 /**
  * Enum representing the different animation type that can be specified in layout animation config.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal enum class LayoutAnimationType {
   CREATE,
   UPDATE,
@@ -23,7 +23,7 @@ internal enum class LayoutAnimationType {
   companion object {
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "LayoutAnimationType", LegacyArchitectureLogLevel.WARNING)
+          "LayoutAnimationType", LegacyArchitectureLogLevel.ERROR)
     }
 
     @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutCreateAnimation.kt

@@ -15,7 +15,7 @@ import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
  * Class responsible for handling layout view creation animation, applied to view whenever a valid
  * config was supplied for the layout animation of CREATE type.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal class LayoutCreateAnimation : BaseLayoutAnimation() {
 
   override fun isReverse(): Boolean = false
@@ -23,7 +23,7 @@ internal class LayoutCreateAnimation : BaseLayoutAnimation() {
   private companion object {
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "LayoutCreateAnimation", LegacyArchitectureLogLevel.WARNING)
+          "LayoutCreateAnimation", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutDeleteAnimation.kt

@@ -15,7 +15,7 @@ import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
  * Class responsible for handling layout view deletion animation, applied to view whenever a valid
  * config was supplied for the layout animation of DELETE type.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal class LayoutDeleteAnimation : BaseLayoutAnimation() {
 
   override fun isReverse(): Boolean = true
@@ -23,7 +23,7 @@ internal class LayoutDeleteAnimation : BaseLayoutAnimation() {
   private companion object {
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "LayoutDeleteAnimation", LegacyArchitectureLogLevel.WARNING)
+          "LayoutDeleteAnimation", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutHandlingAnimation.kt

@@ -8,9 +8,10 @@
 package com.facebook.react.uimanager.layoutanimation
 
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 
 /** Interface for an animation type that takes care of updating the view layout. */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal interface LayoutHandlingAnimation {
   /**
    * Notifies the animation of a layout update in case one occurs during the animation. This avoids

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/LayoutUpdateAnimation.kt

@@ -18,12 +18,12 @@ import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
  * Class responsible for handling layout update animation, applied to view whenever a valid config
  * was supplied for the layout animation of UPDATE type.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal class LayoutUpdateAnimation : AbstractLayoutAnimation() {
 
-  internal override fun isValid(): Boolean = durationMs > 0
+  override fun isValid(): Boolean = durationMs > 0
 
-  internal override fun createAnimationImpl(
+  override fun createAnimationImpl(
       view: View,
       x: Int,
       y: Int,
@@ -32,16 +32,16 @@ internal class LayoutUpdateAnimation : AbstractLayoutAnimation() {
   ): Animation? {
     val animateLocation = view.x.toInt() != x || view.y.toInt() != y
     val animateSize = view.width != width || view.height != height
-    if (!animateLocation && !animateSize) {
-      return null
+    return if (!animateLocation && !animateSize) {
+      null
     } else if (animateLocation && !animateSize && USE_TRANSLATE_ANIMATION) {
       // Use GPU-accelerated animation, however we loose the ability to resume interrupted
       // animation where it was left off. We may be able to listen to animation interruption
       // and set the layout manually in this case, so that next animation kicks off smoothly.
-      return TranslateAnimation(view.x - x, 0f, view.y - y, 0f)
+      TranslateAnimation(view.x - x, 0f, view.y - y, 0f)
     } else {
       // Animation is sub-optimal for perf, but scale transformation can't be use in this case.
-      return PositionAndSizeAnimation(view, x, y, width, height)
+      PositionAndSizeAnimation(view, x, y, width, height)
     }
   }
 
@@ -52,7 +52,7 @@ internal class LayoutUpdateAnimation : AbstractLayoutAnimation() {
 
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "LayoutUpdateAnimation", LegacyArchitectureLogLevel.WARNING)
+          "LayoutUpdateAnimation", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/OpacityAnimation.kt

@@ -20,7 +20,7 @@ import java.lang.ref.WeakReference
  * Animation responsible for updating opacity of a view. It should ideally use hardware texture to
  * optimize rendering performances.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal class OpacityAnimation(view: View, private val startOpacity: Float, endOpacity: Float) :
     Animation() {
   private val viewRef = WeakReference(view)
@@ -29,7 +29,7 @@ internal class OpacityAnimation(view: View, private val startOpacity: Float, end
   init {
     setAnimationListener(OpacityAnimationListener(view))
     LegacyArchitectureLogger.assertLegacyArchitecture(
-        "OpacityAnimation", LegacyArchitectureLogLevel.WARNING)
+        "OpacityAnimation", LegacyArchitectureLogLevel.ERROR)
   }
 
   class OpacityAnimationListener(view: View) : Animation.AnimationListener {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/PositionAndSizeAnimation.kt

@@ -11,6 +11,7 @@ import android.view.View
 import android.view.animation.Animation
 import android.view.animation.Transformation
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 import java.lang.ref.WeakReference
 
@@ -20,7 +21,7 @@ import java.lang.ref.WeakReference
  * passes occurring on every frame. What we might want to try to do instead is use a combined
  * ScaleAnimation and TranslateAnimation.
  */
-@LegacyArchitecture
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
 internal class PositionAndSizeAnimation(view: View, x: Int, y: Int, width: Int, height: Int) :
     Animation(), LayoutHandlingAnimation {
   private val viewRef = WeakReference(view)
@@ -81,7 +82,8 @@ internal class PositionAndSizeAnimation(view: View, x: Int, y: Int, width: Int,
 
   private companion object {
     init {
-      LegacyArchitectureLogger.assertLegacyArchitecture("PositionAndSizeAnimation")
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "PositionAndSizeAnimation", LegacyArchitectureLogLevel.ERROR)
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/layoutanimation/SimpleSpringInterpolator.kt

@@ -13,17 +13,15 @@ import com.facebook.react.bridge.ReadableType
 import com.facebook.react.common.annotations.internal.LegacyArchitecture
 import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
 import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import kotlin.math.pow
+import kotlin.math.sin
 
 /** Simple spring interpolator */
 // TODO(7613736): Improve spring interpolator with friction and damping variable support
-@LegacyArchitecture
-internal class SimpleSpringInterpolator : Interpolator {
-  private val _springDamping: Float
-
-  @JvmOverloads
-  constructor(springDamping: Float = FACTOR) {
-    _springDamping = springDamping
-  }
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
+internal class SimpleSpringInterpolator @JvmOverloads constructor(springDamping: Float = FACTOR) :
+    Interpolator {
+  private val _springDamping: Float = springDamping
 
   override fun getInterpolation(input: Float): Float =
       // Using mSpringDamping in this equation is not really the exact mathematical springDamping,
@@ -31,15 +29,15 @@ internal class SimpleSpringInterpolator : Interpolator {
       // We need to replace this equation with the right Factor that accounts for damping and
       // friction
       (1 +
-              Math.pow(2.0, (-10 * input).toDouble()) *
-                  Math.sin((input - _springDamping / 4) * Math.PI * 2 / _springDamping))
+              2.0.pow((-10 * input).toDouble()) *
+                  sin((input - _springDamping / 4) * Math.PI * 2 / _springDamping))
           .toFloat()
 
   companion object {
 
     init {
       LegacyArchitectureLogger.assertLegacyArchitecture(
-          "SimpleSpringInterpolator", LegacyArchitectureLogLevel.WARNING)
+          "SimpleSpringInterpolator", LegacyArchitectureLogLevel.ERROR)
     }
 
     private const val FACTOR = 0.5f