react-native-tvos 0.75.4-0 → 0.76.0-0

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

@@ -0,0 +1,104 @@
+/*
+ * 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.animated
+
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.build.ReactBuildConfig
+
+/**
+ * Implementation of [AnimationDriver] which provides a support for simple time-based animations
+ * that are pre-calculate on the JS side. For each animation frame JS provides a value from 0 to 1
+ * that indicates a progress of the animation at that frame.
+ */
+internal class FrameBasedAnimationDriver(config: ReadableMap) : AnimationDriver() {
+  private var startFrameTimeNanos: Long = -1
+  private var frames: DoubleArray = DoubleArray(0)
+  private var toValue = 0.0
+  private var fromValue = 0.0
+  private var iterations = 1
+  private var currentLoop = 1
+  private var logCount = 0
+
+  init {
+    resetConfig(config)
+  }
+
+  override fun resetConfig(config: ReadableMap) {
+    val framesConfig = config.getArray("frames")
+    if (framesConfig != null) {
+      val numberOfFrames = framesConfig.size()
+      if (frames.size != numberOfFrames) {
+        frames = DoubleArray(numberOfFrames) { i -> framesConfig.getDouble(i) }
+      }
+    }
+    toValue =
+        if (config.hasKey("toValue") && config.getType("toValue") == ReadableType.Number)
+            config.getDouble("toValue")
+        else 0.0
+    iterations =
+        if (config.hasKey("iterations") && config.getType("iterations") == ReadableType.Number)
+            config.getInt("iterations")
+        else 1
+    currentLoop = 1
+    hasFinished = iterations == 0
+    startFrameTimeNanos = -1
+  }
+
+  override fun runAnimationStep(frameTimeNanos: Long) {
+    val animatedValue = requireNotNull(animatedValue) { "Animated value should not be null" }
+    if (startFrameTimeNanos < 0) {
+      startFrameTimeNanos = frameTimeNanos
+      if (currentLoop == 1) {
+        // initiate start value when animation runs for the first time
+        fromValue = animatedValue.nodeValue
+      }
+    }
+    val timeFromStartMillis = (frameTimeNanos - startFrameTimeNanos) / 1000000
+    val frameIndex = Math.round(timeFromStartMillis / FRAME_TIME_MILLIS).toInt()
+    if (frameIndex < 0) {
+      val message =
+          ("Calculated frame index should never be lower than 0. Called with frameTimeNanos " +
+              frameTimeNanos +
+              " and mStartFrameTimeNanos " +
+              startFrameTimeNanos)
+      check(!ReactBuildConfig.DEBUG) { message }
+      if (logCount < 100) {
+        FLog.w(ReactConstants.TAG, message)
+        logCount++
+      }
+      return
+    } else if (hasFinished) {
+      // nothing to do here
+      return
+    }
+    val nextValue: Double
+    if (frameIndex >= frames.size - 1) {
+      if (iterations == -1 || currentLoop < iterations) {
+        // Use last frame value, just in case it's different from mToValue
+        nextValue = fromValue + frames[frames.size - 1] * (toValue - fromValue)
+        startFrameTimeNanos = -1
+        currentLoop++
+      } else {
+        // animation has completed, no more frames left
+        nextValue = toValue
+        hasFinished = true
+      }
+    } else {
+      nextValue = fromValue + frames[frameIndex] * (toValue - fromValue)
+    }
+    animatedValue.nodeValue = nextValue
+  }
+
+  companion object {
+    // 60FPS
+    private const val FRAME_TIME_MILLIS = 1000.0 / 60.0
+  }
+}

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

