@qafka/react-native 2.0.0

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

@@ -0,0 +1,290 @@
+package com.qafka.audio
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.AudioTrack
+import android.media.MediaRecorder
+import android.media.audiofx.AcousticEchoCanceler
+import android.media.audiofx.AutomaticGainControl
+import android.media.audiofx.NoiseSuppressor
+import android.util.Base64
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class QafkaAudioModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "QafkaAudio"
+
+    private var audioRecord: AudioRecord? = null
+    private var audioTrack: AudioTrack? = null
+    private var captureThread: Thread? = null
+    @Volatile private var isCapturing = false
+    private var listenerCount = 0
+
+    // iOS VPIO equivalent — hardware AEC + NS + AGC (android.media.audiofx).
+    // Enables barge-in by cancelling playback echo at mic level.
+    // Device-dependent; isAvailable() + null checks keep it safe.
+    private var echoCanceler: AcousticEchoCanceler? = null
+    private var noiseSuppressor: NoiseSuppressor? = null
+    private var automaticGainControl: AutomaticGainControl? = null
+
+    companion object {
+        private const val TAG = "QafkaAudio"
+        private const val CAPTURE_SAMPLE_RATE = 16000
+        private const val PLAYBACK_SAMPLE_RATE = 24000
+        private const val CHANNEL_IN = AudioFormat.CHANNEL_IN_MONO
+        private const val CHANNEL_OUT = AudioFormat.CHANNEL_OUT_MONO
+        private const val AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT
+    }
+
+    /**
+     * True when the consumer app is built in debug mode. Used to gate noisy
+     * info/warn logs so they never reach release builds. Real errors still
+     * call Log.e directly.
+     */
+    private val isDebugBuild: Boolean by lazy {
+        (reactApplicationContext.applicationInfo.flags and
+            android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0
+    }
+
+    private fun dlogI(message: String) {
+        if (isDebugBuild) Log.i(TAG, message)
+    }
+
+    private fun dlogW(message: String) {
+        if (isDebugBuild) Log.w(TAG, message)
+    }
+
+    // MARK: - Event Emitter support
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        listenerCount++
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        listenerCount -= count
+        if (listenerCount < 0) listenerCount = 0
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        if (listenerCount > 0) {
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, params)
+        }
+    }
+
+    // MARK: - Capture
+
+    @ReactMethod
+    fun startCapture(promise: Promise) {
+        if (isCapturing) {
+            promise.resolve(true)
+            return
+        }
+
+        // Check permission
+        val permission = ContextCompat.checkSelfPermission(
+            reactApplicationContext,
+            Manifest.permission.RECORD_AUDIO
+        )
+        if (permission != PackageManager.PERMISSION_GRANTED) {
+            promise.reject("PERMISSION_DENIED", "RECORD_AUDIO permission not granted")
+            return
+        }
+
+        val minBufferSize = AudioRecord.getMinBufferSize(
+            CAPTURE_SAMPLE_RATE, CHANNEL_IN, AUDIO_ENCODING
+        )
+        if (minBufferSize == AudioRecord.ERROR || minBufferSize == AudioRecord.ERROR_BAD_VALUE) {
+            promise.reject("AUDIO_ERROR", "Failed to get minimum buffer size for AudioRecord")
+            return
+        }
+
+        val bufferSize = maxOf(minBufferSize, 4096)
+
+        try {
+            val record = AudioRecord(
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION,
+                CAPTURE_SAMPLE_RATE,
+                CHANNEL_IN,
+                AUDIO_ENCODING,
+                bufferSize
+            )
+
+            if (record.state != AudioRecord.STATE_INITIALIZED) {
+                record.release()
+                promise.reject("AUDIO_ERROR", "Failed to initialize AudioRecord")
+                return
+            }
+
+            // iOS VPIO equivalent — hardware AEC + NS + AGC, bound to AudioRecord sessionId.
+            val sessionId = record.audioSessionId
+
+            if (AcousticEchoCanceler.isAvailable()) {
+                echoCanceler = AcousticEchoCanceler.create(sessionId)?.also {
+                    it.enabled = true
+                    dlogI("✅ AcousticEchoCanceler enabled (sessionId=$sessionId)")
+                }
+                if (echoCanceler == null) dlogW("⚠️ AcousticEchoCanceler.create returned null")
+            } else {
+                dlogW("⚠️ AcousticEchoCanceler NOT available on this device")
+            }
+
+            if (NoiseSuppressor.isAvailable()) {
+                noiseSuppressor = NoiseSuppressor.create(sessionId)?.also {
+                    it.enabled = true
+                    dlogI("✅ NoiseSuppressor enabled")
+                }
+                if (noiseSuppressor == null) dlogW("⚠️ NoiseSuppressor.create returned null")
+            } else {
+                dlogW("⚠️ NoiseSuppressor NOT available on this device")
+            }
+
+            if (AutomaticGainControl.isAvailable()) {
+                automaticGainControl = AutomaticGainControl.create(sessionId)?.also {
+                    it.enabled = true
+                    dlogI("✅ AutomaticGainControl enabled")
+                }
+                if (automaticGainControl == null) dlogW("⚠️ AutomaticGainControl.create returned null")
+            } else {
+                dlogW("⚠️ AutomaticGainControl NOT available on this device")
+            }
+
+            // Initialize AudioTrack for playback
+            val playMinBuffer = AudioTrack.getMinBufferSize(
+                PLAYBACK_SAMPLE_RATE, CHANNEL_OUT, AUDIO_ENCODING
+            )
+            val playBufferSize = maxOf(playMinBuffer, 4096)
+
+            val track = AudioTrack.Builder()
+                .setAudioFormat(
+                    AudioFormat.Builder()
+                        .setSampleRate(PLAYBACK_SAMPLE_RATE)
+                        .setChannelMask(CHANNEL_OUT)
+                        .setEncoding(AUDIO_ENCODING)
+                        .build()
+                )
+                .setBufferSizeInBytes(playBufferSize)
+                .setTransferMode(AudioTrack.MODE_STREAM)
+                .build()
+
+            track.play()
+
+            audioRecord = record
+            audioTrack = track
+            isCapturing = true
+
+            record.startRecording()
+
+            // Start capture thread
+            captureThread = Thread {
+                val readBuffer = ShortArray(bufferSize / 2)
+
+                while (isCapturing) {
+                    val shortsRead = record.read(readBuffer, 0, readBuffer.size)
+                    if (shortsRead > 0) {
+                        // Convert shorts to bytes (little-endian PCM 16-bit)
+                        val byteBuffer = ByteArray(shortsRead * 2)
+                        for (i in 0 until shortsRead) {
+                            byteBuffer[i * 2] = (readBuffer[i].toInt() and 0xFF).toByte()
+                            byteBuffer[i * 2 + 1] = (readBuffer[i].toInt() shr 8 and 0xFF).toByte()
+                        }
+
+                        val base64 = Base64.encodeToString(byteBuffer, Base64.NO_WRAP)
+                        val params = Arguments.createMap().apply {
+                            putString("audio", base64)
+                        }
+                        sendEvent("onAudioData", params)
+                    }
+                }
+            }.apply {
+                name = "QafkaAudioCapture"
+                start()
+            }
+
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("AUDIO_ERROR", "Failed to start capture: ${e.message}", e)
+        }
+    }
+
+    // MARK: - Stop Capture
+
+    @ReactMethod
+    fun stopCapture(promise: Promise) {
+        isCapturing = false
+
+        try {
+            captureThread?.join(2000)
+        } catch (_: InterruptedException) {}
+        captureThread = null
+
+        // Release audio effects BEFORE AudioRecord — they depend on its sessionId
+        try { echoCanceler?.release() } catch (_: Exception) {}
+        echoCanceler = null
+        try { noiseSuppressor?.release() } catch (_: Exception) {}
+        noiseSuppressor = null
+        try { automaticGainControl?.release() } catch (_: Exception) {}
+        automaticGainControl = null
+
+        try {
+            audioRecord?.stop()
+            audioRecord?.release()
+        } catch (_: Exception) {}
+        audioRecord = null
+
+        try {
+            audioTrack?.stop()
+            audioTrack?.release()
+        } catch (_: Exception) {}
+        audioTrack = null
+
+        promise.resolve(true)
+    }
+
+    // MARK: - Playback
+
+    @ReactMethod
+    fun playAudioChunk(base64Data: String, promise: Promise) {
+        val track = audioTrack
+        if (track == null) {
+            promise.reject("NOT_RUNNING", "Audio is not running. Call startCapture first.")
+            return
+        }
+
+        try {
+            val audioBytes = Base64.decode(base64Data, Base64.DEFAULT)
+            track.write(audioBytes, 0, audioBytes.size)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PLAYBACK_ERROR", "Failed to play audio chunk: ${e.message}", e)
+        }
+    }
+
+    // MARK: - Stop Playback
+
+    @ReactMethod
+    fun stopPlayback(promise: Promise) {
+        val track = audioTrack ?: run {
+            promise.resolve(true)
+            return
+        }
+
+        try {
+            track.pause()
+            track.flush()
+            track.play()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PLAYBACK_ERROR", "Failed to stop playback: ${e.message}", e)
+        }
+    }
+}

