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

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/{MessageQueueThread.java → MessageQueueThread.kt}

@@ -5,74 +5,67 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge.queue;
+package com.facebook.react.bridge.queue
 
-import androidx.annotation.Nullable;
-import com.facebook.proguard.annotations.DoNotStrip;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.AssertionException
+import java.util.concurrent.Callable
+import java.util.concurrent.Future
 
 /** Encapsulates a Thread that can accept Runnables. */
-@DoNotStrip
+@DoNotStripAny
 public interface MessageQueueThread {
   /**
    * Runs the given Runnable on this Thread. It will be submitted to the end of the event queue even
    * if it is being submitted from the same queue Thread.
    */
-  @DoNotStrip
-  boolean runOnQueue(Runnable runnable);
+  public fun runOnQueue(runnable: Runnable): Boolean
 
   /**
    * Runs the given Callable on this Thread. It will be submitted to the end of the event queue even
    * if it is being submitted from the same queue Thread.
    */
-  @DoNotStrip
-  <T> Future<T> callOnQueue(final Callable<T> callable);
+  public fun <T> callOnQueue(callable: Callable<T>): Future<T>
 
   /**
-   * @return whether the current Thread is also the Thread associated with this MessageQueueThread.
+   * Tells whether the current Thread is also the Thread associated with this MessageQueueThread.
    */
-  @DoNotStrip
-  boolean isOnThread();
+  public fun isOnThread(): Boolean
 
   /**
-   * Asserts {@link #isOnThread()}, throwing a {@link AssertionException} (NOT an {@link
-   * AssertionError}) if the assertion fails.
+   * Asserts [isOnThread], throwing a [AssertionException] (NOT an [AssertionError]) if the
+   * assertion fails.
    */
-  @DoNotStrip
-  void assertIsOnThread();
+  public fun assertIsOnThread()
 
   /**
-   * Asserts {@link #isOnThread()}, throwing a {@link AssertionException} (NOT an {@link
-   * AssertionError}) if the assertion fails. The given message is appended to the error.
+   * Asserts [isOnThread], throwing a [AssertionException] (NOT an [AssertionError]) if the
+   * assertion fails. The given message is appended to the error.
    */
-  @DoNotStrip
-  void assertIsOnThread(String message);
+  public fun assertIsOnThread(message: String)
 
   /**
    * Quits this MessageQueueThread. If called from this MessageQueueThread, this will be the last
    * thing the thread runs. If called from a separate thread, this will block until the thread can
    * be quit and joined.
    */
-  @DoNotStrip
-  void quitSynchronous();
+  public fun quitSynchronous()
 
   /**
    * Returns the perf counters taken when the framework was started. This method is intended to be
    * used for instrumentation purposes.
    */
-  @Nullable
-  @DoNotStrip
-  MessageQueueThreadPerfStats getPerfStats();
+  public fun getPerfStats(): MessageQueueThreadPerfStats?
 
   /**
    * Resets the perf counters. This is useful if the RN threads are being re-used. This method is
    * intended to be used for instrumentation purposes.
    */
-  @DoNotStrip
-  void resetPerfStats();
+  public fun resetPerfStats()
 
-  /** Returns true if the message queue is idle */
-  @DoNotStrip
-  boolean isIdle();
+  /**
+   * Resets the perf counters. This is useful if the RN threads are being re-used. This method is
+   * intended to be used for instrumentation purposes.
+   */
+  public fun isIdle(): Boolean
 }

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

@@ -0,0 +1,25 @@
+/*
+ * 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.queue
+
+import android.os.Handler
+import android.os.Looper
+import android.os.Message
+
+/** Handler that can catch and dispatch Exceptions to an Exception handler. */
+public class MessageQueueThreadHandler
+constructor(looper: Looper, private val exceptionHandler: QueueThreadExceptionHandler) :
+    Handler(looper) {
+  override fun dispatchMessage(msg: Message) {
+    try {
+      super.dispatchMessage(msg)
+    } catch (e: Exception) {
+      exceptionHandler.handleException(e)
+    }
+  }
+}

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