@@ -0,0 +1,278 @@
+/*
+ * 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.animated
+
+import androidx.core.graphics.ColorUtils
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import java.util.regex.Pattern
+
+/**
+ * Animated node that corresponds to `AnimatedInterpolation` from AnimatedImplementation.js.
+ *
+ * Currently only a linear interpolation is supported on an input range of an arbitrary size.
+ */
+public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode() {
+  private enum class OutputType {
+    Number,
+    Color,
+    String
+  }
+
+  private val inputRange: DoubleArray = fromDoubleArray(config.getArray("inputRange"))
+  private var outputRange: Any? = null
+  private var outputType: OutputType? = null
+  private var pattern: String? = null
+  private val extrapolateLeft: String? = config.getString("extrapolateLeft")
+  private val extrapolateRight: String? = config.getString("extrapolateRight")
+  private var parent: ValueAnimatedNode? = null
+  private var objectValue: Any? = null
+
+  init {
+    val output = config.getArray("outputRange")
+    if (COLOR_OUTPUT_TYPE == config.getString("outputType")) {
+      outputType = OutputType.Color
+      outputRange = fromIntArray(output)
+    } else if (output?.getType(0) == ReadableType.String) {
+      outputType = OutputType.String
+      outputRange = fromStringPattern(output)
+      pattern = output.getString(0)
+    } else {
+      outputType = OutputType.Number
+      outputRange = fromDoubleArray(output)
+    }
+  }
+
+  override fun onAttachedToNode(parent: AnimatedNode) {
+    check(this.parent == null) { "Parent already attached" }
+    require(parent is ValueAnimatedNode) { "Parent is of an invalid type" }
+    this.parent = parent
+  }
+
+  override fun onDetachedFromNode(parent: AnimatedNode) {
+    require(parent === this.parent) { "Invalid parent node provided" }
+    this.parent = null
+  }
+
+  override fun update() {
+    // If the graph is in the middle of being created, just skip this unattached node.
+    val parentValue = parent?.getValue() ?: return
+    when (outputType) {
+      OutputType.Number ->
+          nodeValue =
+              interpolate(
+                  parentValue,
+                  inputRange,
+                  outputRange as DoubleArray,
+                  extrapolateLeft,
+                  extrapolateRight)
+      OutputType.Color ->
+          objectValue =
+              Integer.valueOf(interpolateColor(parentValue, inputRange, outputRange as IntArray))
+      OutputType.String ->
+          pattern?.let {
+            @Suppress("UNCHECKED_CAST")
+            objectValue =
+                interpolateString(
+                    it,
+                    parentValue,
+                    inputRange,
+                    outputRange as Array<DoubleArray>,
+                    extrapolateLeft,
+                    extrapolateRight)
+          }
+
+      else -> {}
+    }
+  }
+
+  override fun getAnimatedObject(): Any? = objectValue
+
+  override fun prettyPrint(): String =
+      "InterpolationAnimatedNode[$tag] super: {super.prettyPrint()}"
+
+  public companion object {
+    public const val EXTRAPOLATE_TYPE_IDENTITY: String = "identity"
+    public const val EXTRAPOLATE_TYPE_CLAMP: String = "clamp"
+    public const val EXTRAPOLATE_TYPE_EXTEND: String = "extend"
+
+    private val numericPattern: Pattern =
+        Pattern.compile("[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?")
+    private const val COLOR_OUTPUT_TYPE: String = "color"
+
+    private fun fromDoubleArray(array: ReadableArray?): DoubleArray {
+      val size = array?.size() ?: return DoubleArray(0)
+      val res = DoubleArray(size)
+      for (i in res.indices) {
+        res[i] = array.getDouble(i)
+      }
+      return res
+    }
+
+    private fun fromIntArray(array: ReadableArray?): IntArray {
+      val size = array?.size() ?: return IntArray(0)
+      val res = IntArray(size)
+      for (i in res.indices) {
+        res[i] = array.getInt(i)
+      }
+      return res
+    }
+
+    private fun fromStringPattern(array: ReadableArray): Array<DoubleArray?> {
+      val size = array.size()
+      val outputRange = arrayOfNulls<DoubleArray>(size)
+
+      // Match the first pattern into a List, since we don't know its length yet
+      var m = numericPattern.matcher(array.getString(0))
+      val firstOutputRange: MutableList<Double> = ArrayList()
+      while (m.find()) {
+        firstOutputRange.add(m.group().toDouble())
+      }
+      val firstOutputRangeArr = DoubleArray(firstOutputRange.size)
+      for (i in firstOutputRange.indices) {
+        firstOutputRangeArr[i] = firstOutputRange[i]
+      }
+      outputRange[0] = firstOutputRangeArr
+      for (i in 1 until size) {
+        val outputArr = DoubleArray(firstOutputRangeArr.size)
+        var j = 0
+        m = numericPattern.matcher(array.getString(i))
+        while (m.find() && j < firstOutputRangeArr.size) {
+          outputArr[j++] = m.group().toDouble()
+        }
+        outputRange[i] = outputArr
+      }
+      return outputRange
+    }
+
+    public fun interpolate(
+        value: Double,
+        inputMin: Double,
+        inputMax: Double,
+        outputMin: Double,
+        outputMax: Double,
+        extrapolateLeft: String?,
+        extrapolateRight: String?
+    ): Double {
+      var result = value
+
+      // Extrapolate
+      if (result < inputMin) {
+        when (extrapolateLeft) {
+          EXTRAPOLATE_TYPE_IDENTITY -> return result
+          EXTRAPOLATE_TYPE_CLAMP -> result = inputMin
+          EXTRAPOLATE_TYPE_EXTEND -> {}
+          else ->
+              throw JSApplicationIllegalArgumentException(
+                  "Invalid extrapolation type " + extrapolateLeft + "for left extrapolation")
+        }
+      }
+      if (result > inputMax) {
+        when (extrapolateRight) {
+          EXTRAPOLATE_TYPE_IDENTITY -> return result
+          EXTRAPOLATE_TYPE_CLAMP -> result = inputMax
+          EXTRAPOLATE_TYPE_EXTEND -> {}
+          else ->
+              throw JSApplicationIllegalArgumentException(
+                  "Invalid extrapolation type " + extrapolateRight + "for right extrapolation")
+        }
+      }
+      if (outputMin == outputMax) {
+        return outputMin
+      }
+      return if (inputMin == inputMax) {
+        if (value <= inputMin) {
+          outputMin
+        } else outputMax
+      } else outputMin + (outputMax - outputMin) * (result - inputMin) / (inputMax - inputMin)
+    }
+
+    public fun interpolate(
+        value: Double,
+        inputRange: DoubleArray,
+        outputRange: DoubleArray,
+        extrapolateLeft: String?,
+        extrapolateRight: String?
+    ): Double {
+      val rangeIndex = findRangeIndex(value, inputRange)
+      return interpolate(
+          value,
+          inputRange[rangeIndex],
+          inputRange[rangeIndex + 1],
+          outputRange[rangeIndex],
+          outputRange[rangeIndex + 1],
+          extrapolateLeft,
+          extrapolateRight)
+    }
+
+    public fun interpolateColor(
+        value: Double,
+        inputRange: DoubleArray,
+        outputRange: IntArray
+    ): Int {
+      val rangeIndex = findRangeIndex(value, inputRange)
+      val outputMin = outputRange[rangeIndex]
+      val outputMax = outputRange[rangeIndex + 1]
+      if (outputMin == outputMax) {
+        return outputMin
+      }
+      val inputMin = inputRange[rangeIndex]
+      val inputMax = inputRange[rangeIndex + 1]
+      if (inputMin == inputMax) {
+        return if (value <= inputMin) {
+          outputMin
+        } else outputMax
+      }
+      val ratio = (value - inputMin) / (inputMax - inputMin)
+      return ColorUtils.blendARGB(outputMin, outputMax, ratio.toFloat())
+    }
+
+    public fun interpolateString(
+        pattern: String,
+        value: Double,
+        inputRange: DoubleArray,
+        outputRange: Array<DoubleArray>,
+        extrapolateLeft: String?,
+        extrapolateRight: String?
+    ): String {
+      val rangeIndex = findRangeIndex(value, inputRange)
+      val sb = StringBuffer(pattern.length)
+      val m = numericPattern.matcher(pattern)
+      var i = 0
+      while (m.find() && i < outputRange[rangeIndex].size) {
+        val v =
+            interpolate(
+                value,
+                inputRange[rangeIndex],
+                inputRange[rangeIndex + 1],
+                outputRange[rangeIndex][i],
+                outputRange[rangeIndex + 1][i],
+                extrapolateLeft,
+                extrapolateRight)
+        val intVal = v.toInt()
+        m.appendReplacement(sb, if (intVal.toDouble() != v) v.toString() else intVal.toString())
+        i++
+      }
+      m.appendTail(sb)
+      return sb.toString()
+    }
+
+    private fun findRangeIndex(value: Double, ranges: DoubleArray): Int {
+      var index: Int = 1
+      while (index < ranges.size - 1) {
+        if (ranges[index] >= value) {
+          break
+        }
+        index++
+      }
+      return index - 1
+    }
+  }
+}

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

