@callstack/react-native-brownfield 6.1.0 → 6.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @callstack/react-native-brownfield
 
+## 6.2.0
+
+### Patch Changes
+
+- Updated dependencies [[`6517ec5`](https://github.com/callstack/react-native-brownfield/commit/6517ec5666269007f10c28efb7a748beba476998)]:
+  - @callstack/brownfield-cli@6.2.0
+
+## 6.1.1
+
+### Patch Changes
+
+- [#516](https://github.com/callstack/react-native-brownfield/pull/516) [`66ac701`](https://github.com/callstack/react-native-brownfield/commit/66ac701d71cb3990732e701a0ab1abd40a7bd271) Thanks [@malopezr7](https://github.com/malopezr7)! - Android: `ReactNativeBrownfield.initialize` can now be called again after it throws. Before, a failure while loading native libraries or creating the `ReactHost` left it marked as initialized, so the next call returned without error and `ReactNativeBrownfield.shared` was never set.
+
+- [#517](https://github.com/callstack/react-native-brownfield/pull/517) [`5884ce9`](https://github.com/callstack/react-native-brownfield/commit/5884ce96bcccf73de33835e7db2785aa3ab8c2a9) Thanks [@tlq5l](https://github.com/tlq5l)! - Fix an iOS crash (`std::bad_function_call`) when native code posts a message to JS while the Brownfield module's JS emitter is still being set up. If the Brownfield module exists but its JS emitter is not ready when delivery happens, the message is dropped and a log line is written. If the module does not exist yet, the message is dropped without a log line.
+- Updated dependencies [[`a9726c1`](https://github.com/callstack/react-native-brownfield/commit/a9726c137c61fe2e59c039555a955632a5d86aec)]:
+  - @callstack/brownfield-cli@6.1.1
+
 ## 6.1.0
 
 ### Minor Changes

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeBrownfield.kt

@@ -18,7 +18,6 @@ import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 import com.facebook.react.soloader.OpenSourceMergedSoMapping
 import com.facebook.soloader.SoLoader
 import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.atomic.AtomicBoolean
 
 fun interface OnJSBundleLoaded {
     operator fun invoke(timings: JSBundleTimings)
@@ -33,17 +32,15 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
 
     companion object {
         private lateinit var instance: ReactNativeBrownfield
-        private val initialized = AtomicBoolean()
-        private val nativeLibsLoaded = AtomicBoolean()
+        private val initialization = RetryableOnce()
+        private val nativeLibsLoading = RetryableOnce()
         private lateinit var applicationContext: Application
 
         @JvmStatic
         val shared: ReactNativeBrownfield get() = instance
 
         private fun loadNativeLibs(application: Application) {
-            if (!nativeLibsLoaded.getAndSet(true)) {
-                loadNativeLibsInternal(application)
-            }
+            nativeLibsLoading.run { loadNativeLibsInternal(application) }
         }
 
         private fun loadNativeLibsInternal(application: Application) {
@@ -65,11 +62,12 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHost, onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
@@ -81,11 +79,12 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             reactHostFactory: () -> ReactHost
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHostFactory(), onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
@@ -98,7 +97,7 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 val reactHost = getDefaultReactHost(
@@ -114,7 +113,8 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
                     jsRuntimeFactory = null
                 )
                 installAndPreload(reactHost, onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }

package/android/src/main/java/com/callstack/reactnativebrownfield/RetryableOnce.kt

@@ -0,0 +1,27 @@
+package com.callstack.reactnativebrownfield
+
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Runs a block at most once, counting only a run that completes.
+ *
+ * If the block throws, the next [run] call runs it again instead of treating
+ * the work as done. Calls made while a run is in progress are skipped.
+ */
+internal class RetryableOnce {
+    private val claimed = AtomicBoolean()
+
+    /** Returns `true` when [block] ran and completed during this call. */
+    fun run(block: () -> Unit): Boolean {
+        if (claimed.getAndSet(true)) {
+            return false
+        }
+        try {
+            block()
+        } catch (error: Throwable) {
+            claimed.set(false)
+            throw error
+        }
+        return true
+    }
+}

package/android/src/test/java/com/callstack/reactnativebrownfield/RetryableOnceTest.kt

@@ -0,0 +1,37 @@
+package com.callstack.reactnativebrownfield
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+
+class RetryableOnceTest {
+    @Test fun `runs the block once after it completes`() {
+        val once = RetryableOnce()
+        var runs = 0
+
+        assertTrue(once.run { runs++ })
+        assertFalse(once.run { runs++ })
+        assertEquals(1, runs)
+    }
+
+    @Test fun `runs the block again after it throws`() {
+        val once = RetryableOnce()
+        var runs = 0
+
+        try {
+            once.run {
+                runs++
+                throw UnsatisfiedLinkError("dlopen failed")
+            }
+            fail("expected the error to propagate")
+        } catch (expected: UnsatisfiedLinkError) {
+            assertEquals("dlopen failed", expected.message)
+        }
+
+        assertTrue(once.run { runs++ })
+        assertFalse(once.run { runs++ })
+        assertEquals(2, runs)
+    }
+}

package/ios/ReactNativeBrownfield.swift

@@ -307,7 +307,9 @@ internal import Expo
 
   /**
    * Send a serialized JSON message to the React Native JS application.
-   * The message is delivered as a `brownfieldMessage` DeviceEventEmitter event.
+   * Messages can be received using `ReactNativeBrownfield.onMessage()`.
+   * If the Brownfield module exists but its JS emitter is not ready when delivery happens, the message is dropped and a log line is written.
+   * If the module does not exist yet, the message is dropped without a log line.
    *
    * @param message - The serialized JSON message to send to the React Native JS application.
    * @example

package/ios/ReactNativeBrownfieldModule.mm

@@ -15,7 +15,9 @@ static ReactNativeBrownfieldModule *_sharedInstance = nil;
 - (instancetype)init {
   self = [super init];
   if (self) {
-    _sharedInstance = self;
+    @synchronized (ReactNativeBrownfieldModule.class) {
+      _sharedInstance = self;
+    }
 
     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(handleNativeToJSMessage:)
@@ -28,8 +30,18 @@ static ReactNativeBrownfieldModule *_sharedInstance = nil;
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
-  if (_sharedInstance == self) {
-    _sharedInstance = nil;
+  @synchronized (ReactNativeBrownfieldModule.class) {
+    if (_sharedInstance == self) {
+      _sharedInstance = nil;
+    }
+  }
+}
+
+// React Native calls invalidate during teardown; clearing the callback sends
+// later messages down the not-ready drop path.
+- (void)invalidate {
+  @synchronized (ReactNativeBrownfieldModule.class) {
+    _eventEmitterCallback = nullptr;
   }
 }
 
@@ -41,10 +53,22 @@ static ReactNativeBrownfieldModule *_sharedInstance = nil;
 }
 
 + (void)emitMessageFromNative:(NSString *)message {
-  if (_sharedInstance) {
+  // Keep singleton and callback access under one lock because getTurboModule:
+  // installs the callback when JS first requires the module.
+  @synchronized (ReactNativeBrownfieldModule.class) {
+    if (!_sharedInstance) {
+      NSLog(@"ReactNativeBrownfieldModule is not initialized, dropping message");
+      return;
+    }
+
+    // The codegen base class exposes this callback as a protected std::function;
+    // invoking it while empty would throw std::bad_function_call.
+    if (!_sharedInstance->_eventEmitterCallback) {
+      NSLog(@"ReactNativeBrownfieldModule is not ready for JS yet, dropping message");
+      return;
+    }
+
     [_sharedInstance emitOnBrownfieldMessage:@{ @"text": message }];
-  } else {
-    NSLog(@"ReactNativeBrownfieldModule is not initialized, dropping message");
   }
 }
 
@@ -65,7 +89,11 @@ RCT_EXPORT_METHOD(addListener:(NSString *)eventName) {}
 RCT_EXPORT_METHOD(removeListeners:(double)count) {}
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
-  return std::make_shared<facebook::react::NativeReactNativeBrownfieldModuleSpecJSI>(params);
+  // Building the spec installs _eventEmitterCallback; use the same lock as
+  // emitMessageFromNative: to prevent the callback read and write from racing.
+  @synchronized (ReactNativeBrownfieldModule.class) {
+    return std::make_shared<facebook::react::NativeReactNativeBrownfieldModuleSpecJSI>(params);
+  }
 }
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/react-native-brownfield",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "license": "MIT",
   "author": "Michal Chudziak <mike.chudziak@callstack.com>",
   "bin": {
@@ -100,7 +100,7 @@
     "@expo/config-plugins": ">=54 <100"
   },
   "dependencies": {
-    "@callstack/brownfield-cli": "^6.1.0",
+    "@callstack/brownfield-cli": "^6.2.0",
     "@react-native-community/cli-config": "^20.0.0",
     "@react-native-community/cli-types": "^20.0.0",
     "xcode": "^3.0.1"