fix(android): use ConcurrentHashMap for listeners to prevent ConcurrentModificationException (#286)

`onChanged` iterates `listeners.values` on a `Dispatchers.Default`
thread (the flow-collection coroutine), while
`addListener`/`removeListener` mutate the same map from the JS thread. A
plain `LinkedHashMap` fails fast with `ConcurrentModificationException`
when this overlap occurs.

`ConcurrentHashMap` iterates safely with concurrent mutations — no CME,
no locks needed at call sites.

Author: mfazekas

.github/workflows/ci.yml

@@ -507,6 +507,9 @@ jobs:
         run: |
           cd example
           bundle install
+          # Drop the experimental-generated lock so the legacy backend resolves
+          # fresh (avoids a stale fast_float podspec checksum mismatch).
+          rm -f ios/Podfile.lock ios/Pods/Manifest.lock
           USE_RIVE_LEGACY=1 bundle exec pod install --project-directory=ios
 
       - name: Save cocoapods cache

android/src/main/java/com/margelo/nitro/rive/BaseHybridViewModelPropertyImpl.kt

@@ -3,6 +3,7 @@ package com.margelo.nitro.rive
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
@@ -11,20 +12,21 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.drop
 import java.lang.ref.WeakReference
 import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
 
 @Keep
 @DoNotStrip
 class BaseHybridViewModelPropertyImpl<T> : BaseHybridViewModelProperty<T> {
   override var scope: CoroutineScope? = null
   override var job: Job? = null
-  override val listeners = mutableMapOf<String, (T) -> Unit>()
+  override val listeners = ConcurrentHashMap<String, (T) -> Unit>()
 
   override fun ensureValueListenerJob(valueFlow: Flow<T>, drop: Int) {
     if (scope == null) {
       scope = CoroutineScope(Dispatchers.Default)
     }
     if (job == null) {
-      job = scope?.launch {
+      job = scope?.launch(start = CoroutineStart.UNDISPATCHED) {
         valueFlow.drop(drop).collect { value ->
           onChanged(value)
         }

android/src/new/java/com/margelo/nitro/rive/HybridViewModelTriggerProperty.kt

@@ -18,7 +18,9 @@ class HybridViewModelTriggerProperty(
 
   override fun addListener(onChanged: () -> Unit): () -> Unit {
     val remover = addListenerInternal { _ -> onChanged() }
-    ensureValueListenerJob(instance.getTriggerFlow(path), 1)
+    // Triggers use drop=0: getTriggerFlow has replay=0 and emits nothing on
+    // subscription, so there is no initial value to skip.
+    ensureValueListenerJob(instance.getTriggerFlow(path), 0)
     return remover
   }
 }

android/src/new/java/com/rive/RiveReactNativeView.kt

@@ -132,6 +132,12 @@ class RiveReactNativeView(context: ThemedReactContext) : FrameLayout(context) {
           worker.advanceStateMachine(sm, deltaTime)
           worker.draw(art, sm, rs, activeFit)
           frameCount++
+          // Signal readiness only once the state machine is actually running
+          // (surface created + first frame drawn), so callers awaiting
+          // awaitViewReady() before firing triggers don't fire too early.
+          if (frameCount == 1L) {
+            viewReadyDeferred.complete(true)
+          }
         } catch (e: Exception) {
           Log.e(TAG, "Render loop error", e)
         }
@@ -203,7 +209,6 @@ class RiveReactNativeView(context: ThemedReactContext) : FrameLayout(context) {
       applyDataBinding(config.bindData, config.riveFile)
     }
 
-    viewReadyDeferred.complete(true)
   }
 
   private fun resizeArtboardIfLayout() {

example/__tests__/use-rive-trigger.harness.tsx

@@ -14,6 +14,7 @@ import {
   RiveView,
   useRiveTrigger,
   type RiveFile,
+  type RiveViewRef,
 } from '@rive-app/react-native';
 import type { ViewModelInstance } from '@rive-app/react-native';
 
@@ -39,10 +40,33 @@ type TriggerContext = {
   triggerFn: (() => void) | null;
   error: Error | null;
   renderCount: number;
+  ref: RiveViewRef | null;
 };
 
 function createTriggerContext(): TriggerContext {
-  return { triggerCount: 0, triggerFn: null, error: null, renderCount: 0 };
+  return {
+    triggerCount: 0,
+    triggerFn: null,
+    error: null,
+    renderCount: 0,
+    ref: null,
+  };
+}
+
+/**
+ * Waits until the Rive view's state machine is live before firing triggers.
+ * A fireTrigger() issued before the surface/state-machine is advancing is
+ * dropped (the instance's trigger flow never emits it), so tests must wait for
+ * readiness first instead of firing synchronously on mount.
+ */
+async function waitForViewReady(context: TriggerContext): Promise<void> {
+  await waitFor(
+    () => {
+      expect(context.ref).not.toBeNull();
+    },
+    { timeout: 5000 }
+  );
+  await context.ref!.awaitViewReady();
 }
 
 // ─── Test component: stable callback ───────────────────────────────
@@ -74,6 +98,11 @@ function StableTriggerComponent({
   return (
     <View style={{ width: 200, height: 200 }}>
       <RiveView
+        hybridRef={{
+          f: (ref: RiveViewRef | null) => {
+            context.ref = ref;
+          },
+        }}
         file={file}
         fit={Fit.Contain}
         dataBind={instance}
@@ -123,6 +152,11 @@ function UnstableTriggerComponent({
   return (
     <View style={{ width: 200, height: 200 }}>
       <RiveView
+        hybridRef={{
+          f: (ref: RiveViewRef | null) => {
+            context.ref = ref;
+          },
+        }}
         file={file}
         fit={Fit.Contain}
         dataBind={instance}
@@ -156,8 +190,9 @@ describe('useRiveTrigger hook', () => {
 
     expect(context.error).toBeNull();
 
-    // Fire trigger and wait for it — pollChanges() runs on frame ticks,
-    // so we wait for each trigger individually to avoid coalescing.
+    // Wait for the state machine to be live before firing — an early
+    // fireTrigger() (before the surface/state-machine is advancing) is dropped.
+    await waitForViewReady(context);
     context.triggerFn!();
 
     await waitFor(
@@ -200,6 +235,7 @@ describe('useRiveTrigger hook', () => {
     expect(context.error).toBeNull();
 
     // Fire trigger AFTER the re-render burst — before the fix, this was lost
+    await waitForViewReady(context);
     context.triggerFn!();
 
     await waitFor(