fix: format and flow issues

Author: matinzd

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/DeferredActivityResultLauncher.kt

@@ -21,8 +21,8 @@ import com.facebook.react.common.ReactConstants
  * unbound (fired on bind), and can be [unbind]-ed and rebound against a new host's registry.
  *
  * [delegate] and [pendingLaunch] are only touched on the UI thread; [launch] and [unregister] get
- * there via [onUiThread]. [launch] decides between delegating and queueing *on* the UI thread, so
- * a concurrent [unbind] cannot leave it pointed at a dead registry.
+ * there via [onUiThread]. [launch] decides between delegating and queueing *on* the UI thread, so a
+ * concurrent [unbind] cannot leave it pointed at a dead registry.
  */
 internal class DeferredActivityResultLauncher<I>(
     private val key: String,
@@ -48,7 +48,8 @@ internal class DeferredActivityResultLauncher<I>(
           FLog.w(
               ReactConstants.TAG,
               "Launcher for '$key' was launched again before an Activity was available; " +
-                  "replacing the previously queued launch.")
+                  "replacing the previously queued launch.",
+          )
         }
         pendingLaunch = PendingLaunch(input, options)
       }

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/ReactActivityResultCaller.kt

@@ -20,18 +20,17 @@ import androidx.activity.result.contract.ActivityResultContract
  * Every registration carries a key that must be unique within the `ReactContext` and stable across
  * process death (AndroidX replays a restored result to whichever registration reproduces the same
  * key). The default key `"<owner class>:<contract class>"` lets unrelated libraries register the
