react-native-tvos 0.75.3-0 → 0.76.0-0

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

@@ -0,0 +1,187 @@
+/*
+ * 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.ReadableMap
+import kotlin.math.*
+
+/**
+ * Implementation of [AnimationDriver] providing support for spring animations. The implementation
+ * has been copied from android implementation of Rebound library (see
+ * [http://facebook.github.io/rebound/](http://facebook.github.io/rebound/))
+ */
+internal class SpringAnimation(config: ReadableMap) : AnimationDriver() {
+  // storage for the current and prior physics state while integration is occurring
+  private data class PhysicsState(var position: Double = 0.0, var velocity: Double = 0.0)
+
+  private var lastTime: Long = 0
+  private var springStarted = false
+  // configuration
+  private var springStiffness = 0.0
+  private var springDamping = 0.0
+  private var springMass = 0.0
+  private var initialVelocity = 0.0
+  private var overshootClampingEnabled = false
+  // all physics simulation objects are final and reused in each processing pass
+  private val currentState = PhysicsState()
+  private var startValue = 0.0
+  private var endValue = 0.0
+  // thresholds for determining when the spring is at rest
+  private var restSpeedThreshold = 0.0
+  private var displacementFromRestThreshold = 0.0
+  private var timeAccumulator = 0.0
+  // for controlling loop
+  private var iterations = 0
+  private var currentLoop = 0
+  private var originalValue = 0.0
+
+  init {
+    currentState.velocity = config.getDouble("initialVelocity")
+    resetConfig(config)
+  }
+
+  override fun resetConfig(config: ReadableMap) {
+    springStiffness = config.getDouble("stiffness")
+    springDamping = config.getDouble("damping")
+    springMass = config.getDouble("mass")
+    initialVelocity = currentState.velocity
+    endValue = config.getDouble("toValue")
+    restSpeedThreshold = config.getDouble("restSpeedThreshold")
+    displacementFromRestThreshold = config.getDouble("restDisplacementThreshold")
+    overshootClampingEnabled = config.getBoolean("overshootClamping")
+    iterations = if (config.hasKey("iterations")) config.getInt("iterations") else 1
+    hasFinished = iterations == 0
+    currentLoop = 0
+    timeAccumulator = 0.0
+    springStarted = false
+  }
+
+  override fun runAnimationStep(frameTimeNanos: Long) {
+    val animatedValue = requireNotNull(animatedValue) { "Animated value should not be null" }
+    val frameTimeMillis = frameTimeNanos / 1_000_000
+    if (!springStarted) {
+      if (currentLoop == 0) {
+        originalValue = animatedValue.nodeValue
+        currentLoop = 1
+      }
+      currentState.position = animatedValue.nodeValue
+      startValue = currentState.position
+      lastTime = frameTimeMillis
+      timeAccumulator = 0.0
+      springStarted = true
+    }
+    advance((frameTimeMillis - lastTime) / 1000.0)
+    lastTime = frameTimeMillis
+    animatedValue.nodeValue = currentState.position
+    if (isAtRest) {
+      if (iterations == -1 || currentLoop < iterations) { // looping animation, return to start
+        springStarted = false
+        animatedValue.nodeValue = originalValue
+        currentLoop++
+      } else { // animation has completed
+        hasFinished = true
+      }
+    }
+  }
+
+  /**
+   * get the displacement from rest for a given physics state
+   *
+   * @param state the state to measure from
+   * @return the distance displaced by
+   */
+  private fun getDisplacementDistanceForState(state: PhysicsState): Double =
+      abs(endValue - state.position)
+
+  private val isAtRest: Boolean
+    /**
+     * check if the current state is at rest
+     *
+     * @return is the spring at rest
+     */
+    get() =
+        (abs(currentState.velocity) <= restSpeedThreshold &&
+            (getDisplacementDistanceForState(currentState) <= displacementFromRestThreshold ||
+                springStiffness == 0.0))
+
+  /* Check if the spring is overshooting beyond its target. */
+  private val isOvershooting: Boolean
+    get() =
+        (springStiffness > 0 &&
+            (startValue < endValue && currentState.position > endValue ||
+                startValue > endValue && currentState.position < endValue))
+
+  private fun advance(realDeltaTime: Double) {
+    if (isAtRest) {
+      return
+    }
+
+    // clamp the amount of realTime to simulate to avoid stuttering in the UI. We should be able
+    // to catch up in a subsequent advance if necessary.
+    var adjustedDeltaTime = realDeltaTime
+    if (realDeltaTime > MAX_DELTA_TIME_SEC) {
+      adjustedDeltaTime = MAX_DELTA_TIME_SEC
+    }
+    timeAccumulator += adjustedDeltaTime
+    val c = springDamping
+    val m = springMass
+    val k = springStiffness
+    val v0 = -initialVelocity
+    val zeta = c / (2 * sqrt(k * m))
+    val omega0 = sqrt(k / m)
+    val omega1 = omega0 * sqrt(1.0 - zeta * zeta)
+    val x0 = endValue - startValue
+    val velocity: Double
+    val position: Double
+    val t = timeAccumulator
+    if (zeta < 1) {
+      // Under damped
+      val envelope = exp(-zeta * omega0 * t)
+      position =
+          (endValue -
+              envelope *
+                  ((v0 + zeta * omega0 * x0) / omega1 * sin(omega1 * t) + x0 * cos(omega1 * t)))
+      // This looks crazy -- it's actually just the derivative of the
+      // oscillation function
+      velocity =
+          ((zeta *
+              omega0 *
+              envelope *
+              (sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 + x0 * cos(omega1 * t))) -
+              envelope *
+                  (cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * sin(omega1 * t)))
+    } else {
+      // Critically damped spring
+      val envelope = exp(-omega0 * t)
+      position = endValue - envelope * (x0 + (v0 + omega0 * x0) * t)
+      velocity = envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0))
+    }
+    currentState.position = position
+    currentState.velocity = velocity
+
+    // End the spring immediately if it is overshooting and overshoot clamping is enabled.
+    // Also make sure that if the spring was considered within a resting threshold that it's now
+    // snapped to its end value.
+    if (isAtRest || overshootClampingEnabled && isOvershooting) {
+      // Don't call setCurrentValue because that forces a call to onSpringUpdate
+      if (springStiffness > 0) {
+        startValue = endValue
+        currentState.position = endValue
+      } else {
+        endValue = currentState.position
+        startValue = endValue
+      }
+      currentState.velocity = 0.0
+    }
+  }
+
+  companion object {
+    // maximum amount of time to simulate per physics iteration in seconds (4 frames at 60 FPS)
+    private const val MAX_DELTA_TIME_SEC = 0.064
+  }
+}

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

