@phonghq/go-chat 1.0.8 → 1.0.10

package/dist/test/composable/TestSound.js

@@ -0,0 +1,196 @@
+import { ref, onBeforeUnmount } from 'vue';
+export function useAudioStream(wsUrl) {
+    const SAMPLE_RATE = 24000;
+    const CHUNK_SIZE = 480;
+    const PREBUFFER_SEC = 0.4;
+    let audioCtx;
+    let processor;
+    let input;
+    let stream;
+    const ws = ref(null);
+    const statusText = ref('Tap to Speak with Vico');
+    // Speaker queue
+    let speakerQueue = [];
+    let nextPlayTime = 0;
+    // UI state
+    const recording = ref(false);
+    const micLevel = ref(0);
+    // Status management
+    const STATUS = {
+        IDLE: 'Tap to Speak with Vico',
+        CONNECTING: 'Connecting...',
+        LISTENING: 'Listening...',
+        SPEAKING: 'Speaking...'
+    };
+    let currentStatus = STATUS.IDLE;
+    function setStatus(newStatus) {
+        if (currentStatus !== newStatus) {
+            currentStatus = newStatus;
+            statusText.value = newStatus;
+        }
+    }
+    // 🎤 Float32 → PCM16
+    function floatTo16BitPCM(float32Array) {
+        const buffer = new ArrayBuffer(float32Array.length * 2);
+        const view = new DataView(buffer);
+        for (let i = 0; i < float32Array.length; i++) {
+            let s = Math.max(-1, Math.min(1, float32Array[i]));
+            view.setInt16(i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+        }
+        return buffer;
+    }
+    // 🔊 PCM16 → Float32
+    function int16ToFloat32(int16Array) {
+        const float32 = new Float32Array(int16Array.length);
+        for (let i = 0; i < int16Array.length; i++) {
+            float32[i] = int16Array[i] / 32768;
+        }
+        return float32;
+    }
+    // 📥 enqueue speaker chunk
+    async function enqueueSpeakerChunk(arrayBuffer) {
+        const int16View = new Int16Array(arrayBuffer);
+        const float32Data = int16ToFloat32(int16View);
+        speakerQueue.push(float32Data);
+    }
+    // 🔊 process queue
+    function processSpeakerQueue() {
+        try {
+            if (speakerQueue.length > 0) {
+                const chunk = speakerQueue.shift();
+                if (chunk) {
+                    const audioBuffer = audioCtx.createBuffer(1, chunk.length, SAMPLE_RATE);
+                    audioBuffer.getChannelData(0).set(chunk);
+                    const source = audioCtx.createBufferSource();
+                    source.buffer = audioBuffer;
+                    source.connect(audioCtx.destination);
+                    if (nextPlayTime < audioCtx.currentTime + 0.05) {
+                        nextPlayTime = audioCtx.currentTime + PREBUFFER_SEC;
+                    }
+                    source.start();
+                    nextPlayTime += audioBuffer.duration;
+                    setStatus(STATUS.SPEAKING);
+                }
+            }
+            else if (recording.value) {
+                setStatus(STATUS.LISTENING);
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+        requestAnimationFrame(processSpeakerQueue);
+    }
+    // 🎤 start mic
+    async function startRecording() {
+        audioCtx = new AudioContext({ sampleRate: SAMPLE_RATE });
+        return;
+        stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        input = audioCtx.createMediaStreamSource(stream);
+        processor = audioCtx.createScriptProcessor(1024, 1, 1);
+        processor.onaudioprocess = (e) => {
+            if (!ws.value || ws.value.readyState !== WebSocket.OPEN)
+                return;
+            const inputData = e.inputBuffer.getChannelData(0);
+            // calculate mic level
+            let sum = 0;
+            for (let i = 0; i < inputData.length; i++)
+                sum += inputData[i] ** 2;
+            micLevel.value = Math.sqrt(sum / inputData.length);
+            // chunking & send
+            for (let i = 0; i < inputData.length; i += CHUNK_SIZE) {
+                const slice = inputData.slice(i, i + CHUNK_SIZE);
+                const binaryChunk = floatTo16BitPCM(slice);
+                ws.value.send(binaryChunk);
+            }
+        };
+        input.connect(processor);
+        processor.connect(audioCtx.destination);
+        recording.value = true;
+        setStatus(STATUS.LISTENING);
+    }
+    // ⏹ stop mic
+    function stopRecording() {
+        recording.value = false;
+        processor?.disconnect();
+        input?.disconnect();
+        stream?.getTracks().forEach((t) => t.stop());
+        if (audioCtx && audioCtx.state !== 'closed') {
+            audioCtx
+                .close()
+                .then(() => console.log('AudioContext closed successfully.'))
+                .catch((err) => console.error('Error closing AudioContext:', err))
+                .finally(() => (micLevel.value = 0));
+        }
+        setStatus(STATUS.IDLE);
+    }
+    const getAudioContext = () => {
+        if (!audioCtx || audioCtx.state === 'closed') {
+            audioCtx = new AudioContext({ sampleRate: SAMPLE_RATE });
+        }
+        return audioCtx;
+    };
+    const safeResumeAudio = () => {
+        const ctx = getAudioContext();
+        if (ctx.state === 'suspended') {
+            ctx.resume().catch((err) => console.error('Error resuming AudioContext:', err));
+        }
+    };
+    function connect() {
+        if (ws.value && ws.value.readyState === WebSocket.OPEN)
+            return;
+        setStatus(STATUS.CONNECTING);
+        ws.value = new WebSocket(wsUrl);
+        ws.value.binaryType = 'arraybuffer';
+        ws.value.onopen = () => {
+            console.log('✅ WS connected');
+            startRecording();
+            processSpeakerQueue();
+        };
+        ws.value.onmessage = (event) => {
+            if (event.data instanceof ArrayBuffer) {
+                enqueueSpeakerChunk(event.data);
+                return;
+            }
+            if (typeof event.data === 'string') {
+                try {
+                    const msg = JSON.parse(event.data);
+                    if (msg.type === 'AudioStop' || msg.code === 'UserStartedSpeaking') {
+                        // speakerQueue.length = 0
+                        nextPlayTime = 0;
+                        setStatus(STATUS.LISTENING);
+                        return;
+                    }
+                }
+                catch (err) {
+                    console.warn('⚠️ Parse JSON error:', err, event.data);
+                }
+            }
+            console.log('⚠️ Unknown WS message, closing...');
+            disconnect();
+        };
+        ws.value.onclose = () => {
+            console.log('❌ WS closed');
+            stopRecording();
+        };
+    }
+    function disconnect() {
+        ws.value?.close();
+        stopRecording();
+    }
+    onBeforeUnmount(() => {
+        disconnect();
+    });
+    return {
+        ws,
+        statusText,
+        micLevel,
+        recording,
+        connect,
+        disconnect,
+        resumeAudio: safeResumeAudio,
+        enqueueSpeakerChunk,
+        processSpeakerQueue,
+        startRecording
+    };
+}

package/dist/test/composable/useCallHelper.js

@@ -1,170 +1,226 @@
-import { publishMessage } from '../plugins/mqtt';
-import { TOPIC_DETAIL_CALL } from '../constant/mqtt';
-import { getIceService } from '../utils/chat/call';
-import { dataProfile } from '../utils/chat/auth';
+import { plivoCall, plivoEndCall } from '../utils/chat/call';
 import { ref } from 'vue';
+import { socketSend } from '../plugins/websocket';
 export function useCallHelper() {
-    let pc;
-    let iceStunServiceLink = '';
-    let iceServer = null;
-    let answer;
-    let offer = null;
-    const remoteAudio = () => {
-        return document.getElementById('go-chat-remote-audio');
-    };
-    const localAudio = () => {
-        return document.getElementById('go-chat-local-audio');
-    };
-    const userRemoter = ref(null);
-    const call = async (user) => {
-        userRemoter.value = user;
-        await getIceServiceLink();
-        startPeerConnection();
-        const offer = await pc?.createOffer();
-        await pc?.setLocalDescription(offer);
-        publishMessage(TOPIC_DETAIL_CALL + (userRemoter.value?.id ?? ''), {
-            type: 'offer',
-            offer,
-            link: iceStunServiceLink,
-            server: iceServer,
-            user: dataProfile.value
+    function _getAudioContext() {
+        return new (window.AudioContext || window.webkitAudioContext)({
+            sampleRate: SAMPLE_RATE
         });
-    };
-    const end = (link) => {
-        endPc(link);
-        publishMessage(TOPIC_DETAIL_CALL + (userRemoter.value?.id ?? ''), {
-            type: 'end-call',
-            link: iceStunServiceLink
-        });
-        iceStunServiceLink = '';
-    };
-    const endPc = (link) => {
-        if (!link || link === iceStunServiceLink) {
-            if (pc) {
-                pc?.close();
-                pc = null;
-            }
-            const remote = remoteAudio();
-            const local = localAudio();
-            if (remote)
-                remote.srcObject = null;
-            if (local)
-                local.srcObject = null;
+    }
+    const SAMPLE_RATE = 8000;
+    let uuid = '';
+    let audioCtxListen = _getAudioContext();
+    let audioCtxCall = _getAudioContext();
+    let prebuffer = [];
+    let nextPlayTime = 0;
+    let processorCall;
+    let sourceCall;
+    let loopTimer = null;
+    let running = false;
+    const userRemoter = ref(null);
+    function _int16ToFloat32(int16Array) {
+        const float32 = new Float32Array(int16Array.length);
+        for (let i = 0; i < int16Array.length; i++) {
+            const int = int16Array[i];
+            float32[i] = int < 0 ? int / 32768 : int / 32767;
         }
-    };
-    const test = async (data) => {
-        const pcs = new RTCPeerConnection({
-            iceServers: data
-        });
-        console.log('www', data);
-        pcs.onicecandidate = (e) => console.log('Candidate:', e.candidate);
-        pcs.onicegatheringstatechange = () => console.log('Gathering:', pc.iceGatheringState);
-        const offer = await pcs.createOffer();
-        await pcs.setLocalDescription(offer);
-    };
-    const startPeerConnection = async () => {
-        // iceServer[1].credentialType = 'oauth'
-        // test(iceServer)
-        const data = { 'iceServers': [{ 'urls': 'stun:stun.cloudflare.com:3478' }] };
-        pc = new RTCPeerConnection(data);
-        // console.log(pc)
-        // pc = new RTCPeerConnection({ iceServers: data })
-        // console.log( "hung" , pc)
-        pc.onicegatheringstatechange = () => {
-            console.log('ICE gathering state:', pc.iceGatheringState);
-        };
-        pc.oniceconnectionstatechange = () => {
-            console.log('ICE connection state:', pc.iceConnectionState);
-        };
-        pc.addEventListener('icecandidate', (event) => {
-            console.log('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii');
-            if (event.candidate) {
-                console.log("New ICE candidate:", event.candidate);
+        return float32;
+    }
+    function _float32ToMuLaw8(float32Array) {
+        const MU_MAX = 0x1fff;
+        const BIAS = 0x84;
+        const muLawArray = new Uint8Array(float32Array.length);
+        for (let i = 0; i < float32Array.length; i++) {
+            let sample = float32Array[i];
+            // Clamp sample to [-1, 1]
+            sample = Math.max(-1, Math.min(1, sample));
+            // Convert to PCM value
+            let pcm_val = sample < 0 ? -sample * MU_MAX : sample * MU_MAX;
+            // Get sign
+            let sign = sample < 0 ? 0x80 : 0;
+            // Calculate exponent and mantissa
+            let exponent = 7;
+            for (let expMask = 0x4000; (pcm_val & expMask) === 0 && exponent > 0; expMask >>= 1) {
+                exponent--;
             }
-        });
-        pc.onicecandidate = (event) => {
-            console.log('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii');
-            if (event.candidate) {
-                publishMessage(TOPIC_DETAIL_CALL + (userRemoter.value?.id ?? ''), {
-                    type: 'candidate',
-                    candidate: event.candidate,
-                    link: iceStunServiceLink
-                });
-            }
-        };
-        pc.ontrack = (event) => {
-            console.log('aaaaaaa');
-            const remote = remoteAudio();
-            if (remote)
-                remote.srcObject = event.streams[0];
-        };
-        navigator.mediaDevices.getUserMedia({ audio: true }).then((stream) => {
-            const local = localAudio();
-            if (local)
-                local.srcObject = stream;
-            stream.getTracks().forEach((track) => pc?.addTrack(track, stream));
-        });
-    };
-    const getIceServiceLink = async () => {
-        const res = await getIceService();
+            let mantissa = (pcm_val >> (exponent + 3)) & 0x0f;
+            // Compose µ-law byte
+            let muByte = ~(sign | (exponent << 4) | mantissa) & 0xff;
+            muLawArray[i] = muByte;
+        }
+        return muLawArray;
+    }
+    function float32To16Bit(float32Array) {
+        const buffer = new ArrayBuffer(float32Array.length * 2);
+        const view = new DataView(buffer);
+        for (let i = 0; i < float32Array.length; i++) {
+            let s = Math.max(-1, Math.min(1, float32Array[i]));
+            view.setInt16(i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+        }
+        return buffer;
+    }
+    function floatToMuLawSample(sample) {
+        const MULAW_MAX = 0x1fff;
+        const MULAW_BIAS = 33;
+        const CLIP = 32635;
+        let sign = sample < 0 ? 0x80 : 0;
+        sample = Math.min(CLIP, Math.abs(sample * 32768));
+        let exponent = Math.floor(Math.log(sample / 256) / Math.log(2));
+        let mantissa = (sample >> (exponent + 3)) & 0x0f;
+        let muLawByte = ~(sign | (exponent << 4) | mantissa);
+        return muLawByte & 0xff;
+    }
+    function _float32ToUint8(float32Array) {
+        const uint8Array = new Uint8Array(float32Array.length);
+        for (let i = 0; i < float32Array.length; i++) {
+            // map từ [-1, 1] sang [0, 255]
+            let val = Math.max(-1, Math.min(1, float32Array[i])); // clamp
+            uint8Array[i] = Math.floor((val + 1) * 127.5); // chuyển về 0-255
+        }
+        return uint8Array;
+    }
+    function _encodeMuLaw(float32Array) {
+        const out = new Uint8Array(float32Array.length);
+        for (let i = 0; i < float32Array.length; i++) {
+            out[i] = floatToMuLawSample(float32Array[i]);
+        }
+        return out;
+    }
+    function _muLawDecode(muLawByte) {
+        const MULAW_MAX = 0x1fff;
+        const BIAS = 0x84;
+        muLawByte = ~muLawByte;
+        let sign = muLawByte & 0x80;
+        let exponent = (muLawByte >> 4) & 0x07;
+        let mantissa = muLawByte & 0x0f;
+        let magnitude = ((mantissa << 4) + 8) << (exponent + 3);
+        magnitude -= BIAS;
+        if (magnitude < 0)
+            magnitude = 0;
+        return sign ? -magnitude : magnitude;
+    }
+    function _muLawToFloat32(muLawArray) {
+        const pcm = new Float32Array(muLawArray.length);
+        for (let i = 0; i < muLawArray.length; i++) {
+            pcm[i] = _muLawDecode(muLawArray[i]) / 32768.0;
+        }
+        return pcm;
+    }
+    function _float32ToInt16(float32Array) {
+        const int16Array = new Int16Array(float32Array.length);
+        for (let i = 0; i < float32Array.length; i++) {
+            let s = Math.max(-1, Math.min(1, float32Array[i]));
+            int16Array[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+        }
+        return int16Array;
+    }
+    const call = async (user) => {
+        userRemoter.value = user;
+        uuid = '';
+        const res = await plivoCall(user);
         console.log(res);
-        iceStunServiceLink = res[0]?.urls[0] ?? '';
-        iceServer = res;
-    };
-    const handleOffer = async (data) => {
-        if (pc)
-            return false;
-        if (!data.link || !data.offer || !data.user || !data.server)
-            return false;
-        offer = data;
-        return true;
+        uuid = res?.call?.requestUuid;
     };
-    const sendOfferOk = async () => {
-        if (!offer)
+    const end = async (link) => {
+        processorCall?.disconnect?.();
+        sourceCall?.disconnect?.(processorCall);
+        stopQueue();
+        console.log(uuid);
+        if (!uuid)
             return;
+        await plivoEndCall(uuid);
+        return;
+    };
+    const startPeerConnection = async () => {
         try {
-            iceStunServiceLink = offer.link;
-            iceServer = offer.server;
-            userRemoter.value = offer.user;
-            startPeerConnection();
-            console.log(pc, 'aaaaaaa');
-            await pc.setRemoteDescription(new RTCSessionDescription(offer.offer));
-            answer = await pc?.createAnswer();
-            await pc?.setLocalDescription(answer);
-            publishMessage(TOPIC_DETAIL_CALL + (userRemoter.value?.id ?? ''), {
-                type: 'offer-response',
-                answer,
-                link: iceStunServiceLink
-            });
-            return true;
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            sourceCall = audioCtxCall.createMediaStreamSource(stream);
+            processorCall: ScriptProcessorNode = audioCtxCall.createScriptProcessor(256, 1, 1);
+            processorCall.onaudioprocess = (e) => {
+                const input = e.inputBuffer.getChannelData(0);
+                for (let i = 0; i < input.length; i += 160) {
+                    const slice = input.slice(i, i + 160);
+                    const binaryChunk = _float32ToMuLaw8(slice);
+                    socketSend(binaryChunk);
+                }
+            };
+            sourceCall.connect(processorCall);
+            processorCall.connect(audioCtxCall.destination);
         }
         catch (e) {
             console.log(e);
-            return false;
         }
     };
-    const handleOfferResponse = async (data) => {
-        if (!data.link || !data.answer || data.link != iceStunServiceLink)
-            return;
-        await pc?.setRemoteDescription(new RTCSessionDescription(data.answer));
+    const handleOffer = async (data) => { };
+    const sendOfferOk = async () => { };
+    const handleOfferResponse = async (data) => { };
+    const addQueueListen = (arrayBuffer) => {
+        // const int16View = new Int16Array(arrayBuffer)
+        const ulawBytes = new Uint8Array(arrayBuffer);
+        // const float32Data = int16ToFloat32(int16View)
+        const floatData = _muLawToFloat32(ulawBytes);
+        prebuffer.push(floatData);
     };
-    const addIceCandidate = async (data) => {
+    async function scheduleNext() {
         try {
-            if (data.candidate && data.link == iceStunServiceLink) {
-                await pc.addIceCandidate(data.candidate);
+            const chunk = prebuffer.shift();
+            if (chunk) {
+                const audioBuffer = audioCtxListen.createBuffer(1, chunk.length, 8000);
+                audioBuffer.getChannelData(0).set(chunk);
+                const source = audioCtxListen.createBufferSource();
+                source.buffer = audioBuffer;
+                source.connect(audioCtxListen.destination);
+                source.start(nextPlayTime);
+                nextPlayTime = audioCtxListen.currentTime + chunk.length / SAMPLE_RATE;
             }
         }
         catch (e) {
-            console.error('Error adding received ICE candidate', e);
+            console.log(e);
+        }
+    }
+    const playQueueLoop = () => {
+        if (!running)
+            return;
+        while (prebuffer.length > 0 && nextPlayTime < audioCtxListen.currentTime + 0.1) {
+            scheduleNext();
+        }
+        loopTimer = setTimeout(playQueueLoop, 10);
+    };
+    function stopQueue() {
+        running = false;
+        if (loopTimer)
+            clearTimeout(loopTimer);
+        prebuffer.length = 0;
+    }
+    const handleMedia = async (message) => {
+        addQueueListen(message);
+    };
+    const startIncomingCall = async () => {
+        if (!audioCtxCall) {
+            audioCtxCall = _getAudioContext();
+        }
+        if (audioCtxCall.state === 'suspended')
+            await audioCtxCall.resume();
+        await startPeerConnection();
+        if (running)
+            return;
+        running = true;
+        if (!audioCtxListen) {
+            audioCtxListen = _getAudioContext();
         }
+        if (audioCtxListen.state === 'suspended')
+            await audioCtxListen.resume();
+        nextPlayTime = audioCtxListen.currentTime;
+        playQueueLoop();
     };
     return {
         call,
         end,
-        endPc,
         handleOfferResponse,
         handleOffer,
-        addIceCandidate,
-        sendOfferOk
+        sendOfferOk,
+        handleMedia,
+        userRemoter,
+        startIncomingCall
     };
 }

package/dist/test/constant/datetime.js

@@ -3,3 +3,4 @@ export const DATE_FORMATS = {
     DATE_FORMAT_FULL: 'YYYY-MM-DD HH:mm:ss',
     TIME_12_FORMAT: 'hh:mm A'
 };
+export const TIME_ZONE_UTC = 'Africa/Freetown';

package/dist/test/plugins/websocket.js

@@ -2,16 +2,8 @@ import { tryParseJson } from '../utils/json';
 let socket = null;
 let dataCallBack = [];
 export function initWebSocket(server) {
-    // Create WebSocket connection.
-    socket = new WebSocket('wss://web-socket.dev01.dtsmart.dev');
-    // socket.addEventListener('open', (event: any) => {
-    //   console.log('fffffff')
-    //   socket.send('Hello Server!')
-    // })
-    //
-    // socket.addEventListener('message', (event: any) => {
-    //   console.log('Message from server ', event.data)
-    // })
+    socket = new WebSocket('wss://web-socket.dev01.dtsmart.dev/web-stream');
+    socket.binaryType = "arraybuffer";
     socket.onopen = (event) => {
         console.log('Connected!');
     };
@@ -28,9 +20,14 @@ export function initWebSocket(server) {
         console.error('Socket error:', event);
     };
 }
-const socketSend = (data) => {
-    let request = typeof data == 'string' ? data : JSON.stringify(data);
-    socket.send(request);
+export const socketSend = (data) => {
+    try {
+        let request = typeof data == 'string' ? data : JSON.stringify(data);
+        socket?.send(data);
+    }
+    catch (e) {
+        console.log(e);
+    }
 };
 export const getWebSocket = async () => {
     const url = 'https://web-socket.dev01.dtsmart.dev/ws/connect';

package/dist/test/utils/chat/call.js

@@ -59,3 +59,40 @@ export const callOutBound = async (user) => {
         console.error(error.message);
     }
 };
+export const plivoCall = async (user) => {
+    const url = BARE_WEBSOCKET_URL + '/ws/call';
+    const response = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify({
+            from: '18668259612' || dataProfile.value?.phone,
+            to: user?.phone || ''
+        }),
+        headers: {
+            ['Content-Type']: 'application/json'
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Response status: ${response.status}`);
+    }
+    console.log(response);
+    const result = await response.json();
+    console.log(result);
+    return result;
+};
+export const plivoEndCall = async (uuid) => {
+    const url = BARE_WEBSOCKET_URL + '/plivo/end-call';
+    const response = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify({
+            call_uuid: uuid
+        }),
+        headers: {
+            ['Content-Type']: 'application/json'
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Response status: ${response.status}`);
+    }
+    const result = await response.json();
+    console.log(result);
+};

package/dist/types/chat/global.d.ts

@@ -3,5 +3,6 @@ export type GoChatProps = {
     id?: string;
     domain?: string;
     response?: PAGE_RESPONSE;
+    isLib?: boolean;
 };
 export type PAGE_RESPONSE = 'mobile' | 'tablet';

package/dist/utils/chat/call.d.ts

@@ -3,3 +3,5 @@ import type { IResCall } from '../../types/call';
 export declare const getIceService: () => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const callClient: (body: IResCall) => Promise<void>;
 export declare const callOutBound: (user: IResUser) => Promise<void>;
+export declare const plivoCall: (user: IResUser) => Promise<any>;
+export declare const plivoEndCall: (uuid: string) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phonghq/go-chat",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "private": false,
   "files": [
     "dist"