react-native-tvos 0.78.0-0rc4 → 0.79.0-0

package/ReactAndroid/src/main/java/com/facebook/react/HeadlessJsTaskService.kt

@@ -0,0 +1,185 @@
+/*
+ * 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
+
+import android.annotation.SuppressLint
+import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.IBinder
+import android.os.PowerManager
+import android.os.PowerManager.WakeLock
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext.Companion.getInstance
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+import java.util.concurrent.CopyOnWriteArraySet
+
+/**
+ * Base class for running JS without a UI. Generally, you only need to override [getTaskConfig],
+ * which is called for every [onStartCommand]. The result, if not `null`, is used to run a JS task.
+ *
+ * If you need more fine-grained control over how tasks are run, you can override [onStartCommand]
+ * and call [startTask] depending on your custom logic.
+ *
+ * If you're starting a `HeadlessJsTaskService` from a `BroadcastReceiver` (e.g. handling push
+ * notifications), make sure to call [acquireWakeLockNow] before returning from
+ * [BroadcastReceiver.onReceive], to make sure the device doesn't go to sleep before the service is
+ * started.
+ */
+public abstract class HeadlessJsTaskService : Service(), HeadlessJsTaskEventListener {
+  private val activeTasks: MutableSet<Int> = CopyOnWriteArraySet()
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    val taskConfig = getTaskConfig(intent)
+    return if (taskConfig != null) {
+      startTask(taskConfig)
+      START_REDELIVER_INTENT
+    } else {
+      START_NOT_STICKY
+    }
+  }
+
+  /**
+   * Called from [.onStartCommand] to create a [HeadlessJsTaskConfig] for this intent.
+   *
+   * @return a [HeadlessJsTaskConfig] to be used with [startTask], or `null` to ignore this command.
+   */
+  protected open fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? = null
+
+  override fun onBind(intent: Intent): IBinder? = null
+
+  /**
+   * Start a task. This method handles starting a new React instance if required.
+   *
+   * Has to be called on the UI thread.
+   *
+   * @param taskConfig describes what task to start and the parameters to pass to it
+   */
+  protected fun startTask(taskConfig: HeadlessJsTaskConfig) {
+    UiThreadUtil.assertOnUiThread()
+    acquireWakeLockNow(this)
+
+    val context = reactContext
+    if (context == null) {
+      createReactContextAndScheduleTask(taskConfig)
+    } else {
+      invokeStartTask(context, taskConfig)
+    }
+  }
+
+  private fun invokeStartTask(reactContext: ReactContext, taskConfig: HeadlessJsTaskConfig) {
+    val headlessJsTaskContext = getInstance(reactContext)
+    headlessJsTaskContext.addTaskEventListener(this)
+    UiThreadUtil.runOnUiThread {
+      val taskId = headlessJsTaskContext.startTask(taskConfig)
+      activeTasks.add(taskId)
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+
+    reactContext?.let { context ->
+      val headlessJsTaskContext = getInstance(context)
+      headlessJsTaskContext.removeTaskEventListener(this)
+    }
+    wakeLock?.release()
+  }
+
+  override fun onHeadlessJsTaskStart(taskId: Int): Unit = Unit
+
+  override fun onHeadlessJsTaskFinish(taskId: Int) {
+    activeTasks.remove(taskId)
+    if (activeTasks.isEmpty()) {
+      stopSelf()
+    }
+  }
+
+  /**
+   * Get the [ReactNativeHost] used by this app. By default, assumes [getApplication] is an instance
+   * of [ReactApplication] and calls [ReactApplication.reactNativeHost].
+   *
+   * Override this method if your application class does not implement `ReactApplication` or you
+   * simply have a different mechanism for storing a `ReactNativeHost`, e.g. as a static field
+   * somewhere.
+   */
+  protected val reactNativeHost: ReactNativeHost
+    get() = (application as ReactApplication).reactNativeHost
+
+  /**
+   * Get the [ReactHost] used by this app. By default, assumes [.getApplication] is an instance of
+   * [ReactApplication] and calls [ReactApplication.getReactHost]. This method assumes it is called
+   * in new architecture and returns null if not.
+   */
+  protected val reactHost: ReactHost?
+    get() = (application as ReactApplication).reactHost
+
+  protected val reactContext: ReactContext?
+    get() {
+      if (ReactNativeFeatureFlags.enableBridgelessArchitecture()) {
+        val reactHost =
+            checkNotNull(reactHost) { "ReactHost is not initialized in New Architecture" }
+        return reactHost.currentReactContext
+      } else {
+        val reactInstanceManager = reactNativeHost.reactInstanceManager
+        return reactInstanceManager.currentReactContext
+      }
+    }
+
+  private fun createReactContextAndScheduleTask(taskConfig: HeadlessJsTaskConfig) {
+    if (ReactNativeFeatureFlags.enableBridgelessArchitecture()) {
+      val reactHost = checkNotNull(reactHost)
+      reactHost.addReactInstanceEventListener(
+          object : ReactInstanceEventListener {
+            override fun onReactContextInitialized(context: ReactContext) {
+              invokeStartTask(context, taskConfig)
+              reactHost.removeReactInstanceEventListener(this)
+            }
+          })
+      reactHost.start()
+    } else {
+      val reactInstanceManager = reactNativeHost.reactInstanceManager
+      reactInstanceManager.addReactInstanceEventListener(
+          object : ReactInstanceEventListener {
+            override fun onReactContextInitialized(context: ReactContext) {
+              invokeStartTask(context, taskConfig)
+              reactInstanceManager.removeReactInstanceEventListener(this)
+            }
+          })
+      reactInstanceManager.createReactContextInBackground()
+    }
+  }
+
+  public companion object {
+    private var wakeLock: WakeLock? = null
+
+    /**
+     * Acquire a wake lock to ensure the device doesn't go to sleep while processing background
+     * tasks.
+     */
+    @JvmStatic
+    @SuppressLint("WakelockTimeout")
+    public fun acquireWakeLockNow(context: Context) {
+      if (wakeLock == null || wakeLock?.isHeld == false) {
+        val powerManager = checkNotNull(context.getSystemService(POWER_SERVICE) as PowerManager)
+        wakeLock =
+            powerManager
+                .newWakeLock(
+                    PowerManager.PARTIAL_WAKE_LOCK, HeadlessJsTaskService::class.java.canonicalName)
+                .also { lock ->
+                  lock.setReferenceCounted(false)
+                  lock.acquire()
+                }
+      }
+    }
+  }
+}

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

