@qafka/react-native 2.3.4 → 2.3.6

package/android/src/main/java/com/qafka/audio/QafkaAudioModule.kt

@@ -184,11 +184,18 @@ class QafkaAudioModule(reactContext: ReactApplicationContext) :
                 dlogW("⚠️ AutomaticGainControl NOT available on this device")
             }
 
-            // Initialize AudioTrack for playback
+            // Initialize AudioTrack for playback.
+            // The voice-communication output path favors low latency with a
+            // small default buffer; that underruns on jittery streamed network
+            // audio and makes playback choppy ("skipping"). Size the buffer for
+            // ~0.4s of audio to absorb jitter — smoothness matters more than
+            // latency for an assistant reply.
             val playMinBuffer = AudioTrack.getMinBufferSize(
                 PLAYBACK_SAMPLE_RATE, CHANNEL_OUT, AUDIO_ENCODING
             )
-            val playBufferSize = maxOf(playMinBuffer, 4096)
+            // bytes/sec = sampleRate * 2 (16-bit mono); * 4 / 10 ≈ 0.4s
+            val jitterBufferBytes = PLAYBACK_SAMPLE_RATE * 2 * 4 / 10
+            val playBufferSize = maxOf(playMinBuffer * 2, jitterBufferBytes)
 
             // iOS VPIO equivalent (part 2): play on the voice-communication path
             // (USAGE_VOICE_COMMUNICATION + CONTENT_TYPE_SPEECH) so the echo

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.4",
+  "version": "2.3.6",
   "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",