@phonghq/go-chat 1.0.11 → 1.0.14

package/dist/test/composable/data.json

@@ -0,0 +1,32 @@
+[
+    {
+        "type": "audio_chunk",
+        "size_bytes": 160,
+        "hex_preview": "36 25 39 bb c0 41 48 bc c3 32 27 3f c7 f6 ee aa 9f ae b3 9e",
+        "samples_count": 160
+    },
+    {
+        "type": "audio_chunk",
+        "size_bytes": 160,
+        "hex_preview": "3f d9 ac b3 3d 3b b9 a8 ac b4 b3 ac af bc ae 9e 9b a5 ac a9",
+        "samples_count": 160
+    },
+    {
+        "type": "audio_chunk",
+        "size_bytes": 160,
+        "hex_preview": "b1 a3 b3 a9 a8 a8 ae a3 a7 a6 a6 a8 a7 ab a9 ad af ae aa a6 ab",
+        "samples_count": 160
+    },
+    {
+        "type": "audio_chunk",
+        "size_bytes": 160,
+        "hex_preview": "b3 b1 b2 b0 ae ae b0 b2 b3 b1 b1 b0 b0 af af ae ae ae ad ac ac",
+        "samples_count": 160
+    },
+    {
+        "type": "audio_chunk",
+        "size_bytes": 160,
+        "hex_preview": "ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad ad",
+        "samples_count": 160
+    }
+]

package/dist/test/composable/useCallHelper.js

@@ -1,14 +1,18 @@
-import { plivoCall, plivoEndCall } from '../utils/chat/call';
+import { callClient, plivoCall, plivoEndCall } from '../utils/chat/call';
+import { dataProfile } from '../utils/chat/auth';
 import { ref } from 'vue';