@@ -0,0 +1,61 @@
+/*
+ * 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.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Native counterpart of style animated node (see AnimatedStyle class in AnimatedImplementation.js)
+ */
+internal class StyleAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : AnimatedNode() {
+  private val propMapping: Map<String, Int>
+
+  init {
+    val style = config.getMap("style")
+    val iter = style?.keySetIterator()
+    propMapping =
+        buildMap() {
+          while (iter != null && iter.hasNextKey()) {
+            val propKey = iter.nextKey()
+            put(propKey, style.getInt(propKey))
+          }
+        }
+  }
+
+  public fun collectViewUpdates(propsMap: JavaOnlyMap) {
+    for ((key, value) in propMapping) {
+      val node = nativeAnimatedNodesManager.getNodeById(value)
+      requireNotNull(node) { "Mapped style node does not exist" }
+      if (node is TransformAnimatedNode) {
+        node.collectViewUpdates(propsMap)
+      } else if (node is ValueAnimatedNode) {
+        val animatedObject = node.getAnimatedObject()
+        if (animatedObject is Int) {
+          propsMap.putInt(key, animatedObject)
+        } else if (animatedObject is String) {
+          propsMap.putString(key, animatedObject)
+        } else {
+          propsMap.putDouble(key, node.getValue())
+        }
+      } else if (node is ColorAnimatedNode) {
+        propsMap.putInt(key, node.color)
+      } else if (node is ObjectAnimatedNode) {
+        node.collectViewUpdates(key, propsMap)
+      } else {
+        throw IllegalArgumentException(
+            "Unsupported type of node used in property node ${node.javaClass}")
+      }
+    }
+  }
+
+  override fun prettyPrint(): String = "StyleAnimatedNode[$tag] mPropMapping: $propMapping"
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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 that plays a role of value aggregator. It takes two or more value nodes as an input
+ * and outputs a difference of values outputted by those nodes.
+ */
+internal class SubtractionAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : ValueAnimatedNode() {
+  private val 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() {
+    for (i in inputNodes.indices) {
+      val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNodes[i])
+      if (animatedNode != null && animatedNode is ValueAnimatedNode) {
+        val value = animatedNode.getValue()
+        if (i == 0) {
+          nodeValue = value
+        } else {
+          nodeValue -= value
+        }
+      } else {
+        throw JSApplicationCausedNativeException(
+            "Illegal node ID set as an input for Animated.subtract node")
+      }
+    }
+  }
+
+  override fun prettyPrint(): String =
+      "SubtractionAnimatedNode[$tag]: input nodes: $inputNodes - super: ${super.prettyPrint()}"
+}

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