@@ -21,8 +21,8 @@ internal class ModulusAnimatedNode(
   override public fun update() {
     val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNode)
     if (animatedNode is ValueAnimatedNode) {
-      val animatedNodeValue = animatedNode.value
-      mValue = (animatedNodeValue % modulus + modulus) % modulus
+      val animatedNodeValue = animatedNode.getValue()
+      nodeValue = (animatedNodeValue % modulus + modulus) % modulus
     } else {
       throw JSApplicationCausedNativeException(
           "Illegal node ID set as an input for Animated.modulus node")
@@ -30,6 +30,6 @@ internal class ModulusAnimatedNode(
   }
 
   override public fun prettyPrint(): String {
-    return "NativeAnimatedNodesManager[$mTag] inputNode: $inputNode modulus: $modulus super: ${super.prettyPrint()}"
+    return "NativeAnimatedNodesManager[$tag] inputNode: $inputNode modulus: $modulus super: ${super.prettyPrint()}"
   }
 }

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

@@ -0,0 +1,50 @@
+/*
+ * 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.animated
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Animated node which takes two or more value node as an input and outputs a product of their
+ * values
+ */
+internal class MultiplicationAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : ValueAnimatedNode() {
+  private var inputNodes: IntArray
+
+  init {
+    val input = config.getArray("input")
+    inputNodes =
+        if (input == null) {
+          IntArray(0)
+        } else {
+          IntArray(input.size()) { i -> input.getInt(i) }
+        }
+  }
+
+  override fun update() {
+    nodeValue = 1.0
+    for (i in inputNodes.indices) {
+      val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNodes[i])
+      val multiplier =
+          if (animatedNode != null && animatedNode is ValueAnimatedNode) {
+            animatedNode.getValue()
+          } else {
+            throw JSApplicationCausedNativeException(
+                "Illegal node ID set as an input for Animated.multiply node")
+          }
+      nodeValue *= multiplier
+    }
+  }
+
+  override fun prettyPrint(): String =
+      "MultiplicationAnimatedNode[$tag]: input nodes: $inputNodes - super: ${super.prettyPrint()}"
+}

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

