fix(android): prevent one-shot Callback double-invoke crash (New Architecture)

[susonthapa]

Problem

On Android with the New Architecture (newArchEnabled=true), play() and prepare() can crash the whole app with SIGABRT:

JavaTurboModule.cpp  LOG(FATAL) "Callback arg cannot be called more than once"

Both methods register two MediaPlayer listeners that wrap the same one-shot React Native Callback:

• play() → OnCompletionListener + OnErrorListener
• prepare() → OnPreparedListener + OnErrorListener

…and the early null-player / no-resource paths can also invoke that same Callback.

Each listener guarded itself with its own callbackWasCalled boolean. Those flags are per-listener, so they don't coordinate across the two listeners — when an error arrives right after completion (or during a teardown race), the same Callback is invoked a second time.

On the legacy bridge that second invoke threw a catchable RuntimeException, which the surrounding try/catch swallowed — so it was invisible. Under the New Architecture, a second invoke of a one-shot Callback is a LOG(FATAL) → std::abort(), which is not catchable. The try/catch no longer protects anything and the process crashes.

This is the same class of crash documented across several RN libraries after the New-Arch migration (e.g. AppsFlyer plugin #601, react-native-image-picker #2390). Related: #152 ("Illegal callback invocation from native module. This callback type only permits a single invocation from native code.").

Fix

Replace the independent per-listener flags with one shared AtomicBoolean latch per callback, routed through a local fire() gate:

val invoked = AtomicBoolean(false)
fun fire(vararg args: Any?) {
  if (invoked.compareAndSet(false, true)) {
    callback.invoke(*args)
  } else {
    Log.w(TAG, "skip double-invoke: source=prepare reason=callback_already_used")
  }
}

Every invoke site in play() / prepare() (early-return paths + both listeners) goes through fire(). compareAndSet makes the first invoke win atomically and drops any later invoke (logged at Log.w), so the exactly-once contract now holds across both listeners and every early-return path — on both the old and new architectures. The now-useless try/catch (RuntimeException) blocks are removed.

Behavior is unchanged on the happy path: the first verdict (success or error, with its original arguments) is delivered exactly as before.

Scope

• android/src/main/java/com/zmxv/RNSound/Sound.kt only — play() and prepare(). iOS and the JS layer are untouched. Other single-invoke synchronous callbacks (stop, pause, getCurrentTime, …) are not affected and were left alone.

Testing

Verified in a production New-Arch app (RN 0.81.5): with the original code the app reliably aborts (SIGABRT, CxxCallbackImpl.invoke -> Sound.play) on a play()→release() teardown race around clip completion; with this change it no longer aborts and the completion callback fires exactly once. The fix has also been driven through an exhaustive event-ordering matrix ({completion}, {error}, {completion,error}, {error,completion}, double/triple completion, early no-resource) asserting exactly-once + first-verdict-wins.