@@ -0,0 +1,36 @@
+/*
+ * 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.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+
+internal class TrackingAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : AnimatedNode() {
+  private val animationConfig: JavaOnlyMap = JavaOnlyMap.deepClone(config.getMap("animationConfig"))
+  private val animationId: Int = config.getInt("animationId")
+  private val toValueNode: Int = config.getInt("toValue")
+  private val valueNode: Int = config.getInt("value")
+
+  public override fun update() {
+    val toValue = nativeAnimatedNodesManager.getNodeById(toValueNode)
+    val valAnimatedNode = toValue as? ValueAnimatedNode
+    if (valAnimatedNode != null) {
+      animationConfig.putDouble("toValue", valAnimatedNode.getValue())
+    } else {
+      animationConfig.putNull("toValue")
+    }
+    nativeAnimatedNodesManager.startAnimatingNode(animationId, valueNode, animationConfig, null)
+  }
+
+  public override fun prettyPrint(): String =
+      "TrackingAnimatedNode[$tag]: animationID: $animationId toValueNode: $toValueNode " +
+          "valueNode: $valueNode animationConfig: $animationConfig"
+}

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

@@ -0,0 +1,87 @@
+/*
+ * 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.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Native counterpart of transform animated node (see AnimatedTransform class in
+ * AnimatedImplementation.js)
+ */
+internal class TransformAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : AnimatedNode() {
+  private val transformConfigs: MutableList<TransformConfig>
+
+  init {
+    val transforms = config.getArray("transforms")
+    transformConfigs =
+        if (transforms == null) mutableListOf()
+        else
+            MutableList<TransformConfig>(transforms.size()) { i ->
+              val transformConfigMap = transforms.getMap(i)
+              val property = transformConfigMap.getString("property")
+              val type = transformConfigMap.getString("type")
+              if (type == "animated") {
+                val transformConfig = AnimatedTransformConfig()
+                transformConfig.property = property
+                transformConfig.nodeTag = transformConfigMap.getInt("nodeTag")
+                transformConfig
+              } else {
+                val transformConfig = StaticTransformConfig()
+                transformConfig.property = property
+                transformConfig.value = transformConfigMap.getDouble("value")
+                transformConfig
+              }
+            }
+  }
+
+  public fun collectViewUpdates(propsMap: JavaOnlyMap) {
+    val transforms =
+        MutableList<JavaOnlyMap>(transformConfigs.size) { i ->
+          val transformConfig = transformConfigs[i]
+          val transform =
+              if (transformConfig is AnimatedTransformConfig) {
+                val nodeTag = transformConfig.nodeTag
+                val node = nativeAnimatedNodesManager.getNodeById(nodeTag)
+                if (node == null) {
+                  throw IllegalArgumentException("Mapped style node does not exist")
+                } else if (node is ValueAnimatedNode) {
+                  node.getValue()
+                } else {
+                  throw IllegalArgumentException(
+                      "Unsupported type of node used as a transform child " +
+                          "node " +
+                          node.javaClass)
+                }
+              } else {
+                (transformConfig as StaticTransformConfig).value
+              }
+          JavaOnlyMap.of(transformConfig.property, transform)
+        }
+    propsMap.putArray("transform", JavaOnlyArray.from(transforms))
+  }
+
+  override fun prettyPrint(): String =
+      "TransformAnimatedNode[$tag]: transformConfigs: $transformConfigs"
+
+  private open inner class TransformConfig {
+    var property: String? = null
+  }
+
+  private inner class AnimatedTransformConfig : TransformConfig() {
+    var nodeTag = 0
+  }
+
+  private inner class StaticTransformConfig : TransformConfig() {
+    var value = 0.0
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/ValueAnimatedNode.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.ReadableMap
+
+/**
+ * Basic type of animated node that maps directly from {@code Animated.Value(x)} of Animated.js
+ * library.
+ */
+public open class ValueAnimatedNode(config: ReadableMap? = null) : AnimatedNode() {
+  @JvmField internal var nodeValue: Double = config?.getDouble("value") ?: Double.NaN
+  @JvmField internal var offset: Double = config?.getDouble("offset") ?: 0.0
+  private var valueListener: AnimatedNodeValueListener? = null
+
+  public fun getValue(): Double {
+    if ((offset + nodeValue).isNaN()) {
+      this.update()
+    }
+    return offset + nodeValue
+  }
+
+  public open fun getAnimatedObject(): Any? = null
+
+  public fun flattenOffset(): Unit {
+    nodeValue += offset
+    offset = 0.0
+  }
+
+  public fun extractOffset(): Unit {
+    offset += nodeValue
+    nodeValue = 0.0
+  }
+
+  public fun onValueUpdate(): Unit {
+    valueListener?.onValueUpdate(getValue())
+  }
+
+  public fun setValueListener(listener: AnimatedNodeValueListener?): Unit {
+    valueListener = listener
+  }
+
+  override public fun prettyPrint(): String =
+      "ValueAnimatedNode[$tag]: value: $nodeValue offset: $offset"
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ActivityEventListener.java

@@ -22,4 +22,8 @@ public interface ActivityEventListener {
 
   /** Called when a new intent is passed to the activity */
   void onNewIntent(Intent intent);
+
+  /** Called when host activity receives an {@link Activity#onUserLeaveHint()} call. */
+  default void onUserLeaveHint(Activity activity) {}
+  ;
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseJavaModule.java

@@ -13,6 +13,7 @@ import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
+import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.annotations.DeprecatedInNewArchitecture;
 import com.facebook.react.common.annotations.StableReactNativeAPI;
@@ -54,6 +55,8 @@ public abstract class BaseJavaModule implements NativeModule {
   public static final String METHOD_TYPE_PROMISE = "promise";
   public static final String METHOD_TYPE_SYNC = "sync";
 
+  protected @Nullable CxxCallbackImpl mEventEmitterCallback;
+
   private final @Nullable ReactApplicationContext mReactApplicationContext;
 
   public BaseJavaModule() {
@@ -129,4 +132,9 @@ public abstract class BaseJavaModule implements NativeModule {
     }
     return null;
   }
+
+  @DoNotStrip
+  private final void setEventEmitterCallback(CxxCallbackImpl eventEmitterCallback) {
+    mEventEmitterCallback = eventEmitterCallback;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ColorPropConverter.java

@@ -217,6 +217,11 @@ public class ColorPropConverter {
 
     int resourceId = context.getResources().getIdentifier(resourceName, ATTR, packageName);
 
+    // If resourceId is 0, try resolving with the android package name
+    if (resourceId == 0) {
+      resourceId = context.getResources().getIdentifier(resourceName, ATTR, "android");
+    }
+
     TypedValue outValue = new TypedValue();
     Resources.Theme theme = context.getTheme();
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/DynamicFromMap.java

@@ -9,6 +9,7 @@ package com.facebook.react.bridge;
 
 import androidx.annotation.Nullable;
 import androidx.core.util.Pools.SimplePool;
+import java.util.Objects;
 
 /** Implementation of Dynamic wrapping a ReadableMap. */
 class DynamicFromMap implements Dynamic {
@@ -96,7 +97,7 @@ class DynamicFromMap implements Dynamic {
     if (mMap == null || mName == null) {
       throw new IllegalStateException("This dynamic value has been recycled");
     }
-    return mMap.getMap(mName);
+    return Objects.requireNonNull(mMap.getMap(mName));
   }
 
   @Override

package/ReactAndroid/src/main/java/com/facebook/react/bridge/DynamicFromObject.java

@@ -80,7 +80,10 @@ public class DynamicFromObject implements Dynamic {
     if (mObject instanceof ReadableArray) {
       return ReadableType.Array;
     }
-    FLog.e(ReactConstants.TAG, "Unmapped object type " + mObject.getClass().getName());
+    FLog.e(
+        ReactConstants.TAG,
+        "Unmapped object type "
+            + (mObject == null ? "<NULL object>" : mObject.getClass().getName()));
     return ReadableType.Null;
   }
 }

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

@@ -0,0 +1,51 @@
+/*
+ * 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.bridge
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.proguard.annotations.DoNotStripAny
+
+/**
+ * An implementation of [Dynamic] that has a C++ implementation.
+ *
+ * This is used to support Legacy Native Modules that have not been migrated to the new architecture
+ * and are using [Dynamic] as a parameter type.
+ */
+@DoNotStripAny
+private class DynamicNative(
+    @Suppress("NoHungarianNotation") @field:DoNotStrip private val mHybridData: HybridData?
+) : Dynamic {
+
+  override val type: ReadableType
+    get() = getTypeNative()
+
+  override val isNull: Boolean
+    get() = isNullNative()
+
+  private external fun getTypeNative(): ReadableType
+
+  private external fun isNullNative(): Boolean
+
+  external override fun asBoolean(): Boolean
+
+  // The native representation is holding the value as Double. We do the Int conversion here.
+  override fun asInt(): Int = asDouble().toInt()
+
+  external override fun asDouble(): Double
+
+  external override fun asString(): String
+
+  external override fun asArray(): ReadableArray
+
+  external override fun asMap(): ReadableMap
+
+  override fun recycle() {
+    // Noop - nothing to recycle since there is no pooling
+  }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.bridge
+
+import android.content.res.AssetManager
+
+/** An interface for classes that initialize JavaScript using [JSBundleLoader] */
+public interface JSBundleLoaderDelegate {
+  /**
+   * Load a JS bundle from Android assets. See [JSBundleLoader.createAssetLoader]
+   *
+   * @param assetManager
+   * @param assetURL
+   * @param loadSynchronously
+   */
+  public fun loadScriptFromAssets(
+      assetManager: AssetManager,
+      assetURL: String,
+      loadSynchronously: Boolean
+  )
+
+  /**
+   * Load a JS bundle from the filesystem. See [JSBundleLoader.createFileLoader] and
+   * [JSBundleLoader.createCachedBundleFromNetworkLoader]
+   *
+   * @param fileName
+   * @param sourceURL
+   * @param loadSynchronously
+   */
+  public fun loadScriptFromFile(fileName: String, sourceURL: String, loadSynchronously: Boolean)
+
+  /**
+   * Load a split JS bundle from the filesystem. See
+   * [JSBundleLoader.createCachedSplitBundleFromNetworkLoader].
+   */
+  public fun loadSplitBundleFromFile(fileName: String, sourceURL: String)
+
+  /**
+   * This API is used in situations where the JS bundle is being executed not on the device, but on
+   * a host machine. In that case, we must provide two source URLs for the JS bundle: One to be used
+   * on the device, and one to be used on the remote debugging machine.
+   *
+   * @param deviceURL A source URL that is accessible from this device.
+   * @param remoteURL A source URL that is accessible from the remote machine executing the JS.
+   */
+  public fun setSourceURLs(deviceURL: String, remoteURL: String)
+}