-import { socketSend } from '../plugins/websocket';
+import { WebSocketClient } from '../plugins/websocket';
+import dataJson from './data.json';
 export function useCallHelper() {
-    function _getAudioContext() {
+    function _getAudioContext(sampleRate) {
         return new (window.AudioContext || window.webkitAudioContext)({
-            sampleRate: SAMPLE_RATE
+            sampleRate: sampleRate ?? PLIVO_SAMPLE_RATE
         });
     }
-    const SAMPLE_RATE = 8000;
-    let uuid = '';
+    const PLIVO_SAMPLE_RATE = 8000;
+    const SAMPLE_RATE = 48000;
+    const CHUNK_LENGTH = 160;
+    const uuid = ref('');
     let audioCtxListen = _getAudioContext();
     let audioCtxCall = _getAudioContext();
     let prebuffer = [];
@@ -17,7 +21,10 @@ export function useCallHelper() {
     let sourceCall;
     let loopTimer = null;
     let running = false;
+    let loopId = null;
     const userRemoter = ref(null);
+    let websocket = null;
+    let stream;
     function _int16ToFloat32(int16Array) {
         const float32 = new Float32Array(int16Array.length);
         for (let i = 0; i < int16Array.length; i++) {
@@ -114,34 +121,59 @@ export function useCallHelper() {
         }
         return int16Array;
     }
+    function _resample8kTo48k(float8k) {
+        const ratio = 48000 / 8000;
+        const float48k = new Float32Array(float8k.length * ratio);
+        for (let i = 0; i < float48k.length; i++) {
+            float48k[i] = float8k[Math.floor(i / ratio)] || 0;
+        }
+        return float48k;
+    }
     const call = async (user) => {
         userRemoter.value = user;
-        uuid = '';
+        uuid.value = '';
         const res = await plivoCall(user);
-        console.log(res);
-        uuid = res?.call?.requestUuid;
+        uuid.value = res?.call?.requestUuid;
     };
-    const end = async (link) => {
+    const end = async () => {
         processorCall?.disconnect?.();
         sourceCall?.disconnect?.(processorCall);
         stopQueue();
-        console.log(uuid);
+        websocket?.disconnect();
+        stream?.getAudioTracks?.()?.forEach((track) => track?.stop());
         if (!uuid)
             return;
-        await plivoEndCall(uuid);
+        await plivoEndCall(uuid.value);
         return;
     };
     const startPeerConnection = async () => {
         try {
-            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            if (!audioCtxCall) {
+                audioCtxCall = _getAudioContext();
+            }
+            if (audioCtxCall.state === 'suspended')
+                await audioCtxCall.resume();
+            stream = await navigator.mediaDevices.getUserMedia({ audio: true });
             sourceCall = audioCtxCall.createMediaStreamSource(stream);
-            processorCall: ScriptProcessorNode = audioCtxCall.createScriptProcessor(256, 1, 1);
+            processorCall = 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);
+                for (let i = 0; i < input.length; i += CHUNK_LENGTH) {
+                    const slice = input.slice(i, i + CHUNK_LENGTH);
                     const binaryChunk = _float32ToMuLaw8(slice);
-                    socketSend(binaryChunk);
+                    // socketSend(binaryChunk)
+                    // const data = {
+                    //   event: 'testPlaySound',
+                    //   media: {
+                    //     payload: binaryChunk
+                    //   }
+                    // }
+                    // console.log(data)
+                    // addQueueListen(binaryChunk)
+                    // socketSend(binaryChunk)
+                    // websocket.binaryType = "arraybuffer";
+                    // console.log(binaryChunk)
+                    // websocket.sendDefault(binaryChunk)
                 }
             };
             sourceCall.connect(processorCall);
@@ -160,59 +192,135 @@ export function useCallHelper() {
         // const float32Data = int16ToFloat32(int16View)
         const floatData = _muLawToFloat32(ulawBytes);
         prebuffer.push(floatData);
+        if (prebuffer.length > 3) {
+            prebuffer.shift(); // bỏ gói cũ
+        }
     };
     async function scheduleNext() {
         try {
             const chunk = prebuffer.shift();
             if (chunk) {
-                const audioBuffer = audioCtxListen.createBuffer(1, chunk.length, 8000);
+                const float48k = _resample8kTo48k(chunk);
+                const audioBuffer = audioCtxListen.createBuffer(1, chunk.length, PLIVO_SAMPLE_RATE);
                 audioBuffer.getChannelData(0).set(chunk);
                 const source = audioCtxListen.createBufferSource();
                 source.buffer = audioBuffer;
                 source.connect(audioCtxListen.destination);
+                // console.log(
+                //   'Scheduling chunk',
+                //   'nextPlayTime:', nextPlayTime,
+                //   'currentTime:', audioCtxListen.currentTime
+                // );
+                if (nextPlayTime < audioCtxListen.currentTime + (CHUNK_LENGTH / PLIVO_SAMPLE_RATE)) {
+                    nextPlayTime = audioCtxListen.currentTime + (CHUNK_LENGTH / PLIVO_SAMPLE_RATE);
+                }
                 source.start(nextPlayTime);
-                nextPlayTime = audioCtxListen.currentTime + chunk.length / SAMPLE_RATE;
+                // console.log(
+                //   'Started chunk',
+                //   'sourceStartTime:', nextPlayTime,
+                //   'audioCtxCurrentTime:', audioCtxListen.currentTime
+                // );
+                // nextPlayTime += audioBuffer.duration
+                nextPlayTime += audioBuffer.duration;
             }
         }
         catch (e) {
             console.log(e);
         }
     }
+    let startTime = 0;
     const playQueueLoop = () => {
         if (!running)
             return;
         while (prebuffer.length > 0 && nextPlayTime < audioCtxListen.currentTime + 0.1) {
             scheduleNext();
         }
-        loopTimer = setTimeout(playQueueLoop, 10);
+        loopId = requestAnimationFrame(playQueueLoop);
     };
+    async function processSpeakerQueue() {
+        try {
+            // console.log(prebuffer)
+            if (prebuffer.length > 0) {
+                const chunk = prebuffer.shift();
+                if (chunk) {
+                    // console.log(chunk.length)
+                    const audioBuffer = audioCtxListen.createBuffer(1, chunk.length, 8000);
+                    audioBuffer.getChannelData(0).set(chunk);
+                    const source = audioCtxListen.createBufferSource();
+                    source.buffer = audioBuffer;
+                    source.connect(audioCtxListen.destination);
+                    if (nextPlayTime < audioCtxListen.currentTime + audioBuffer.duration) {
+                        nextPlayTime = audioCtxListen.currentTime + audioBuffer.duration;
+                    }
+                    source.start(nextPlayTime);
+                    // console.log(`🎧 Played  samples (${audioBuffer.duration.toFixed(3)}s)`);
+                    nextPlayTime += audioBuffer.duration;
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+        requestAnimationFrame(processSpeakerQueue);
+    }
     function stopQueue() {
         running = false;
         if (loopTimer)
             clearTimeout(loopTimer);
+        if (loopId !== null) {
+            cancelAnimationFrame(loopId);
+            loopId = null;
+        }
         prebuffer.length = 0;
     }
     const handleMedia = async (message) => {
         addQueueListen(message);
     };
-    const startIncomingCall = async () => {
-        if (!audioCtxCall) {
-            audioCtxCall = _getAudioContext();
+    const handleMqttMessage = async (message) => {
+        handleMedia(message);
+    };
+    const startIncomingCall = async (uuid_request) => {
+        try {
+            if (uuid_request && uuid_request != uuid.value) {
+                throw new Error('This call isn’t yours');
+            }
+            websocket = new WebSocketClient(uuid_request, handleMqttMessage);
+            await websocket?.init();
+            if (running)
+                return;
+            running = true;
+            if (!audioCtxListen) {
+                audioCtxListen = _getAudioContext();
+            }
+            if (audioCtxListen.state === 'suspended')
+                await audioCtxListen.resume();
+            nextPlayTime = audioCtxListen.currentTime;
+            playQueueLoop();
+            // processSpeakerQueue()
+        }
+        catch (e) {
+            end();
+            throw new Error(e);
+        }
+    };
+    const testPlay = () => {
+        for (let i = 0; i < dataJson.length; i++) {
+            addQueueListen(dataJson[i]);
         }
-        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();
     };
+    const handleCallAnswer = (data) => {
+        uuid.value = data?.data?.call_uuid ?? '';
+    };
+    const callAnswer = async (uuid_request) => {
+        if (uuid_request && uuid_request != uuid.value) {
+            throw new Error('This call isn’t yours');
+        }
+        await callClient({ call_uuid: uuid.value, clientId: dataProfile.value?.tenant_id ?? '' });
+    };
     return {
         call,
         end,
@@ -221,6 +329,11 @@ export function useCallHelper() {
         sendOfferOk,
         handleMedia,
         userRemoter,
-        startIncomingCall
+        testPlay,
+        handleCallAnswer,
+        callAnswer,
+        startPeerConnection,
+        startIncomingCall,
+        uuid
     };
 }

package/dist/test/composable/useDigibot.js

@@ -2,7 +2,7 @@
 export const digibotData = {
     id: -98,
     receiver_id: 101,
-    username: 'digibot',
+    username: 'Gocheckin AI',
     customer_phone: '',
     avatar: '',
     last_message: '',

package/dist/test/composable/useInitData.js

@@ -5,7 +5,8 @@ import { routerPush } from '../utils/chat/chat-router';
 import { PAGE } from '../constant/general';
 import { subscribeToTopic, unsubscribeFromTopic } from '../plugins/mqtt';
 import { TOPIC_DETAIL_CALL } from '../constant/mqtt';
-import { getWebSocket } from '../plugins/websocket';
+import { getWebSocket, initWebSocket } from '../plugins/websocket';
+import router from '../router';
 //PINIA
 export const isRouterReady = ref(false);
 export function useInitData() {
@@ -13,7 +14,7 @@ export function useInitData() {
     const initPage = async (data) => {
         try {
             isRouterReady.value = false;
-            const sdk_res = await sdkInit({ id: data.id, token: data.token, domain: data.domain });
+            const sdk_res = await sdkInit(data.props);
             if (sdk_res.tenant_error) {
                 const api_link_res = await loginApiLink();
                 // if (api_link_res.client_error) {
@@ -22,13 +23,7 @@ export function useInitData() {
                 // }
             }
             // connectMqtt()
-            await initData();
-            if (data.response == 'mobile') {
-                routerPush(PAGE.CHAT_LIST);
-            }
-            else {
-                routerPush(PAGE.HOME);
-            }
+            await initData(data.props, data.response);
         }
         catch (error) {
             console.log(error);
@@ -37,11 +32,21 @@ export function useInitData() {
             isRouterReady.value = true;
         }
     };
-    const initData = async () => {
-        await getProfile();
-        getWebSocket();
+    const initData = async (props, response) => {
+        const res = await getProfile();
+        await getWebSocket();
+        initWebSocket();
         unsubscribeFromTopic(TOPIC_DETAIL_CALL + dataProfile.value?.id);
         subscribeToTopic(TOPIC_DETAIL_CALL + dataProfile.value?.id);
+        if ((!res?.phone && res.tenant_id && !props.isLib)) {
+            router.push({ name: 'tenant-phone' });
+        }
+        else if (response == 'mobile') {
+            routerPush(PAGE.CHAT_LIST);
+        }
+        else {
+            routerPush(PAGE.HOME);
+        }
     };
     const loginApiLink = async () => {
         try {

package/dist/test/composable/usePlivo.js

@@ -0,0 +1,138 @@
+import { PLIVO_CALL_STATUS } from '../types/call';
+export function usePlivo(callback) {
+    var options = {
+        debug: 'ALL',
+        permOnClick: true,
+        deviceParams: {
+            micEnabled: true,
+            audioConstraints: { audio: true, video: false }
+        }
+    };
+    var plivoBrowserSdk = null;
+    let CallUuid = '';
+    let custom_resolve = null;
+    let custom_reject = null;
+    const plivoLogin = async (token) => {
+        token =
+            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCIsImN0eSI6InBsaXZvO3Y9MSJ9.eyJqdGkiOiJ0ZXN0MSIsImlzcyI6IlNBTjJZMFpERTRNSkFUTVpZNU5DIiwic3ViIjoid2ViY2FsbDAwMzA3OTY3MzQ1NDg5MTgyNyIsIm5iZiI6MTc2MzY5MzUyNSwiZXhwIjoxNzYzNzc5OTI1LCJncmFudHMiOnsidm9pY2UiOnsiaW5jb21pbmdfYWxsb3ciOnRydWUsIm91dGdvaW5nX2FsbG93Ijp0cnVlfX19.9p4O_xTb4kNhKyDVfK3EemSKBQiHtbKNUZ5iwnSdX1I';
+        try {
+            if (!plivoBrowserSdk)
+                plivoBrowserSdk = new window.Plivo(options);
+            plivoBrowserSdk?.client?.on?.('onCallAnswered', (callInfo) => {
+                handleCallAnswered(callInfo);
+            });
+            plivoBrowserSdk?.client?.on?.('onCallTerminated', (hangupInfo, callInfo) => handleCallTerminated(hangupInfo, callInfo));
+            plivoBrowserSdk.client.on('onCallFailed', (data, callInfo) => {
+                handleCallFailed(data, callInfo);
+            });
+            plivoBrowserSdk.client.on('onCalling', (data) => console.log('onCallFailed', data));
+            plivoBrowserSdk?.client?.on?.('onIncomingCall', (callerID, extraHeaders, callInfo) => {
+                handleIncomingCall(callInfo);
+            });
+            plivoBrowserSdk.client.on('onCallRemoteRinging', (data) => handleCallRemoteRinging(data));
+            // plivoBrowserSdk?.client?.on?.('onReady', () => console.log('Ready'))
+            // plivoBrowserSdk?.client?.on?.('onLoginFailed', () => console.log('Login failed'))
+            // plivoBrowserSdk?.client?.on?.('remoteAudioStatus', () => console.log('remoteAudioStatus'))
+            await plivoBrowserSdk?.client?.login('webcall003079673454891827', '123456abcA!');
+            const speaker = document.getElementById("go-chat-remote-audio");
+            if (speaker)
+                plivoBrowserSdk?.client?.setAudioElement(speaker);
+            console.log('Registered with token');
+        }
+        catch (err) {
+            console.log('Login error: ' + err);
+        }
+    };
+    const handleIncomingCall = (call) => {
+        const data = {
+            phone: _getPhone(call.src)
+        };
+        console.log(call);
+        callback(PLIVO_CALL_STATUS.RINGING, data);
+        CallUuid = call?.callUUID;
+    };
+    const handleCallRemoteRinging = (callInfo) => {
+        CallUuid = callInfo.callUUID;
+        callback(PLIVO_CALL_STATUS.CALLING);
+        custom_resolve?.();
+    };
+    const handleCallAnswered = (call) => {
+        if (call.callUUID == CallUuid) {
+            custom_resolve?.();
+            callback(PLIVO_CALL_STATUS.CALL_START);
+        }
+    };
+    const handleCallTerminated = (data, callInfo) => {
+        if (CallUuid === callInfo.callUUID) {
+            callback(PLIVO_CALL_STATUS.CALL_END, { message: data?.reason });
+            CallUuid = '';
+        }
+    };
+    const _getPhone = (text, dial = '1') => {
+        let result = text.replace(/[^0-9]/g, '');
+        return result?.startsWith(dial) ? result.slice(dial.toString().length) : result;
+    };
+    const _waitEventOrTimeout = (timeoutMs = 3000) => {
+        return new Promise((resolve, reject) => {
+            custom_resolve = null;
+            const timer = setTimeout(() => {
+                reject('Time out error!');
+                custom_resolve = null;
+                custom_reject = null;
+            }, timeoutMs);
+            custom_resolve = () => {
+                resolve(true);
+                custom_resolve = null;
+                clearTimeout(timer);
+            };
+            custom_reject = (data) => {
+                reject(data);
+                custom_reject = null;
+                clearTimeout(timer);
+            };
+        });
+    };
+    const plivoCallAnswer = async () => {
+        plivoBrowserSdk?.client?.answer?.(CallUuid);
+        await _waitEventOrTimeout(3000);
+    };
+    const plivoCallReject = () => {
+        plivoBrowserSdk?.client?.reject?.(CallUuid);
+    };
+    const plivoCallIgnore = () => {
+        if (CallUuid)
+            plivoBrowserSdk?.client?.ignore?.(CallUuid);
+    };
+    const plivoCallSwishMute = (isMute) => {
+        plivoBrowserSdk?.client?.mute();
+        if (isMute)
+            plivoBrowserSdk?.client?.mute?.();
+        else
+            plivoBrowserSdk?.client?.unmute?.();
+    };
+    const plivoCall = async (phone) => {
+        plivoBrowserSdk.client.call('+' + phone, { number_phone: phone });
+        await _waitEventOrTimeout(5000);
+    };
+    const plivoEndCall = (status) => {
+        if (status == PLIVO_CALL_STATUS.RINGING) {
+            plivoBrowserSdk?.client?.reject?.(CallUuid);
+        }
+        else if (status == PLIVO_CALL_STATUS.CALL_START || status == PLIVO_CALL_STATUS.CALLING) {
+            plivoBrowserSdk?.client?.hangup?.();
+        }
+    };
+    const handleCallFailed = (data, callInfo) => {
+        if (custom_reject)
+            custom_reject?.(data);
+        callback(PLIVO_CALL_STATUS.CALL_END, { message: data });
+    };
+    return {
+        plivoLogin,
+        plivoCallAnswer,
+        plivoCallReject,
+        plivoCall,
+        plivoEndCall,
+        plivoCallSwishMute
+    };
+}

package/dist/test/constant/color.js

@@ -27,7 +27,7 @@ export function defineRootColor() {
         root.style?.setProperty('--chat-color-primary', Color.Primary);
         // root.style?.setProperty('--chat-color-primary_hover', Color.Primary_Hover)
         // root.style?.setProperty('--chat-color-primary_rgb', Color.Primary_RGB)
-        // root.style?.setProperty('--chat-color-error', Color.Error)
+        root.style?.setProperty('--chat-color-error', Color.Error);
         // root.style?.setProperty('--chat-color-error_hover', Color.Error_Hover)
         root.style?.setProperty('--chat-color-success', Color.Success);
         // root.style?.setProperty('--chat-color-success-bg', Color.Success_Bg)

package/dist/test/plugins/axios.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
 const baseURL = 'https://go-chat.dev01.dtsmart.dev/';
-// const baseURL = 'http://192.168.1.152:8085/'
+// const baseURL = 'https://go-chat-test.dev01.dtsmart.dev'
+// const baseURL = '192.168.1.162:3000'
 const instance = axios.create({
     baseURL,
     timeout: 20000,

package/dist/test/plugins/mqtt.js

@@ -4,11 +4,12 @@ const mqttOptions = { qos: 1, retain: false };
 let mqttClient = null;
 const subscribedTopics = new Set();
 let dataCallBack = [];
+let reconnectCount = 0;
+const MAX_RECONNECT = 5;
 export const connectMqtt = () => {
     return new Promise((resolve, reject) => {
-        console.log(mqttClient);
+        reconnectCount = 0;
         if (mqttClient && mqttClient?.connected) {
-            console.log('MQTT already connected');
             return resolve();
         }
         const userInfo = JSON.parse(localStorage.getItem('user') || '{}');
@@ -28,7 +29,6 @@ export const connectMqtt = () => {
         const connectUrl = `wss://${host}:${port}${path}`;
         mqttClient = mqtt.connect(connectUrl, options);
         mqttClient?.on('connect', () => {
-            console.log('MQTT Connected Successfully');
             subscribedTopics.forEach((topic) => mqttClient?.subscribe(topic));
             mqttClient?.on('message', (topic, message) => {
                 try {
@@ -49,11 +49,17 @@ export const connectMqtt = () => {
             });
             resolve();
         });
+        mqttClient?.on('reconnect', () => {
+            reconnectCount++;
+            if (reconnectCount >= MAX_RECONNECT) {
+                mqttClient?.end(true); // true = force close
+                mqttClient = null;
+                resolve();
+            }
+        });
         mqttClient?.on('close', () => {
-            console.log('MQTT Disconnected');
         });
         mqttClient?.on('error', (err) => {
-            console.error('MQTT Error:', err);
             reject(err);
         });
     });
@@ -61,14 +67,12 @@ export const connectMqtt = () => {
 export const disconnectMqtt = () => {
     if (mqttClient) {
         mqttClient?.end(false, {}, () => {
-            console.log('MQTT Disconnected');
             mqttClient = null;
         });
     }
 };
 export const subscribeToTopic = (topic) => {
     if (subscribedTopics.has(topic)) {
-        console.log(`Already subscribed to ${topic}`);
         return;
     }
     if (mqttClient?.connected || true) {
@@ -104,7 +108,6 @@ export const publishMessage = (topic, payload) => {
         const message = typeof payload !== 'string' ? JSON.stringify(payload) : payload;
         mqttClient?.publish(topic, message, { qos: 1, retain: false }, (err) => {
             if (!err) {
-                // console.log(`Published message to ${topic}`)
             }
             else {
                 console.error(`Failed to publish message to ${topic}`, err);