@@ -10,13 +10,15 @@ package com.facebook.react;
 import android.content.ComponentCallbacks2;
 import android.content.Context;
 import android.content.res.Configuration;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.MemoryPressureListener;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /** Translates and routes memory pressure events. */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class MemoryPressureRouter implements ComponentCallbacks2 {
   private final CopyOnWriteArrayList<MemoryPressureListener> mListeners =
-      new CopyOnWriteArrayList();
+      new CopyOnWriteArrayList<>();
 
   public MemoryPressureRouter(Context context) {
     context.getApplicationContext().registerComponentCallbacks(this);

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

@@ -20,6 +20,7 @@ import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.common.annotations.DeprecatedInNewArchitecture;
+import com.facebook.react.interfaces.fabric.ReactSurface;
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.core.PermissionListener;
 import com.facebook.systrace.Systrace;
@@ -156,6 +157,14 @@ public class ReactActivityDelegate {
     getPlainActivity().setContentView(mReactDelegate.getReactRootView());
   }
 
+  public void setReactSurface(ReactSurface reactSurface) {
+    mReactDelegate.setReactSurface(reactSurface);
+  }
+
+  public void setReactRootView(ReactRootView reactRootView) {
+    mReactDelegate.setReactRootView(reactRootView);
+  }
+
   public void onUserLeaveHint() {
     if (mReactDelegate != null) {
       mReactDelegate.onUserLeaveHint();

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

@@ -355,6 +355,14 @@ public class ReactDelegate {
     }
   }
 
+  public void setReactSurface(ReactSurface reactSurface) {
+    mReactSurface = reactSurface;
+  }
+
+  public void setReactRootView(ReactRootView reactRootView) {
+    mReactRootView = reactRootView;
+  }
+
   @Nullable
   public ReactRootView getReactRootView() {
     if (ReactNativeFeatureFlags.enableBridgelessArchitecture()) {

package/ReactAndroid/src/main/java/com/facebook/react/ReactHost.kt

@@ -20,9 +20,9 @@ import com.facebook.react.interfaces.fabric.ReactSurface
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 
 /**
- * A ReactHost is an object that manages a single {@link ReactInstance}. A ReactHost can be
- * constructed without initializing the ReactInstance, and it will continue to exist after the
- * instance is destroyed.
+ * A ReactHost is an object that manages a single [ReactInstance]. A ReactHost can be constructed
+ * without initializing the ReactInstance, and it will continue to exist after the instance is
+ * destroyed.
  *
  * The implementation of this interface should be Thread Safe
  */
@@ -187,6 +187,6 @@ public interface ReactHost {
   /** Add a listener to be notified of ReactInstance events. */
   public fun addReactInstanceEventListener(listener: ReactInstanceEventListener)
 
-  /** Remove a listener previously added with {@link #addReactInstanceEventListener}. */
+  /** Remove a listener previously added with [addReactInstanceEventListener]. */
   public fun removeReactInstanceEventListener(listener: ReactInstanceEventListener)
 }

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

@@ -56,12 +56,10 @@ import com.facebook.react.bridge.CatalystInstance;
 import com.facebook.react.bridge.CatalystInstanceImpl;
 import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.JSExceptionHandler;
-import com.facebook.react.bridge.JavaJSExecutor;
 import com.facebook.react.bridge.JavaScriptExecutor;
 import com.facebook.react.bridge.JavaScriptExecutorFactory;
 import com.facebook.react.bridge.NativeModuleRegistry;
 import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
-import com.facebook.react.bridge.ProxyJavaScriptExecutor;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactCxxErrorHandler;
@@ -325,11 +323,6 @@ public class ReactInstanceManager {
 
   private ReactInstanceDevHelper createDevHelperInterface() {
     return new ReactInstanceDevHelper() {
-      @Override
-      public void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
-        ReactInstanceManager.this.onReloadWithJSDebugger(jsExecutorFactory);
-      }
-
       @Override
       public void onJSBundleLoadedFromServer() {
         ReactInstanceManager.this.onJSBundleLoadedFromServer();
@@ -502,14 +495,11 @@ public class ReactInstanceManager {
                         if (packagerIsRunning) {
                           mDevSupportManager.handleReloadJS();
                         } else if (mDevSupportManager.hasUpToDateJSBundleInCache()
-                            && !devSettings.isRemoteJSDebugEnabled()
                             && !mUseFallbackBundle) {
                           // If there is a up-to-date bundle downloaded from server,
                           // with remote JS debugging disabled, always use that.
                           onJSBundleLoadedFromServer();
                         } else {
-                          // If dev server is down, disable the remote JS debugging.
-                          devSettings.setRemoteJSDebugEnabled(false);
                           recreateReactContextInBackgroundFromBundleLoader();
                         }
                       });
@@ -1155,16 +1145,6 @@ public class ReactInstanceManager {
     destroy();
   }
 
-  @ThreadConfined(UI)
-  private void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
-    FLog.d(ReactConstants.TAG, "ReactInstanceManager.onReloadWithJSDebugger()");
-    recreateReactContextInBackground(
-        new ProxyJavaScriptExecutor.Factory(jsExecutorFactory),
-        JSBundleLoader.createRemoteDebuggerBundleLoader(
-            mDevSupportManager.getJSBundleURLForRemoteDebugging(),
-            mDevSupportManager.getSourceUrl()));
-  }
-
   @ThreadConfined(UI)
   private void onJSBundleLoadedFromServer() {
     FLog.d(ReactConstants.TAG, "ReactInstanceManager.onJSBundleLoadedFromServer()");

package/ReactAndroid/src/main/java/com/facebook/react/ReactPackageLogger.kt

@@ -8,9 +8,8 @@
 package com.facebook.react
 
 /** Interface for the bridge to call for TTI start and end markers. */
-public interface ReactPackageLogger {
+internal interface ReactPackageLogger {
+  fun startProcessPackage(): Unit
 
-  public fun startProcessPackage(): Unit
-
-  public fun endProcessPackage(): Unit
+  fun endProcessPackage(): Unit
 }

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

@@ -44,13 +44,13 @@ public abstract class AnimatedNode {
 
   /**
    * Subclasses may want to override this method in order to store a reference to the parent of a
-   * given node that can then be used to calculate current node's value in {@link #update}. In that
-   * case it is important to also override {@link #onDetachedFromNode} to clear that reference once
-   * current node gets detached.
+   * given node that can then be used to calculate current node's value in [update]. In that case it
+   * is important to also override [onDetachedFromNode] to clear that reference once current node
+   * gets detached.
    */
   public open fun onAttachedToNode(parent: AnimatedNode): Unit = Unit
 
-  /** See {@link #onAttachedToNode} */
+  /** See [onAttachedToNode] */
   public open fun onDetachedFromNode(parent: AnimatedNode): Unit = Unit
 
   /**

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

@@ -8,6 +8,6 @@
 package com.facebook.react.animated
 
 /** Interface used to listen to [ValueAnimatedNode] updates. */
-public fun interface AnimatedNodeValueListener {
-  public fun onValueUpdate(value: Double)
+internal fun interface AnimatedNodeValueListener {
+  fun onValueUpdate(value: Double)
 }

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

@@ -10,6 +10,6 @@ package com.facebook.react.animated
 import com.facebook.react.bridge.ReadableMap
 
 /** Indicates that AnimatedNode is able to receive native config updates. */
-public fun interface AnimatedNodeWithUpdateableConfig {
-  public fun onUpdateConfig(config: ReadableMap?)
+internal fun interface AnimatedNodeWithUpdateableConfig {
+  fun onUpdateConfig(config: ReadableMap?)
 }

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

@@ -28,7 +28,7 @@ internal class DecayAnimation(config: ReadableMap) : AnimationDriver() {
     resetConfig(config)
   }
 
-  public override fun resetConfig(config: ReadableMap): Unit {
+  override fun resetConfig(config: ReadableMap): Unit {
     velocity = config.getDouble("velocity")
     deceleration = config.getDouble("deceleration")
     startFrameTimeMillis = -1
@@ -39,7 +39,7 @@ internal class DecayAnimation(config: ReadableMap) : AnimationDriver() {
     hasFinished = iterations == 0
   }
 
-  public override fun runAnimationStep(frameTimeNanos: Long) {
+  override fun runAnimationStep(frameTimeNanos: Long) {
     val animatedValue = requireNotNull(animatedValue) { "Animated value should not be null" }
     val frameTimeMillis = frameTimeNanos / 1000000
     if (startFrameTimeMillis == -1L) {

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

@@ -19,7 +19,7 @@ import java.util.regex.Pattern
  *
  * Currently only a linear interpolation is supported on an input range of an arbitrary size.
  */
-public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode() {
+internal class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode() {
   private enum class OutputType {
     Number,
     Color,
@@ -98,10 +98,10 @@ public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode(
   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"
+  companion object {
+    const val EXTRAPOLATE_TYPE_IDENTITY: String = "identity"
+    const val EXTRAPOLATE_TYPE_CLAMP: String = "clamp"
+    const val EXTRAPOLATE_TYPE_EXTEND: String = "extend"
 
     private val numericPattern: Pattern =
         Pattern.compile("[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?")
@@ -152,7 +152,7 @@ public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode(
       return outputRange
     }
 
-    public fun interpolate(
+    fun interpolate(
         value: Double,
         inputMin: Double,
         inputMax: Double,
@@ -194,7 +194,7 @@ public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode(
       } else outputMin + (outputMax - outputMin) * (result - inputMin) / (inputMax - inputMin)
     }
 
-    public fun interpolate(
+    fun interpolate(
         value: Double,
         inputRange: DoubleArray,
         outputRange: DoubleArray,
@@ -212,11 +212,7 @@ public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode(
           extrapolateRight)
     }
 
-    public fun interpolateColor(
-        value: Double,
-        inputRange: DoubleArray,
-        outputRange: IntArray
-    ): Int {
+    fun interpolateColor(value: Double, inputRange: DoubleArray, outputRange: IntArray): Int {
       val rangeIndex = findRangeIndex(value, inputRange)
       val outputMin = outputRange[rangeIndex]
       val outputMax = outputRange[rangeIndex + 1]
@@ -234,7 +230,7 @@ public class InterpolationAnimatedNode(config: ReadableMap) : ValueAnimatedNode(
       return ColorUtils.blendARGB(outputMin, outputMax, ratio.toFloat())
     }
 
-    public fun interpolateString(
+    fun interpolateString(
         pattern: String,
         value: Double,
         inputRange: DoubleArray,

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

@@ -18,7 +18,7 @@ internal class ModulusAnimatedNode(
   private val inputNode: Int = config.getInt("input")
   private val modulus: Double = config.getDouble("modulus")
 
-  override public fun update() {
+  override fun update() {
     val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNode)
     if (animatedNode is ValueAnimatedNode) {
       val animatedNodeValue = animatedNode.getValue()
@@ -29,7 +29,7 @@ internal class ModulusAnimatedNode(
     }
   }
 
-  override public fun prettyPrint(): String {
+  override fun prettyPrint(): String {
     return "NativeAnimatedNodesManager[$tag] inputNode: $inputNode modulus: $modulus super: ${super.prettyPrint()}"
   }
 }

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

@@ -14,6 +14,7 @@ import androidx.annotation.UiThread;
 import com.facebook.common.logging.FLog;
 import com.facebook.fbreact.specs.NativeAnimatedModuleSpec;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
@@ -87,6 +88,7 @@ import java.util.concurrent.atomic.AtomicReference;
  * This isolates us from the problems that may be caused by concurrent updates of animated graph
  * while UI thread is "executing" the animation loop.
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 @ReactModule(name = NativeAnimatedModuleSpec.NAME)
 public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     implements LifecycleEventListener, UIManagerListener {
@@ -117,6 +119,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     OP_CODE_ADD_LISTENER(20), // ios only
     OP_CODE_REMOVE_LISTENERS(21); // ios only
 
+    // NULLSAFE_FIXME[Field Not Nullable]
     private static BatchExecutionOpCodes[] valueMap = null;
     private final int value;
 
@@ -371,7 +374,9 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
       }
     }
 
+    // NULLSAFE_FIXME[Parameter Not Nullable]
     mPreOperations.executeBatch(batchNumber, getNodesManager());
+    // NULLSAFE_FIXME[Parameter Not Nullable]
     mOperations.executeBatch(batchNumber, getNodesManager());
   }
 
@@ -391,7 +396,9 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     UIBlock preOperationsUIBlock =
         new UIBlock() {
           @Override
+          // NULLSAFE_FIXME[Inconsistent Subclass Parameter Annotation]
           public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+            // NULLSAFE_FIXME[Parameter Not Nullable]
             mPreOperations.executeBatch(frameNo, getNodesManager());
           }
         };
@@ -399,7 +406,9 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     UIBlock operationsUIBlock =
         new UIBlock() {
           @Override
+          // NULLSAFE_FIXME[Inconsistent Subclass Parameter Annotation]
           public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+            // NULLSAFE_FIXME[Parameter Not Nullable]
             mOperations.executeBatch(frameNo, getNodesManager());
           }
         };
@@ -1119,13 +1128,16 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
               switch (command) {
                 case OP_CODE_CREATE_ANIMATED_NODE:
                   animatedNodesManager.createAnimatedNode(
+                      // NULLSAFE_FIXME[Parameter Not Nullable]
                       opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
                   break;
                 case OP_CODE_UPDATE_ANIMATED_NODE_CONFIG:
                   animatedNodesManager.updateAnimatedNodeConfig(
+                      // NULLSAFE_FIXME[Parameter Not Nullable]
                       opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
                   break;
                 case OP_CODE_GET_VALUE:
+                  // NULLSAFE_FIXME[Parameter Not Nullable]
                   animatedNodesManager.getValue(opsAndArgs.getInt(i++), null);
                   break;
                 case OP_START_LISTENING_TO_ANIMATED_NODE_VALUE:
@@ -1163,6 +1175,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
                     enqueueFrameCallback();
                   }
                   animatedNodesManager.startAnimatingNode(
+                      // NULLSAFE_FIXME[Parameter Not Nullable]
                       opsAndArgs.getInt(i++), opsAndArgs.getInt(i++), opsAndArgs.getMap(i++), null);
                   break;
                 case OP_CODE_STOP_ANIMATION:
@@ -1200,12 +1213,14 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
                   break;
                 case OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW:
                   animatedNodesManager.addAnimatedEventToView(
+                      // NULLSAFE_FIXME[Parameter Not Nullable]
                       opsAndArgs.getInt(i++), opsAndArgs.getString(i++), opsAndArgs.getMap(i++));
                   break;
                 case OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW:
                   viewTag = opsAndArgs.getInt(i++);
                   decrementInFlightAnimationsForViewTag(viewTag);
                   animatedNodesManager.removeAnimatedEventFromView(
+                      // NULLSAFE_FIXME[Parameter Not Nullable]
                       viewTag, opsAndArgs.getString(i++), opsAndArgs.getInt(i++));
                   break;
                 case OP_CODE_ADD_LISTENER: