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

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/MessageQueueThreadImpl.java

@@ -11,11 +11,11 @@ import android.os.Looper;
 import android.os.Process;
 import android.os.SystemClock;
 import android.util.Pair;
+import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.AssertionException;
 import com.facebook.react.bridge.SoftAssertions;
-import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.futures.SimpleSettableFuture;
 import java.util.concurrent.Callable;
@@ -29,7 +29,7 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
   private final Looper mLooper;
   private final MessageQueueThreadHandler mHandler;
   private final String mAssertionErrorMessage;
-  private MessageQueueThreadPerfStats mPerfStats;
+  private final @Nullable MessageQueueThreadPerfStats mPerfStats;
   private volatile boolean mIsFinished = false;
 
   private MessageQueueThreadImpl(
@@ -41,7 +41,7 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
       String name,
       Looper looper,
       QueueThreadExceptionHandler exceptionHandler,
-      MessageQueueThreadPerfStats stats) {
+      @Nullable MessageQueueThreadPerfStats stats) {
     mName = name;
     mLooper = looper;
     mHandler = new MessageQueueThreadHandler(looper, exceptionHandler);
@@ -73,14 +73,11 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
   public <T> Future<T> callOnQueue(final Callable<T> callable) {
     final SimpleSettableFuture<T> future = new SimpleSettableFuture<>();
     runOnQueue(
-        new Runnable() {
-          @Override
-          public void run() {
-            try {
-              future.set(callable.call());
-            } catch (Exception e) {
-              future.setException(e);
-            }
+        () -> {
+          try {
+            future.set(callable.call());
+          } catch (Exception e) {
+            future.setException(e);
           }
         });
     return future;
@@ -135,6 +132,7 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
     }
   }
 
+  @Nullable
   @DoNotStrip
   @Override
   public MessageQueueThreadPerfStats getPerfStats() {
@@ -146,13 +144,10 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
   public void resetPerfStats() {
     assignToPerfStats(mPerfStats, -1, -1);
     runOnQueue(
-        new Runnable() {
-          @Override
-          public void run() {
-            long wallTime = SystemClock.uptimeMillis();
-            long cpuTime = SystemClock.currentThreadTimeMillis();
-            assignToPerfStats(mPerfStats, wallTime, cpuTime);
-          }
+        () -> {
+          long wallTime = SystemClock.uptimeMillis();
+          long cpuTime = SystemClock.currentThreadTimeMillis();
+          assignToPerfStats(mPerfStats, wallTime, cpuTime);
         });
   }
 
@@ -162,7 +157,11 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
     return mLooper.getQueue().isIdle();
   }
 
-  private static void assignToPerfStats(MessageQueueThreadPerfStats stats, long wall, long cpu) {
+  private static void assignToPerfStats(
+      @Nullable MessageQueueThreadPerfStats stats, long wall, long cpu) {
+    if (stats == null) {
+      return;
+    }
     stats.wallTime = wall;
     stats.cpuTime = cpu;
   }
@@ -192,21 +191,7 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
    */
   private static MessageQueueThreadImpl createForMainThread(
       String name, QueueThreadExceptionHandler exceptionHandler) {
-    final MessageQueueThreadImpl mqt =
-        new MessageQueueThreadImpl(name, Looper.getMainLooper(), exceptionHandler);
-
-    if (UiThreadUtil.isOnUiThread()) {
-      Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
-    } else {
-      UiThreadUtil.runOnUiThread(
-          new Runnable() {
-            @Override
-            public void run() {
-              Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
-            }
-          });
-    }
-    return mqt;
+    return new MessageQueueThreadImpl(name, Looper.getMainLooper(), exceptionHandler);
   }
 
   /**
@@ -218,22 +203,18 @@ public class MessageQueueThreadImpl implements MessageQueueThread {
       final String name, long stackSize, QueueThreadExceptionHandler exceptionHandler) {
     final SimpleSettableFuture<Pair<Looper, MessageQueueThreadPerfStats>> dataFuture =
         new SimpleSettableFuture<>();
-    long startTimeMillis;
     Thread bgThread =
         new Thread(
             null,
-            new Runnable() {
-              @Override
-              public void run() {
-                Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
-                Looper.prepare();
-                MessageQueueThreadPerfStats stats = new MessageQueueThreadPerfStats();
-                long wallTime = SystemClock.uptimeMillis();
-                long cpuTime = SystemClock.currentThreadTimeMillis();
-                assignToPerfStats(stats, wallTime, cpuTime);
-                dataFuture.set(new Pair<>(Looper.myLooper(), stats));
-                Looper.loop();
-              }
+            () -> {
+              Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
+              Looper.prepare();
+              MessageQueueThreadPerfStats stats = new MessageQueueThreadPerfStats();
+              long wallTime = SystemClock.uptimeMillis();
+              long cpuTime = SystemClock.currentThreadTimeMillis();
+              assignToPerfStats(stats, wallTime, cpuTime);
+              dataFuture.set(new Pair<>(Looper.myLooper(), stats));
+              Looper.loop();
             },
             "mqt_" + name,
             stackSize);

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/ReactQueueConfigurationImpl.java

@@ -8,8 +8,6 @@
 package com.facebook.react.bridge.queue;
 
 import android.os.Looper;
-import com.facebook.react.common.MapBuilder;
-import java.util.Map;
 
 public class ReactQueueConfigurationImpl implements ReactQueueConfiguration {
 
@@ -56,24 +54,12 @@ public class ReactQueueConfigurationImpl implements ReactQueueConfiguration {
 
   public static ReactQueueConfigurationImpl create(
       ReactQueueConfigurationSpec spec, QueueThreadExceptionHandler exceptionHandler) {
-    Map<MessageQueueThreadSpec, MessageQueueThreadImpl> specsToThreads = MapBuilder.newHashMap();
-
-    MessageQueueThreadSpec uiThreadSpec = MessageQueueThreadSpec.mainThreadSpec();
-    MessageQueueThreadImpl uiThread = MessageQueueThreadImpl.create(uiThreadSpec, exceptionHandler);
-    specsToThreads.put(uiThreadSpec, uiThread);
-
-    MessageQueueThreadImpl jsThread = specsToThreads.get(spec.getJSQueueThreadSpec());
-    if (jsThread == null) {
-      jsThread = MessageQueueThreadImpl.create(spec.getJSQueueThreadSpec(), exceptionHandler);
-    }
-
+    MessageQueueThreadImpl uiThread =
+        MessageQueueThreadImpl.create(MessageQueueThreadSpec.mainThreadSpec(), exceptionHandler);
+    MessageQueueThreadImpl jsThread =
+        MessageQueueThreadImpl.create(spec.getJSQueueThreadSpec(), exceptionHandler);
     MessageQueueThreadImpl nativeModulesThread =
-        specsToThreads.get(spec.getNativeModulesQueueThreadSpec());
-    if (nativeModulesThread == null) {
-      nativeModulesThread =
-          MessageQueueThreadImpl.create(spec.getNativeModulesQueueThreadSpec(), exceptionHandler);
-    }
-
+        MessageQueueThreadImpl.create(spec.getNativeModulesQueueThreadSpec(), exceptionHandler);
     return new ReactQueueConfigurationImpl(uiThread, nativeModulesThread, jsThread);
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/ReactQueueConfigurationSpec.java

@@ -21,7 +21,7 @@ public class ReactQueueConfigurationSpec {
   private final MessageQueueThreadSpec mNativeModulesQueueThreadSpec;
   private final MessageQueueThreadSpec mJSQueueThreadSpec;
 
-  private ReactQueueConfigurationSpec(
+  public ReactQueueConfigurationSpec(
       MessageQueueThreadSpec nativeModulesQueueThreadSpec,
       MessageQueueThreadSpec jsQueueThreadSpec) {
     mNativeModulesQueueThreadSpec = nativeModulesQueueThreadSpec;
@@ -41,11 +41,9 @@ public class ReactQueueConfigurationSpec {
   }
 
   public static ReactQueueConfigurationSpec createDefault() {
-    MessageQueueThreadSpec spec = MessageQueueThreadSpec.newBackgroundThreadSpec("native_modules");
-    return builder()
-        .setJSQueueThreadSpec(MessageQueueThreadSpec.newBackgroundThreadSpec("js"))
-        .setNativeModulesQueueThreadSpec(spec)
-        .build();
+    return new ReactQueueConfigurationSpec(
+        MessageQueueThreadSpec.newBackgroundThreadSpec("native_modules"),
+        MessageQueueThreadSpec.newBackgroundThreadSpec("js"));
   }
 
   public static class Builder {

package/ReactAndroid/src/main/java/com/facebook/react/common/ClearableSynchronizedPool.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.common
+
+import androidx.core.util.Pools.Pool
+
+/**
+ * Like [androidx.core.util.Pools.SynchronizedPool] with the option to clear the pool (e.g. on
+ * memory pressure).
+ */
+public class ClearableSynchronizedPool<T : Any>(maxSize: Int) : Pool<T> {
+
+  private val pool: Array<Any?> = arrayOfNulls(maxSize)
+  private var size = 0
+
+  @Synchronized
+  @Suppress("UNCHECKED_CAST", "KotlinGenericsCast")
+  override fun acquire(): T? {
+    if (size == 0) {
+      return null
+    }
+    size--
+    val lastIndex = size
+    val toReturn = pool[lastIndex] as T
+    pool[lastIndex] = null
+    return toReturn
+  }
+
+  @Synchronized
+  override fun release(instance: T): Boolean {
+    if (size == pool.size) {
+      return false
+    }
+    pool[size] = instance
+    size++
+    return true
+  }
+
+  @Synchronized
+  public fun clear(): Unit {
+    for (i in 0 until size) {
+      pool[i] = null
+    }
+    size = 0
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/DebugServerException.kt

@@ -0,0 +1,107 @@
+/*
+ * 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.common
+
+import android.net.Uri
+import com.facebook.common.logging.FLog
+import org.json.JSONException
+import org.json.JSONObject
+
+/**
+ * Tracks errors connecting to or received from the debug server. The debug server returns errors as
+ * json objects. This exception represents that error.
+ */
+public class DebugServerException : RuntimeException {
+
+  public val originalMessage: String
+
+  private constructor(
+      description: String,
+      fileName: String,
+      lineNumber: Int,
+      column: Int,
+  ) : super("$description\n  at $fileName:$lineNumber:$column") {
+    originalMessage = description
+  }
+
+  public constructor(description: String) : super(description) {
+    originalMessage = description
+  }
+
+  public constructor(
+      detailMessage: String,
+      throwable: Throwable?,
+  ) : super(detailMessage, throwable) {
+    originalMessage = detailMessage
+  }
+
+  public companion object {
+    private val GENERIC_ERROR_MESSAGE =
+        """
+        |
+        |
+        |Try the following to fix the issue:
+        |\u2022 Ensure that Metro is running
+        |\u2022 Ensure that your device/emulator is connected to your machine and has USB debugging enabled - run 'adb devices' to see a list of connected devices
+        |\u2022 Ensure Airplane Mode is disabled
+        |\u2022 If you're on a physical device connected to the same machine, run 'adb reverse tcp:<PORT> tcp:<PORT> to forward requests from your device
+        |\u2022 If your device is on the same Wi-Fi network, set 'Debug server host & port for device' in 'Dev settings' to your machine's IP address and the port of the local dev server - e.g. 10.0.1.1:<PORT>
+        |
+        |
+        """
+            .trimMargin()
+
+    @JvmStatic
+    public fun makeGeneric(url: String, reason: String, t: Throwable?): DebugServerException =
+        makeGeneric(url, reason, "", t)
+
+    @JvmStatic
+    public fun makeGeneric(
+        url: String,
+        reason: String,
+        extra: String,
+        t: Throwable?,
+    ): DebugServerException {
+      val uri = Uri.parse(url)
+      val message = GENERIC_ERROR_MESSAGE.replace("<PORT>", "${uri.port}")
+      return DebugServerException(reason + message + extra, t)
+    }
+
+    /**
+     * Parse a DebugServerException from the server json string.
+     *
+     * @param str json string returned by the debug server
+     * @return A DebugServerException or null if the string is not of proper form.
+     */
+    @JvmStatic
+    @Suppress("UNUSED_PARAMETER")
+    public fun parse(url: String?, str: String?): DebugServerException? {
+      if (str.isNullOrEmpty()) {
+        return null
+      }
+      try {
+        val jsonObject = JSONObject(str)
+        val fullFileName = jsonObject.getString("filename")
+        return DebugServerException(
+            jsonObject.getString("message"),
+            shortenFileName(fullFileName),
+            jsonObject.getInt("lineNumber"),
+            jsonObject.getInt("column"),
+        )
+      } catch (e: JSONException) {
+        FLog.w(ReactConstants.TAG, "Could not parse DebugServerException from: $str", e)
+        return null
+      }
+    }
+
+    private fun shortenFileName(fullFileName: String): String {
+      val parts = fullFileName.split("/".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+      return parts.last()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/JavascriptException.kt

@@ -14,14 +14,6 @@ import com.facebook.proguard.annotations.DoNotStrip
  * to developers in a redbox.
  */
 @DoNotStrip
-public open class JavascriptException(jsStackTrace: String) :
-    RuntimeException(jsStackTrace), HasJavascriptExceptionMetadata {
-  private var extraDataAsJson: String? = null
-
-  override fun getExtraDataAsJson(): String? = extraDataAsJson
-
-  public fun setExtraDataAsJson(extraDataAsJson: String?): JavascriptException {
-    this.extraDataAsJson = extraDataAsJson
-    return this
-  }
+public open class JavascriptException(jsStackTrace: String) : RuntimeException(jsStackTrace) {
+  public var extraDataAsJson: String? = null
 }

package/ReactAndroid/src/main/java/com/facebook/react/common/MapBuilder.java

@@ -11,8 +11,13 @@ import com.facebook.infer.annotation.Nullsafe;
 import java.util.HashMap;
 import java.util.Map;
 
-/** Utility class for creating maps */
+/**
+ * Utility class for creating maps
+ *
+ * @deprecated Use Kotlin's built-in collections extensions
+ */
 @Nullsafe(Nullsafe.Mode.LOCAL)
+@Deprecated
 public class MapBuilder {
 
   /** Creates an instance of {@code HashMap} */

package/ReactAndroid/src/main/java/com/facebook/react/common/ShakeDetector.kt

@@ -0,0 +1,124 @@
+/*
+ * 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.common
+
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import java.util.concurrent.TimeUnit
+
+/** Listens for the user shaking their phone. Allocation-less once it starts listening. */
+public class ShakeDetector
+@JvmOverloads
+constructor(private val shakeListener: ShakeListener, private val minNumShakes: Int = 1) :
+    SensorEventListener {
+
+  private var accelerationX = 0f
+  private var accelerationY = 0f
+  private var accelerationZ = 0f
+
+  public fun interface ShakeListener {
+    public fun onShake()
+  }
+
+  private var sensorManager: SensorManager? = null
+  private var lastTimestamp: Long = 0
+  private var numShakes = 0
+  private var lastShakeTimestamp: Long = 0
+
+  /** Start listening for shakes. */
+  public fun start(manager: SensorManager): Unit {
+    val accelerometer = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) ?: return
+    sensorManager = manager
+    lastTimestamp = -1
+    manager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_UI)
+    lastShakeTimestamp = 0
+    reset()
+  }
+
+  /** Stop listening for shakes. */
+  public fun stop(): Unit {
+    sensorManager?.unregisterListener(this)
+    sensorManager = null
+  }
+
+  /** Reset all variables used to keep track of number of shakes recorded. */
+  private fun reset() {
+    numShakes = 0
+    accelerationX = 0f
+    accelerationY = 0f
+    accelerationZ = 0f
+  }
+
+  /**
+   * Determine if acceleration applied to sensor is large enough to count as a rage shake.
+   *
+   * @param a acceleration in x, y, or z applied to the sensor
+   * @return true if the magnitude of the force exceeds the minimum required amount of force. false
+   *   otherwise.
+   */
+  private fun atLeastRequiredForce(a: Float): Boolean = Math.abs(a) > REQUIRED_FORCE
+
+  /**
+   * Save data about last shake
+   *
+   * @param timestamp (ns) of last sensor event
+   */
+  private fun recordShake(timestamp: Long) {
+    lastShakeTimestamp = timestamp
+    numShakes++
+  }
+
+  override fun onSensorChanged(sensorEvent: SensorEvent) {
+    if (sensorEvent.timestamp - lastTimestamp < MIN_TIME_BETWEEN_SAMPLES_NS) {
+      return
+    }
+    val ax = sensorEvent.values[0]
+    val ay = sensorEvent.values[1]
+    val az = sensorEvent.values[2] - SensorManager.GRAVITY_EARTH
+    lastTimestamp = sensorEvent.timestamp
+    when {
+      atLeastRequiredForce(ax) && ax * accelerationX <= 0 -> {
+        recordShake(sensorEvent.timestamp)
+        accelerationX = ax
+      }
+      atLeastRequiredForce(ay) && ay * accelerationY <= 0 -> {
+        recordShake(sensorEvent.timestamp)
+        accelerationY = ay
+      }
+      atLeastRequiredForce(az) && az * accelerationZ <= 0 -> {
+        recordShake(sensorEvent.timestamp)
+        accelerationZ = az
+      }
+    }
+    maybeDispatchShake(sensorEvent.timestamp)
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor, i: Int): Unit = Unit
+
+  private fun maybeDispatchShake(currentTimestamp: Long) {
+    if (numShakes >= 8 * minNumShakes) {
+      reset()
+      shakeListener.onShake()
+    }
+    if (currentTimestamp - lastShakeTimestamp > SHAKING_WINDOW_NS) {
+      reset()
+    }
+  }
+}
+
+// Collect sensor data in this interval (nanoseconds)
+private val MIN_TIME_BETWEEN_SAMPLES_NS = TimeUnit.NANOSECONDS.convert(20, TimeUnit.MILLISECONDS)
+
+// Number of nanoseconds to listen for and count shakes (nanoseconds)
+private val SHAKING_WINDOW_NS = TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS).toFloat()
+
+// Required force to constitute a rage shake. Need to multiply gravity by 1.33 because a rage
+// shake in one direction should have more force than just the magnitude of free fall.
+private const val REQUIRED_FORCE = SensorManager.GRAVITY_EARTH * 1.33f