package/android/src/main/java/com/qafka/clipboard/QafkaClipboardModule.kt

@@ -0,0 +1,28 @@
+package com.qafka.clipboard
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class QafkaClipboardModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "QafkaClipboard"
+
+    @ReactMethod
+    fun setString(value: String, promise: Promise) {
+        try {
+            val clipboard = reactApplicationContext.getSystemService(
+                Context.CLIPBOARD_SERVICE
+            ) as ClipboardManager
+            clipboard.setPrimaryClip(ClipData.newPlainText("Qafka", value))
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("CLIPBOARD_WRITE_FAILED", e.message, e)
+        }
+    }
+}

package/android/src/main/java/com/qafka/storage/QafkaStorageModule.kt

@@ -0,0 +1,80 @@
+package com.qafka.storage
+
+import android.content.SharedPreferences
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+
+class QafkaStorageModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "QafkaStorage"
+
+    private val prefs: SharedPreferences by lazy {
+        val masterKey = MasterKey.Builder(reactApplicationContext)
+            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+            .build()
+
+        EncryptedSharedPreferences.create(
+            reactApplicationContext,
+            FILE_NAME,
+            masterKey,
+            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
+        )
+    }
+
+    @ReactMethod
+    fun getItem(key: String, promise: Promise) {
+        try {
+            val value = prefs.getString(key, null)
+            promise.resolve(value)
+        } catch (e: Exception) {
+            promise.reject("STORAGE_READ_FAILED", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setItem(key: String, value: String, promise: Promise) {
+        try {
+            prefs.edit().putString(key, value).apply()
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("STORAGE_WRITE_FAILED", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun removeItem(key: String, promise: Promise) {
+        try {
+            prefs.edit().remove(key).apply()
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("STORAGE_DELETE_FAILED", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun multiRemove(keys: ReadableArray, promise: Promise) {
+        try {
+            val editor = prefs.edit()
+            for (i in 0 until keys.size()) {
+                val key = keys.getString(i) ?: continue
+                editor.remove(key)
+            }
+            editor.apply()
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("STORAGE_DELETE_FAILED", e.message, e)
+        }
+    }
+
+    companion object {
+        private const val FILE_NAME = "qafka_secure_prefs"
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./expo-plugin/withQafkaAttestation');

package/dist/QafkaSDK.d.ts

@@ -0,0 +1,174 @@
+import { SDKConfig, SDKStatusType, ChatMessage, ChatResponse } from './types';
+/**
+ * QafkaSDK - Main SDK class
+ * Provides AI-powered conversational interface for React Native apps
+ */
+export declare class QafkaSDK {
+    private static instance;
+    private config;
+    private status;
+    private subProjectId;
+    private backendService;
+    private attestationManager;
+    private conversationManager;
+    private navigationHandler;
+    private themePrefetchPromise;
+    private constructor();
+    /**
+    * Get singleton instance
+    */
+    static getInstance(): QafkaSDK;
+    /**
+    * Initialize SDK
+    */
+    initialize(config: SDKConfig): Promise<void>;
+    /**
+    * developer-driven locale (BCP 47 — e.g. "tr", "en", "tr-TR").
+    * Forwarded to BackendService so it lands in `sdkContext.locale` on every
+    * outgoing chat request, which the server then echoes into the user-message
+    * context prefix. Same value should drive UI strings on the SDK side.
+    *
+    * Pass `null` to clear (e.g. when switching back to instructions-default).
+    * Calling before initialize() is a no-op; pass `locale` via SDKConfig instead.
+    */
+    setLocale(locale: string | null): void;
+    /**
+     * Tool Data Channel: register the partner-provided resolver
+     * that supplies opaque PII bags for `{{tooldata.X}}` substitution on
+     * the backend. Called from `Qafka.tsx` whenever the `onToolDataRequested`
+     * prop changes. Pass `null` to clear.
+     */
+    setOnToolDataRequested(resolver: ((tool: {
+        key: string;
+        name: string;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>) | null): void;
+    /**
+    * Returns the current device-attestation session token (or `null` when
+    * attestation is unavailable). Voice mode passes this in the auth frame so
+    * the realtime WS opens against an attested session.
+    */
+    getSessionToken(): Promise<string | null>;
+    /**
+     * Propagate the validated end-user identity from the React component
+     * into the transport layer. Called by `<Qafka />` in an effect whenever
+     * the `endUserId` / `endUserData` props change. Validation happens at
+     * the component boundary (`validate-end-user.ts`).
+     */
+    setEndUser(endUserId: string, endUserData?: Record<string, unknown>): void;
+    /**
+    * Send a chat message
+    */
+    sendMessage(message: string, context?: Record<string, any>, contextDescription?: string, isInitialMessage?: boolean): Promise<ChatResponse>;
+    /**
+    * Send message with streaming response
+    */
+    sendMessageStream(message: string, onChunk: (chunk: string) => void, onComplete?: (response: ChatResponse) => void, onError?: (error: Error) => void, context?: Record<string, any>, contextDescription?: string, onToolSuggestions?: (tools: any[], conversationId?: string, messageId?: string) => void, // Tool suggestions callback
+    isInitialMessage?: boolean, onActionResult?: (results: Array<{
+        actionType: string;
+        success: boolean;
+        message: string;
+    }>) => void, // Action result callback
+    onStepCompleted?: (result: {
+        tool: string;
+        step: string;
+        data: Record<string, any>;
+        actionResults?: Array<{
+            actionType: string;
+            success: boolean;
+            message: string;
+        }>;
+    }) => void, // Step completed callback
+    onFileUploadRequest?: (request: any) => void, // File upload request callback
+    onExtractionResult?: (result: any) => void, // Extraction result callback
+    onToolStatus?: (event: {
+        toolKey: string;
+        message: string;
+        stage: string;
+    }) => void, onToolResultPayload?: (event: {
+        toolKey: string;
+        data: unknown;
+        uiConfig?: any;
+    }) => void, onFinalChunk?: (content: string) => void): Promise<void>;
+    /**
+    * Get conversation history
+    */
+    getConversationHistory(): Promise<ChatMessage[]>;
+    /**
+    * Clear conversation history
+    */
+    clearConversation(): Promise<void>;
+    /**
+    * Start a new conversation
+    * Clears history and returns the new session ID
+    */
+    startNewConversation(): Promise<string>;
+    /**
+    * Add tool response to conversation
+    * Use this after executing a tool to display the results
+    */
+    addToolResponse(toolKey: string, data: any, tool: any): ChatMessage;
+    /**
+    * Post a tool result back to the backend so the AI can continue its turn.
+    */
+    postToolResult(payload: {
+        conversationId: string;
+        messageId: string;
+        toolKey: string;
+        data: unknown;
+        sdkContext?: Record<string, unknown>;
+    }, onFinalChunk: (content: string) => void, onDone: () => void, onError: (err: Error) => void, onCard?: (card: {
+        templateId: string;
+        templateSlug: string;
+        definition: any;
+        data: any;
+    }) => void): Promise<void>;
+    /**
+    * Upload a file attached to a tool flow.
+    */
+    uploadFile(toolId: string, file: {
+        uri: string;
+        name: string;
+        type: string;
+    }, conversationId?: string): Promise<any>;
+    /**
+    * Get project theme configuration
+    */
+    getProjectTheme(): Promise<any>;
+    /**
+    * Returns the in-flight theme prefetch (kicked off in initialize() parallel
+    * with attestation). Used by `useProjectTheme` to paint the branded greeting
+    * without waiting for `status === 'ready'`. Returns `null` if initialize()
+    * hasn't been called yet or if prefetch already settled.
+    */
+    getThemePrefetch(): Promise<any> | null;
+    /**
+    * Fetches the project theme via BackendService and writes the result to
+    * persistent cache so subsequent chat opens paint instantly.
+    */
+    private prefetchAndCacheTheme;
+    /**
+    * Get SDK status
+    */
+    getStatus(): SDKStatusType;
+    /**
+    * Get SDK configuration
+    */
+    getConfig(): SDKConfig | null;
+    /**
+    * Navigate to screen
+    */
+    navigate(screenName: string, params?: any): void;
+    /**
+    * Generate unique ID
+    */
+    private generateId;
+    /**
+    * Resolve API key from config
+    */
+    private resolveApiKey;
+    /**
+    * Destroy SDK instance
+    */
+    destroy(): Promise<void>;
+}
+export declare const getSDK: () => QafkaSDK;