@@ -23,6 +23,7 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
@@ -38,6 +39,7 @@ import com.facebook.react.uimanager.common.ViewUtil;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Queue;
+import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -261,6 +263,43 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
         };
   }
 
+  /**
+   * This method is used to notify the JS side that the user has stopped scrolling. With natively
+   * driven animation, we might have to force a resync between the Shadow Tree and the Native Tree.
+   * This is because with natively driven animation, the Shadow Tree is bypassed and it can have
+   * stale information on the layout of the native views. This method takes care of verifying if
+   * there are some views listening to the native driven animation and it triggers the resynch.
+   *
+   * @param viewTag The tag of the scroll view that has stopped scrolling
+   */
+  public void userDrivenScrollEnded(int viewTag) {
+    // ask to the Node Manager for all the native nodes listening to OnScroll event
+    NativeAnimatedNodesManager nodeManager = mNodesManager.get();
+    if (nodeManager == null) {
+      return;
+    }
+
+    Set<Integer> tags = nodeManager.getTagsOfConnectedNodes(viewTag, "topScrollEnded");
+
+    if (tags.isEmpty()) {
+      return;
+    }
+
+    WritableArray tagsArray = Arguments.createArray();
+    for (Integer tag : tags) {
+      tagsArray.pushInt(tag);
+    }
+
+    // emit the event to JS to resync the trees
+    WritableMap onAnimationEndedData = Arguments.createMap();
+    onAnimationEndedData.putArray("tags", tagsArray);
+
+    ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
+    if (reactApplicationContext != null) {
+      reactApplicationContext.emitDeviceEvent("onUserDrivenAnimationEnded", onAnimationEndedData);
+    }
+  }
+
   @Override
   public void initialize() {
     super.initialize();
@@ -507,7 +546,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
   @Override
   public void finishOperationBatch() {
-    mBatchingControlledByJS = true;
+    mBatchingControlledByJS = false;
     mCurrentBatchNumber++;
   }