@qafka/react-native 2.3.5 → 2.3.7

package/dist/hooks/useVoiceChat.js

@@ -358,12 +358,21 @@ function useVoiceChat({ apiUrl, apiKey, userContext, contextDescription, onToolS
         }
     }, []);
     const connect = (0, react_1.useCallback)(async () => {
-        if (serviceRef.current?.isConnected) {
-            // Re-entering the voice page after a swipe to chat (which calls pauseMic
-            // and stops native capture). The socket is still open, so the fresh-
-            // connect path below would no-op and leave the mic stopped — resume
-            // capture so the user can be heard again.
-            await serviceRef.current.resumeMic();
+        // A service already exists for this voice session — do NOT create a second.
+        // The scroll handler fires connect() repeatedly while the pager settles on
+        // the voice page; the previous `isConnected` guard passed for two near-
+        // simultaneous calls (the first WS hadn't opened yet), so each spawned a
+        // RealtimeService and the first was orphaned but kept streaming mic + audio
+        // (two interleaved audio streams = choppy playback; the orphan still heard
+        // the mic = "mute didn't work"). Guard on existence, set synchronously
+        // below before any await, to close that race.
+        if (serviceRef.current) {
+            if (serviceRef.current.isConnected) {
+                // Re-entering the voice page after a swipe to chat (which calls pauseMic
+                // and stops native capture). The socket is still open — resume capture
+                // so the user can be heard again.
+                await serviceRef.current.resumeMic();
+            }
             return;
         }
         setState('connecting');

package/dist/native/QafkaAudio.js

@@ -3,7 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QafkaAudio = void 0;
 const react_native_1 = require("react-native");
 const ensure_record_permission_1 = require("./ensure-record-permission");
+const serial_lock_1 = require("./serial-lock");
 const { QafkaAudio: NativeQafkaAudio } = react_native_1.NativeModules;
+// Serialize the native audio lifecycle. The native module is a process-wide
+// singleton with shared mutable state (capture thread, AudioRecord/AudioTrack).
+// On a quick leave-and-reenter of voice, the previous session's stopCapture is
+// fired un-awaited and would otherwise race the next startCapture, corrupting
+// the new session's playback (choppy / overlapping audio). One queue for both
+// guarantees a stop fully completes before the next start begins.
+const lifecycleQueue = (0, serial_lock_1.createSerialQueue)();
 const emitter = NativeQafkaAudio ? new react_native_1.NativeEventEmitter(NativeQafkaAudio) : null;
 const MISSING_MODULE_MESSAGE = `QafkaAudio native module is not linked. ` +
     `The JS bundle was updated but the native binary was not rebuilt. ` +
@@ -35,8 +43,8 @@ exports.QafkaAudio = {
             return result === react_native_1.PermissionsAndroid.RESULTS.GRANTED;
         },
     }),
-    startCapture: () => requireModule().startCapture(),
-    stopCapture: () => requireModule().stopCapture(),
+    startCapture: () => lifecycleQueue(() => requireModule().startCapture()),
+    stopCapture: () => lifecycleQueue(() => requireModule().stopCapture()),
     playAudioChunk: (base64Data) => requireModule().playAudioChunk(base64Data),
     stopPlayback: () => requireModule().stopPlayback(),
     onAudioData: (callback) => {

package/dist/native/serial-lock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create a serial execution queue: each submitted operation runs only after the
+ * previous one has fully settled, so two operations never overlap.
+ *
+ * Used to serialize native audio lifecycle calls (startCapture / stopCapture).
+ * The native module is a process-wide singleton with shared mutable state; when
+ * the user leaves and quickly re-enters voice, an un-awaited teardown
+ * (stopCapture) can otherwise race the next startCapture and corrupt the new
+ * session's audio track. Routing both through one queue removes that race.
+ *
+ * A failing operation does not break the chain — the next one still runs.
+ */
+export declare function createSerialQueue(): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/native/serial-lock.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSerialQueue = createSerialQueue;
+/**
+ * Create a serial execution queue: each submitted operation runs only after the
+ * previous one has fully settled, so two operations never overlap.
+ *
+ * Used to serialize native audio lifecycle calls (startCapture / stopCapture).
+ * The native module is a process-wide singleton with shared mutable state; when
+ * the user leaves and quickly re-enters voice, an un-awaited teardown
+ * (stopCapture) can otherwise race the next startCapture and corrupt the new
+ * session's audio track. Routing both through one queue removes that race.
+ *
+ * A failing operation does not break the chain — the next one still runs.
+ */
+function createSerialQueue() {
+    let tail = Promise.resolve();
+    return function run(fn) {
+        // Chain off the tail regardless of whether it resolved or rejected, so one
+        // failure can't wedge the queue.
+        const result = tail.then(fn, fn);
+        tail = result.then(() => undefined, () => undefined);
+        return result;
+    };
+}

package/dist/services/RealtimeService.d.ts

@@ -51,6 +51,7 @@ export declare class RealtimeService {
     private audioChunksSent;
     private sessionTokenGetter;
     private appVersion;
+    private disposed;
     constructor(apiUrl: string, apiKey: string);
     setSessionTokenGetter(fn: () => Promise<string | null>): void;
     connect(onEvent: RealtimeEventHandler, options?: {

package/dist/services/RealtimeService.js

@@ -12,6 +12,11 @@ class RealtimeService {
     audioChunksSent = 0;
     sessionTokenGetter = null;
     appVersion = null;
+    // Set once disconnect() has torn this session down. Guards against the ws
+    // `onclose` (fired by our own ws.close()) running a SECOND cleanup/stopCapture
+    // — which, after the user has reopened voice, would tear down the NEW
+    // session's shared native audio engine.
+    disposed = false;
     constructor(apiUrl, apiKey) {
         this.apiUrl = apiUrl;
         this.apiKey = apiKey;
@@ -95,7 +100,12 @@ class RealtimeService {
                 reject(new Error('WebSocket connection failed'));
             };
             this.ws.onclose = (event) => {
-                this.cleanup();
+                // On a graceful disconnect() we've already cleaned up; skip the redundant
+                // teardown so it can't stop a newer session's shared native audio engine.
+                // On an UNEXPECTED close (network drop) disposed is false → still clean up.
+                if (!this.disposed) {
+                    this.cleanup();
+                }
                 this.eventHandler?.({
                     type: 'session.closed',
                     reason: event.reason || 'CONNECTION_CLOSED',
@@ -190,6 +200,9 @@ class RealtimeService {
         }));
     }
     async disconnect() {
+        // Mark disposed BEFORE closing the ws so the onclose handler (which our
+        // ws.close() triggers) skips its redundant cleanup/stopCapture.
+        this.disposed = true;
         await this.cleanup();
         if (this.ws?.readyState === WebSocket.OPEN) {
             this.ws.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qafka/react-native",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "description": "Drop-in AI assistant for React Native: chat, voice, and tool execution with screen-aware navigation.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",