@@ -0,0 +1,186 @@
+/*
+ * 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.queue
+
+import android.os.Looper
+import android.os.Process
+import android.os.SystemClock
+import android.util.Pair
+import com.facebook.common.logging.FLog
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.AssertionException
+import com.facebook.react.bridge.SoftAssertions
+import com.facebook.react.bridge.queue.MessageQueueThreadSpec.ThreadType
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.futures.SimpleSettableFuture
+import java.util.concurrent.Callable
+import java.util.concurrent.Future
+import kotlin.concurrent.Volatile
+
+/** Encapsulates a Thread that has a [Looper] running on it that can accept Runnables. */
+@DoNotStripAny
+public class MessageQueueThreadImpl
+private constructor(
+    public val name: String,
+    public val looper: Looper,
+    exceptionHandler: QueueThreadExceptionHandler,
+    private val stats: MessageQueueThreadPerfStats? = null
+) : MessageQueueThread {
+  private val handler = MessageQueueThreadHandler(looper, exceptionHandler)
+  private val assertionErrorMessage = "Expected to be called from the '$name' thread!"
+
+  @Volatile private var isFinished = false
+
+  /**
+   * Runs the given Runnable on this Thread. It will be submitted to the end of the event queue even
+   * if it is being submitted from the same queue Thread.
+   */
+  public override fun runOnQueue(runnable: Runnable): Boolean {
+    if (isFinished) {
+      FLog.w(
+          ReactConstants.TAG,
+          "Tried to enqueue runnable on already finished thread: '$name... dropping Runnable.")
+      return false
+    }
+    handler.post(runnable)
+    return true
+  }
+
+  public override fun <T> callOnQueue(callable: Callable<T>): Future<T> {
+    val future = SimpleSettableFuture<T>()
+    runOnQueue {
+      try {
+        future.set(callable.call())
+      } catch (e: Exception) {
+        future.setException(e)
+      }
+    }
+    return future
+  }
+
+  /**
+   * @return whether the current Thread is also the Thread associated with this MessageQueueThread.
+   */
+  override fun isOnThread(): Boolean = looper.thread === Thread.currentThread()
+
+  /**
+   * Asserts [isOnThread], throwing a [AssertionException] (NOT an [AssertionError]) if the
+   * assertion fails.
+   */
+  @Throws(AssertionException::class)
+  override fun assertIsOnThread() {
+    SoftAssertions.assertCondition(isOnThread(), assertionErrorMessage)
+  }
+
+  /**
+   * Asserts [isOnThread], throwing a [AssertionException] (NOT an [AssertionError]) if the
+   * assertion fails.
+   */
+  @Throws(AssertionException::class)
+  public override fun assertIsOnThread(message: String) {
+    SoftAssertions.assertCondition(
+        isOnThread(),
+        StringBuilder().append(assertionErrorMessage).append(" ").append(message).toString())
+  }
+
+  /**
+   * Quits this queue's Looper. If that Looper was running on a different Thread than the current
+   * Thread, also waits for the last message being processed to finish and the Thread to die.
+   */
+  @Throws(RuntimeException::class)
+  override fun quitSynchronous() {
+    isFinished = true
+    looper.quit()
+    if (looper.thread !== Thread.currentThread()) {
+      try {
+        looper.thread.join()
+      } catch (e: InterruptedException) {
+        throw RuntimeException("Got interrupted waiting to join thread $name")
+      }
+    }
+  }
+
+  override fun getPerfStats(): MessageQueueThreadPerfStats? = stats
+
+  override fun resetPerfStats() {
+    assignToPerfStats(stats, -1, -1)
+    runOnQueue {
+      val wallTime = SystemClock.uptimeMillis()
+      val cpuTime = SystemClock.currentThreadTimeMillis()
+      assignToPerfStats(stats, wallTime, cpuTime)
+    }
+  }
+
+  public override fun isIdle(): Boolean = looper.queue.isIdle
+
+  public companion object {
+    private fun assignToPerfStats(stats: MessageQueueThreadPerfStats?, wall: Long, cpu: Long) {
+      stats?.let { s ->
+        s.wallTime = wall
+        s.cpuTime = cpu
+      }
+    }
+
+    @JvmStatic
+    @Throws(RuntimeException::class)
+    public fun create(
+        spec: MessageQueueThreadSpec,
+        exceptionHandler: QueueThreadExceptionHandler
+    ): MessageQueueThreadImpl {
+      return when (spec.threadType) {
+        ThreadType.MAIN_UI -> createForMainThread(spec.name, exceptionHandler)
+
+        ThreadType.NEW_BACKGROUND ->
+            startNewBackgroundThread(spec.name, spec.stackSize, exceptionHandler)
+      }
+    }
+
+    /** Returns a MessageQueueThreadImpl corresponding to Android's main UI thread. */
+    private fun createForMainThread(
+        name: String,
+        exceptionHandler: QueueThreadExceptionHandler
+    ): MessageQueueThreadImpl =
+        MessageQueueThreadImpl(name, Looper.getMainLooper(), exceptionHandler)
+
+    /**
+     * Creates and starts a new MessageQueueThreadImpl encapsulating a new Thread with a new Looper
+     * running on it. Give it a name for easier debugging and optionally a suggested stack size.
+     * When this method exits, the new MessageQueueThreadImpl is ready to receive events. throws a
+     * Runtime exception if there was no looper for current thread or looper and stats couldn't be
+     * made
+     */
+    @Throws(RuntimeException::class)
+    private fun startNewBackgroundThread(
+        name: String,
+        stackSize: Long,
+        exceptionHandler: QueueThreadExceptionHandler
+    ): MessageQueueThreadImpl {
+      val dataFuture = SimpleSettableFuture<Pair<Looper?, MessageQueueThreadPerfStats>>()
+      val bgThread =
+          Thread(
+              null,
+              {
+                Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY)
+                Looper.prepare()
+                val stats = MessageQueueThreadPerfStats()
+                val wallTime = SystemClock.uptimeMillis()
+                val cpuTime = SystemClock.currentThreadTimeMillis()
+                assignToPerfStats(stats, wallTime, cpuTime)
+                dataFuture.set(Pair(Looper.myLooper(), stats))
+                Looper.loop()
+              },
+              "mqt_$name",
+              stackSize)
+      bgThread.start()
+
+      val pair = dataFuture.getOrThrow()
+      val looper = pair?.first ?: throw RuntimeException("Looper not found for thread")
+      return MessageQueueThreadImpl(name, looper, exceptionHandler, pair.second)
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/{MessageQueueThreadPerfStats.java → MessageQueueThreadPerfStats.kt}

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge.queue;
+package com.facebook.react.bridge.queue
 
 /** This class holds perf counters' values at the beginning of an RN startup. */
 public class MessageQueueThreadPerfStats {
-  public long wallTime;
-  public long cpuTime;
+  @JvmField public var wallTime: Long = 0
+  @JvmField public var cpuTime: Long = 0
 }

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

@@ -0,0 +1,42 @@
+/*
+ * 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.queue
+
+/** Spec for creating a MessageQueueThread. */
+public class MessageQueueThreadSpec
+private constructor(
+    public val threadType: ThreadType,
+    public val name: String,
+    public val stackSize: Long = DEFAULT_STACK_SIZE_BYTES
+) {
+  public enum class ThreadType {
+    MAIN_UI,
+    NEW_BACKGROUND,
+  }
+
+  public companion object {
+    private val MAIN_UI_SPEC = MessageQueueThreadSpec(ThreadType.MAIN_UI, "main_ui")
+
+    // The Thread constructor interprets zero the same as not specifying a stack size
+    public const val DEFAULT_STACK_SIZE_BYTES: Long = 0
+
+    @JvmStatic
+    public fun newUIBackgroundTreadSpec(name: String): MessageQueueThreadSpec =
+        MessageQueueThreadSpec(ThreadType.NEW_BACKGROUND, name)
+
+    @JvmStatic
+    public fun newBackgroundThreadSpec(name: String): MessageQueueThreadSpec =
+        MessageQueueThreadSpec(ThreadType.NEW_BACKGROUND, name)
+
+    @JvmStatic
+    public fun newBackgroundThreadSpec(name: String, stackSize: Long): MessageQueueThreadSpec =
+        MessageQueueThreadSpec(ThreadType.NEW_BACKGROUND, name, stackSize)
+
+    @JvmStatic public fun mainThreadSpec(): MessageQueueThreadSpec = MAIN_UI_SPEC
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/{QueueThreadExceptionHandler.java → QueueThreadExceptionHandler.kt}

@@ -5,13 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge.queue;
+package com.facebook.react.bridge.queue
 
 /**
  * Interface for a class that knows how to handle an Exception thrown while executing a Runnable
- * submitted via {@link MessageQueueThread#runOnQueue}.
+ * submitted via [MessageQueueThread.runOnQueue].
  */
-public interface QueueThreadExceptionHandler {
-
-  void handleException(Exception e);
+public fun interface QueueThreadExceptionHandler {
+  public fun handleException(e: Exception)
 }

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

@@ -0,0 +1,30 @@
+/*
+ * 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.queue
+
+/**
+ * Specifies which [MessageQueueThread]s must be used to run the various contexts of execution
+ * within catalyst (Main UI thread, native modules, and JS). Some of these queues *may* be the same
+ * but should be coded against as if they are different.
+ *
+ * UI Queue Thread: The standard Android main UI thread and Looper. Not configurable.
+ *
+ * Native Modules Queue Thread: The thread and Looper that native modules are invoked on.
+ *
+ * JS Queue Thread: The thread and Looper that JS is executed on. thread and Looper that JS is
+ * executed on.
+ */
+public interface ReactQueueConfiguration {
+  public fun getUIQueueThread(): MessageQueueThread
+
+  public fun getNativeModulesQueueThread(): MessageQueueThread
+
+  public fun getJSQueueThread(): MessageQueueThread
+
+  public fun destroy()
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/ReactQueueConfigurationImpl.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.queue
+
+import android.os.Looper
+import com.facebook.react.bridge.queue.MessageQueueThreadImpl.Companion.create
+import com.facebook.react.bridge.queue.MessageQueueThreadSpec.Companion.mainThreadSpec
+
+public class ReactQueueConfigurationImpl
+private constructor(
+    private val uiQueueThread: MessageQueueThreadImpl,
+    private val nativeModulesQueueThread: MessageQueueThreadImpl,
+    private val jsQueueThread: MessageQueueThreadImpl
+) : ReactQueueConfiguration {
+  override fun getUIQueueThread(): MessageQueueThread = uiQueueThread
+
+  override fun getNativeModulesQueueThread(): MessageQueueThread = nativeModulesQueueThread
+
+  override fun getJSQueueThread(): MessageQueueThread = jsQueueThread
+
+  /**
+   * Should be called when the corresponding [com.facebook.react.bridge.CatalystInstance] is
+   * destroyed so that we shut down the proper queue threads.
+   */
+  override fun destroy() {
+    if (nativeModulesQueueThread.looper != Looper.getMainLooper()) {
+      nativeModulesQueueThread.quitSynchronous()
+    }
+    if (jsQueueThread.looper != Looper.getMainLooper()) {
+      jsQueueThread.quitSynchronous()
+    }
+  }
+
+  public companion object {
+    @JvmStatic
+    public fun create(
+        spec: ReactQueueConfigurationSpec,
+        exceptionHandler: QueueThreadExceptionHandler
+    ): ReactQueueConfigurationImpl {
+      val uiThread = create(mainThreadSpec(), exceptionHandler)
+      val jsThread = create(spec.jSQueueThreadSpec, exceptionHandler)
+      val nativeModulesThread = create(spec.nativeModulesQueueThreadSpec, exceptionHandler)
+      return ReactQueueConfigurationImpl(uiThread, nativeModulesThread, jsThread)
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/ReactQueueConfigurationSpec.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.queue
+
+import com.facebook.react.bridge.queue.MessageQueueThreadSpec.Companion.newBackgroundThreadSpec
+
+/**
+ * Spec for creating a ReactQueueConfiguration. This exists so that CatalystInstance is able to set
+ * Exception handlers on the MessageQueueThreads it uses and it would not be super clean if the
+ * threads were configured, then passed to CatalystInstance where they are configured more. These
+ * specs allows the Threads to be created fully configured.
+ */
+public class ReactQueueConfigurationSpec
+public constructor(
+    public val nativeModulesQueueThreadSpec: MessageQueueThreadSpec,
+    public val jSQueueThreadSpec: MessageQueueThreadSpec
+) {
+  public class Builder public constructor() {
+    private var nativeModulesQueueSpec: MessageQueueThreadSpec? = null
+    private var jsQueueSpec: MessageQueueThreadSpec? = null
+
+    public fun setNativeModulesQueueThreadSpec(spec: MessageQueueThreadSpec?): Builder {
+      check(nativeModulesQueueSpec == null) { "Setting native modules queue spec multiple times!" }
+      nativeModulesQueueSpec = spec
+      return this
+    }
+
+    public fun setJSQueueThreadSpec(spec: MessageQueueThreadSpec?): Builder {
+      check(jsQueueSpec == null) { "Setting JS queue multiple times!" }
+      jsQueueSpec = spec
+      return this
+    }
+
+    public fun build(): ReactQueueConfigurationSpec =
+        ReactQueueConfigurationSpec(checkNotNull(nativeModulesQueueSpec), checkNotNull(jsQueueSpec))
+  }
+
+  public companion object {
+    public fun builder(): Builder = Builder()
+
+    @JvmStatic
+    public fun createDefault(): ReactQueueConfigurationSpec =
+        ReactQueueConfigurationSpec(
+            newBackgroundThreadSpec("native_modules"), newBackgroundThreadSpec("js"))
+  }
+}

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

@@ -0,0 +1,18 @@
+/*
+ * 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
+
+/**
+ * This enum is used to determine the release level of a React Native application, which is then
+ * used to determine what React Native Features will be enabled in the application.
+ */
+public enum class ReleaseLevel {
+  EXPERIMENTAL,
+  CANARY,
+  STABLE
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/annotations/internal/LegacyArchitecture.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.annotations.internal
+
+/**
+ * Annotation to mark classes or functions that are part of the legacy architecture.
+ *
+ * This annotation is used to indicate that the annotated class or function is part of the legacy
+ * architecture. The `logLevel` parameter can be used to specify the level of logging that should be
+ * applied when the annotated element is used.
+ *
+ * @property logLevel The logging level to be used for the annotated element. Defaults to
+ *   `LegacyArchitectureLogLevel.WARNING`.
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+public annotation class LegacyArchitecture(
+    val logLevel: LegacyArchitectureLogLevel = LegacyArchitectureLogLevel.WARNING
+) {}

package/ReactAndroid/src/main/java/com/facebook/react/common/annotations/internal/LegacyArchitectureLogLevel.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.annotations.internal
+
+/**
+ * Enum class representing the log levels for classes annotated with @LegacyArcture annoation.
+ *
+ * It provides two levels of logging:
+ * - WARNING: Indicates a warning signal will be logged if the underlying class is used when the new
+ *   architecture is enabled.
+ * - ERROR: : Indicates an error signal will be logged if the underlying class is used when the new
+ *   architecture is enabled.
+ */
+public enum class LegacyArchitectureLogLevel {
+  WARNING,
+  ERROR
+}

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

@@ -22,9 +22,19 @@ public object ReactBuildConfig {
 
   @JvmField public val IS_INTERNAL_BUILD: Boolean = BuildConfig.IS_INTERNAL_BUILD
 
+  /**
+   * [true] if Perfetto was enabled on this build (`WITH_PERFETTO=1`), indicating it is a profiling
+   * build.
+   */
+  @JvmField public val ENABLE_PERFETTO: Boolean = BuildConfig.ENABLE_PERFETTO
+
   @JvmField public val EXOPACKAGE_FLAGS: Int = BuildConfig.EXOPACKAGE_FLAGS
 
   /** [Experimental] Enable React Native DevTools in release builds. */
   @JvmField
   public val UNSTABLE_ENABLE_FUSEBOX_RELEASE: Boolean = BuildConfig.UNSTABLE_ENABLE_FUSEBOX_RELEASE
+
+  @JvmField
+  public val UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE: Boolean =
+      BuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE
 }

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

@@ -17,7 +17,7 @@ import java.util.concurrent.TimeoutException
  * A super simple Future-like class that can safely notify another Thread when a value is ready.
  * Does not support canceling.
  */
-internal class SimpleSettableFuture<T> : Future<T?> {
+internal class SimpleSettableFuture<T> : Future<T> {
 
   private val readyLatch = CountDownLatch(1)
   private var result: T? = null
@@ -27,7 +27,7 @@ internal class SimpleSettableFuture<T> : Future<T?> {
    * Sets the result. If another thread has called [get], they will immediately receive the value.
    * set or setException must only be called once.
    */
-  public fun set(result: T?): Unit {
+  fun set(result: T?): Unit {
     checkNotSet()
     this.result = result
     readyLatch.countDown()
@@ -37,7 +37,7 @@ internal class SimpleSettableFuture<T> : Future<T?> {
    * Sets the exception. If another thread has called [get], they will immediately receive the
    * exception. set or setException must only be called once.
    */
-  public fun setException(exception: Exception): Unit {
+  fun setException(exception: Exception): Unit {
     checkNotSet()
     this.exception = exception
     readyLatch.countDown()
@@ -79,7 +79,7 @@ internal class SimpleSettableFuture<T> : Future<T?> {
   }
 
   /** Convenience wrapper for [get()] that re-throws get()'s Exceptions as RuntimeExceptions. */
-  public fun getOrThrow(): T? =
+  fun getOrThrow(): T? =
       try {
         get()
       } catch (e: InterruptedException) {
@@ -92,7 +92,7 @@ internal class SimpleSettableFuture<T> : Future<T?> {
    * Convenience wrapper for [get(long, TimeUnit)] that re-throws get()'s Exceptions as
    * RuntimeExceptions.
    */
-  public fun getOrThrow(timeout: Long, unit: TimeUnit): T? =
+  fun getOrThrow(timeout: Long, unit: TimeUnit): T? =
       try {
         get(timeout, unit)
       } catch (e: InterruptedException) {