- * same stock contract without colliding; a collision throws [IllegalStateException] at
- * registration time, and the keyed overload (which appends to that scope, not replaces it)
- * resolves it.
+ * same stock contract without colliding; a collision throws [IllegalStateException] at registration
+ * time, and the keyed overload (which appends to that scope, not replaces it) resolves it.
  */
 internal interface ReactActivityResultCaller {
 
   /**
    * Registers [contract] under the key `"<owner class>:<contract class>"` and returns a launcher
    * for it. [owner] must be an instance of a named class — typically the native module itself.
    * Anonymous classes are rejected because their generated names can change between builds, which
-   * breaks result delivery after the process is killed and restored. For the same reason, apps
-   * that minify class names (R8/ProGuard) should keep the owner class's name, since the key is not
+   * breaks result delivery after the process is killed and restored. For the same reason, apps that
+   * minify class names (R8/ProGuard) should keep the owner class's name, since the key is not
    * guaranteed to be stable between builds otherwise.
    *
    * @throws IllegalArgumentException if [owner] is an instance of an anonymous class
@@ -44,11 +43,11 @@ internal interface ReactActivityResultCaller {
   ): ActivityResultLauncher<I>
 
   /**
-   * Registers [contract] under the key `"<owner class>:<contract class>:<key>"`. Use this when
-   * one owner needs several launchers of the same contract class. [key] only has to be unique
-   * among those, but must stay the same across process restarts, so derive it from a constant.
-   * [owner] carries the same requirements as the two-argument overload: it must be an instance of
-   * a named class.
+   * Registers [contract] under the key `"<owner class>:<contract class>:<key>"`. Use this when one
+   * owner needs several launchers of the same contract class. [key] only has to be unique among
+   * those, but must stay the same across process restarts, so derive it from a constant. [owner]
+   * carries the same requirements as the two-argument overload: it must be an instance of a named
+   * class.
    *
    * @throws IllegalArgumentException if [owner] is an instance of an anonymous class
    * @throws IllegalStateException if [owner] already registered this contract class under [key]

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/ReactActivityResultCallerImpl.kt

@@ -35,15 +35,15 @@ internal fun onUiThread(block: () -> Unit) {
  * [ActivityResultRegistry] immediately or on the next `onHostResume`. They outlive any single
  * Activity: keys stay stable so AndroidX can re-associate a result after Activity recreation.
  *
- * Every `onHostResume` checks each launcher against the *current* registry, not just "already
- * bound to something": with multi-Activity navigation the new Activity resumes before the old one
- * is destroyed (whose onHostDestroy is dropped once `currentActivity` moves on), so a bound-only
- * check would leave launchers attached to the previous Activity's dead registry.
+ * Every `onHostResume` checks each launcher against the *current* registry, not just "already bound
+ * to something": with multi-Activity navigation the new Activity resumes before the old one is
+ * destroyed (whose onHostDestroy is dropped once `currentActivity` moves on), so a bound-only check
+ * would leave launchers attached to the previous Activity's dead registry.
  *
  * Threading: [entries] is concurrent and reachable from any thread; everything touching the
  * registry goes through [onUiThread]. Registration stays on the caller's thread so the launcher
- * returns immediately and a duplicate key throws at the causing frame. Only the registry call
- * moves to the UI thread.
+ * returns immediately and a duplicate key throws at the causing frame. Only the registry call moves
+ * to the UI thread.
  */
 internal class ReactActivityResultCallerImpl(private val reactContext: ReactContext) :
     ReactActivityResultCaller, LifecycleEventListener {
@@ -78,10 +78,10 @@ internal class ReactActivityResultCallerImpl(private val reactContext: ReactCont
       contract: ActivityResultContract<I, O>,
       callback: ActivityResultCallback<O>,
   ): ActivityResultLauncher<I> {
-    if(owner::class.java.isAnonymousClass) {
+    if (owner::class.java.isAnonymousClass) {
       throw IllegalArgumentException(
-        "ActivityResult owner must be a named class, but got an anonymous class. " +
-          "Pass an instance of a named class instead."
+          "ActivityResult owner must be a named class, but got an anonymous class. " +
+              "Pass an instance of a named class instead."
       )
     }
 
@@ -91,7 +91,8 @@ internal class ReactActivityResultCallerImpl(private val reactContext: ReactCont
             "Register once and reuse the launcher, or pass a distinct key per launcher: " +
                 "registerForActivityResult(owner, \"someName\", contract, callback).",
         contract = contract,
-        callback = callback)
+        callback = callback,
+    )
   }
 
   override fun <I, O> registerForActivityResult(
@@ -100,18 +101,19 @@ internal class ReactActivityResultCallerImpl(private val reactContext: ReactCont
       contract: ActivityResultContract<I, O>,
       callback: ActivityResultCallback<O>,
   ): ActivityResultLauncher<I> {
-    if(owner::class.java.isAnonymousClass) {
+    if (owner::class.java.isAnonymousClass) {
       throw IllegalArgumentException(
-        "ActivityResult owner must be a named class, but got an anonymous class. " +
-          "Pass an instance of a named class instead."
+          "ActivityResult owner must be a named class, but got an anonymous class. " +
+              "Pass an instance of a named class instead."
       )
     }
 
     return register(
         key = "${owner.javaClass.name}:${contract.javaClass.name}:$key",
         collisionHint = "Pass a key that is unique among this owner's launchers of this contract.",
         contract = contract,
-        callback = callback)
+        callback = callback,
+    )
   }
 
   private fun <I, O> register(
@@ -123,8 +125,7 @@ internal class ReactActivityResultCallerImpl(private val reactContext: ReactCont
     val launcher = DeferredActivityResultLauncher(key, contract) { entries.remove(key) }
     val entry = Entry(key, contract, callback, launcher)
     if (entries.putIfAbsent(key, entry) != null) {
-      throw IllegalStateException(
-          "A launcher is already registered for key '$key'. $collisionHint")
+      throw IllegalStateException("A launcher is already registered for key '$key'. $collisionHint")
     }
     onUiThread { currentRegistry()?.let { registry -> entry.bindTo(registry) } }
     return launcher
@@ -145,11 +146,12 @@ internal class ReactActivityResultCallerImpl(private val reactContext: ReactCont
 
   private fun currentRegistry(): ActivityResultRegistry? {
     val activity = reactContext.currentActivity ?: return null
-    val owner = activity as? ActivityResultRegistryOwner
-      ?: throw IllegalStateException(
-        "Current Activity ${activity.javaClass.name} is not an ActivityResultRegistryOwner; " +
-          "ActivityResultContract launchers cannot be registered."
-      )
+    val owner =
+        activity as? ActivityResultRegistryOwner
+            ?: throw IllegalStateException(
+                "Current Activity ${activity.javaClass.name} is not an ActivityResultRegistryOwner; " +
+                    "ActivityResultContract launchers cannot be registered."
+            )
     return owner.activityResultRegistry
   }
 }

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactContext.java

@@ -16,13 +16,11 @@
 import android.os.Bundle;
 import android.view.LayoutInflater;
 import android.view.Window;
-
 import androidx.activity.result.ActivityResultCallback;
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContract;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
@@ -35,7 +33,6 @@
 import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.interfaces.ExtraWindowEventListener;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
-
 import java.lang.ref.WeakReference;
 import java.util.Collection;
 import java.util.concurrent.CopyOnWriteArraySet;
@@ -553,12 +550,11 @@ private synchronized ReactActivityResultCallerImpl getActivityResultCaller() {
    * consumer's {@code MainActivity}. Registration is legal at any time; the launcher binds lazily
    * once an Activity is available, queueing a {@code launch} issued while unbound.
    *
-   * <p>The registration key is {@code "<owner class>:<contract class>"}, so {@code owner} should
-   * be a stable, long-lived object (typically the native module itself): the key must be
-   * reproducible after the process is killed and restored. Registering the same contract class
-   * twice from one owner
-   * throws {@link IllegalStateException}; use {@link #registerForActivityResult(Object, String,
-   * ActivityResultContract, ActivityResultCallback)} in that case.
+   * <p>The registration key is {@code "<owner class>:<contract class>"}, so {@code owner} should be
+   * a stable, long-lived object (typically the native module itself): the key must be reproducible
+   * after the process is killed and restored. Registering the same contract class twice from one
+   * owner throws {@link IllegalStateException}; use {@link #registerForActivityResult(Object,
+   * String, ActivityResultContract, ActivityResultCallback)} in that case.
    */
   public <I, O> ActivityResultLauncher<I> registerForActivityResult(
       Object owner, ActivityResultContract<I, O> contract, ActivityResultCallback<O> callback) {

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/activityresult/ReactActivityResultCallerImplTest.kt

@@ -28,8 +28,8 @@ import org.robolectric.RobolectricTestRunner
 
 /**
  * Covers the registration keying scheme: owner-scoped by default so two independent modules can use
- * the same stock contract, with an extra-key overload -- appended to that scope, not replacing it --
- * for one owner needing several launchers of the same contract class.
+ * the same stock contract, with an extra-key overload -- appended to that scope, not replacing it
+ * -- for one owner needing several launchers of the same contract class.
  */
 @RunWith(RobolectricTestRunner::class)
 class ReactActivityResultCallerImplTest {
@@ -87,8 +87,7 @@ class ReactActivityResultCallerImplTest {
     caller.registerForActivityResult(moduleB, GetContent()) {}
 
     assertThat(registry.registeredKeys)
-        .containsExactlyInAnyOrder(
-            "$moduleAName:$getContentName", "$moduleBName:$getContentName")
+        .containsExactlyInAnyOrder("$moduleAName:$getContentName", "$moduleBName:$getContentName")
   }
 
   @Test
@@ -107,7 +106,9 @@ class ReactActivityResultCallerImplTest {
 
     assertThat(registry.registeredKeys)
         .containsExactlyInAnyOrder(
-            "$moduleAName:$getContentName", "$moduleAName:${RequestPermission::class.java.name}")
+            "$moduleAName:$getContentName",
+            "$moduleAName:${RequestPermission::class.java.name}",
+        )
   }
 
   @Test
@@ -117,7 +118,9 @@ class ReactActivityResultCallerImplTest {
 
     assertThat(registry.registeredKeys)
         .containsExactlyInAnyOrder(
-            "$moduleAName:$getContentName:avatar", "$moduleAName:$getContentName:banner")
+            "$moduleAName:$getContentName:avatar",
+            "$moduleAName:$getContentName:banner",
+        )
   }
 
   /** The owner-and-contract scope is still applied, so a shared key across owners is safe. */
@@ -128,7 +131,9 @@ class ReactActivityResultCallerImplTest {
 
     assertThat(registry.registeredKeys)
         .containsExactlyInAnyOrder(
-            "$moduleAName:$getContentName:pick", "$moduleBName:$getContentName:pick")
+            "$moduleAName:$getContentName:pick",
+            "$moduleBName:$getContentName:pick",
+        )
   }
 
   @Test

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/activityresult/ReactActivityResultCallerThreadingTest.kt

@@ -127,7 +127,9 @@ class ReactActivityResultCallerThreadingTest {
 
     var thrown: Throwable? = null
     onBackgroundThread {
-      thrown = runCatching { caller.registerForActivityResult(moduleA, GetContent()) {} }.exceptionOrNull()
+      thrown =
+          runCatching { caller.registerForActivityResult(moduleA, GetContent()) {} }
+              .exceptionOrNull()
     }
 
     // Not surfaced later on the UI thread, where it would be unattributable.
@@ -151,9 +153,9 @@ class ReactActivityResultCallerThreadingTest {
   }
 
   /**
-   * Multi-Activity navigation: B resumes while A is still alive, and `ReactHostImpl` then drops
-   * A's `onHostDestroy` because `currentActivity` has already moved to B. So no unbind ever runs
-   * for A -- `onHostResume` alone has to move the launcher across.
+   * Multi-Activity navigation: B resumes while A is still alive, and `ReactHostImpl` then drops A's
+   * `onHostDestroy` because `currentActivity` has already moved to B. So no unbind ever runs for A
+   * -- `onHostResume` alone has to move the launcher across.
    */
   @Test
   fun `resuming a second activity rebinds to its registry without any onHostDestroy`() {

packages/react-native/ReactCommon/react/nativemodule/samples/platform/android/SampleTurboModule.kt

@@ -385,7 +385,8 @@ public class SampleTurboModule(private val context: ReactApplicationContext) :
     }
     pendingPickMultipleMediaPromise = promise
     pickMultipleMediaLauncher.launch(
-        PickUpToMedia.Request(limit, PickVisualMediaRequest(visualMediaType(mimeType))))
+        PickUpToMedia.Request(limit, PickVisualMediaRequest(visualMediaType(mimeType)))
+    )
   }
 
   /**
@@ -429,15 +430,21 @@ public class SampleTurboModule(private val context: ReactApplicationContext) :
     // Reject anything still in flight: the JS context that made these calls is going away.
     // Clearing the fields also lets the still-registered callbacks tolerate a late result.
     pendingPermissionPromise?.reject(
-        "E_MODULE_INVALIDATED", "Permission request cancelled: SampleTurboModule was invalidated")
+        "E_MODULE_INVALIDATED",
+        "Permission request cancelled: SampleTurboModule was invalidated",
+    )
     pendingPermissionPromise = null
 
     pendingPickMediaPromise?.reject(
-        "E_MODULE_INVALIDATED", "Media pick cancelled: SampleTurboModule was invalidated")
+        "E_MODULE_INVALIDATED",
+        "Media pick cancelled: SampleTurboModule was invalidated",
+    )
     pendingPickMediaPromise = null
 
     pendingPickMultipleMediaPromise?.reject(
-        "E_MODULE_INVALIDATED", "Multiple media pick cancelled: SampleTurboModule was invalidated")
+        "E_MODULE_INVALIDATED",
+        "Multiple media pick cancelled: SampleTurboModule was invalidated",
+    )
     pendingPickMultipleMediaPromise = null
     super.invalidate()
   }

packages/rn-tester/js/examples/TurboModule/SampleTurboModuleExample.js

@@ -12,8 +12,15 @@ import type {EventSubscription, RootTag} from 'react-native';
 
 import RNTesterText from '../../components/RNTesterText';
 import styles from './TurboModuleExampleCommon';
+
 import * as React from 'react';
-import {FlatList, RootTagContext, TouchableOpacity, View} from 'react-native';
+import {
+  FlatList,
+  Platform,
+  RootTagContext,
+  TouchableOpacity,
+  View,
+} from 'react-native';
 import NativeSampleTurboModule, {
   EnumInt,
 } from 'react-native/Libraries/TurboModule/samples/NativeSampleTurboModule';
@@ -178,15 +185,16 @@ class SampleTurboModuleExample extends React.Component<{}, State> {
     installJSIBindings: () => global.__SampleTurboModuleJSIBindings,
   };
 
-  // Kept out of `_tests` so that "Run all tests" does not raise a system permission dialog.
   // $FlowFixMe[missing-local-annot]
   _androidTests = {
     requestSamplePermission: () => {
-      NativeSampleTurboModule.requestSamplePermission?.()
-        .then(isGranted =>
-          this._setResult('requestSamplePermission', isGranted),
-        )
-        .catch(e => this._setResult('requestSamplePermission', e.message));
+      try {
+        const isGranted = NativeSampleTurboModule.requestSamplePermission?.();
+        this._setResult('requestSamplePermission', isGranted);
+      } catch (e) {
+        this._setResult('requestSamplePermission', e.message);
+        return e.message;
+      }
     },
   };
 
@@ -326,6 +334,7 @@ class SampleTurboModuleExample extends React.Component<{}, State> {
                     </RNTesterText>
                   </TouchableOpacity>
                   <View style={[styles.column]}>
+                    {/* $FlowFixMe[incompatible-type] */}
                     {this._renderResult(item)}
                   </View>
                 </View>