@phonghq/go-chat 1.0.10 → 1.0.13

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,54 @@ 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?.getTracks?.()?.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 });
+            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);
@@ -165,54 +192,133 @@ export function useCallHelper() {
         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 (!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();
+            // 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 +327,10 @@ export function useCallHelper() {
         sendOfferOk,
         handleMedia,
         userRemoter,
-        startIncomingCall
+        testPlay,
+        handleCallAnswer,
+        callAnswer,
+        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/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,9 +4,11 @@ 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();
@@ -49,11 +51,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,7 +69,6 @@ export const connectMqtt = () => {
 export const disconnectMqtt = () => {
     if (mqttClient) {
         mqttClient?.end(false, {}, () => {
-            console.log('MQTT Disconnected');
             mqttClient = null;
         });
     }
@@ -104,7 +111,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);

package/dist/test/plugins/websocket.js

@@ -1,9 +1,19 @@
 import { tryParseJson } from '../utils/json';
+import { dataProfile } from '../utils/chat/auth';
 let socket = null;
 let dataCallBack = [];
-export function initWebSocket(server) {
-    socket = new WebSocket('wss://web-socket.dev01.dtsmart.dev/web-stream');
-    socket.binaryType = "arraybuffer";
+let callId = '';
+const BASE_URL = 'wss://web-socket.dev01.dtsmart.dev/web-stream';
+// const BASE_URL = 'wss://web-socket-test.dev01.dtsmart.dev/web-stream'
+const BARE_URL_INBOUND = 'https://web-socket.dev01.dtsmart.dev';
+export function initWebSocket() {
+    if (socket && socket.readyState === 1) {
+        console.log("WebSocket đã kết nối, bỏ qua connect.");
+        return;
+    }
+    // socket = new WebSocket('wss://' + callId)
+    socket = new WebSocket(BASE_URL);
+    socket.binaryType = 'arraybuffer';
     socket.onopen = (event) => {
         console.log('Connected!');
     };
@@ -35,9 +45,10 @@ export const getWebSocket = async () => {
         const response = await fetch(url, {
             method: 'POST',
             body: JSON.stringify({
-                clientId: 'test1'
+                clientId: dataProfile.value?.tenant_id
             }),
             headers: {
+                "Content-Type": "application/json",
                 Authorization: 'Bearer -Qixt-ZztiBA5Dxl-EIWG7f2TDhK-ZCj'
             }
         });
@@ -45,6 +56,8 @@ export const getWebSocket = async () => {
             throw new Error(`Response status: ${response.status}`);
         }
         const result = await response.json();
+        callId = result?.wsUrl;
+        return result;
     }
     catch (error) {
         console.error(error.message);
@@ -60,3 +73,70 @@ export const removeHandleWebSK = (key) => {
         dataCallBack.splice(index, 1);
     }
 };
+export class WebSocketClient {
+    socket = null;
+    dataCallbacks = null;
+    server;
+    constructor(server, callBack) {
+        this.server = server;
+        this.dataCallbacks = callBack;
+    }
+    async init() {
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                reject(new Error("Missing uuid!"));
+            this.socket = new WebSocket(BASE_URL + '?call_uuid=' + this.server);
+            console.log(BASE_URL + '?call_uuid=' + this.server);
+            this.socket.binaryType = "arraybuffer";
+            const timeout = setTimeout(() => {
+                reject(new Error("⏰ WebSocket connection timeout"));
+            }, 5000); // 5s timeout
+            this.socket.onopen = () => {
+                clearTimeout(timeout);
+                resolve(); // Kết nối thành công
+            };
+            this.socket.onmessage = (event) => {
+                const data = tryParseJson(event.data);
+                console.log(data);
+                this.dataCallbacks?.(data);
+            };
+            this.socket.onclose = (event) => {
+            };
+            this.socket.onerror = (event) => {
+                clearTimeout(timeout);
+                reject(new Error("WebSocket connection error"));
+            };
+        });
+    }
+    send(data) {
+        try {
+            const message = typeof data === 'string' ? data : JSON.stringify(data);
+            this.socket?.send(message);
+        }
+        catch (e) {
+            console.error('Send error:', e);
+        }
+    }
+    sendDefault(data) {
+        try {
+            this.socket?.send(data);
+        }
+        catch (e) {
+            console.error('Send error:', e);
+        }
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.onopen = null;
+            this.socket.onmessage = null;
+            this.socket.onclose = null;
+            this.socket.onerror = null;
+            if (this.socket.readyState === WebSocket.OPEN) {
+                this.socket.close(1000, "Manual disconnect");
+                console.log("🔌 WebSocket closed manually");
+            }
+            this.socket = null;
+        }
+        this.dataCallbacks = null;
+    }
+}

package/dist/test/router/index.js

@@ -0,0 +1,39 @@
+import { createRouter, createWebHistory } from "vue-router";
+import Index from "../chat/App.vue";
+import NotFound from "../views/NotFound.vue";
+import TenantPhone from "../views/TenantPhone.vue";
+const router = createRouter({
+    history: createWebHistory(import.meta.env.BASE_URL),
+    routes: [
+        {
+            path: '/',
+            alias: '/index.html',
+            name: "home",
+            component: Index,
+        },
+        {
+            path: '/tenant',
+            alias: '/index.html',
+            name: "client-home",
+            component: Index,
+        },
+        {
+            path: '/tenant-phone',
+            alias: '/index.html',
+            name: "tenant-phone",
+            component: TenantPhone,
+        },
+        {
+            path: '/:pathMatch(.*)*',
+            alias: '/index.html',
+            name: "not-found",
+            component: NotFound,
+        },
+    ],
+});
+// router.beforeEach(async (to, from): Promise<any> => {
+//   if (to.name != "home") {
+//     return { name: "home" };
+//   }
+// });
+export default router;

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

@@ -31,21 +31,29 @@ export const loginLink = async (params) => {
 };
 export const getProfile = async () => {
     const res = await axios.get('/api/v1/message/user/me');
-    localStorage.setItem('chat_user', JSON.stringify(res?.data));
+    localStorage.setItem('chat_user', JSON.stringify(res));
     dataProfile.value = res;
     return res;
 };
+export const submitTenantPhone = async (body) => {
+    const res = await axios.post('/api/v1/message/tenant/update-phone', body);
+    dataLoginLink.value = res;
+    console.log(res);
+    return res;
+};
 export const logout = async () => {
     dataLogin = { id: '', token: '', domain: '' };
     dataProfile.value = null;
     localStorage.removeItem('chat_accessToken');
     localStorage.removeItem('chat_domain');
     localStorage.removeItem('chat_id');
-    window.location.href = '/login';
     try {
         if (gapMiniAppSdk?.getInstance()?.getBridge()) {
             gapMiniAppSdk?.getInstance()?.closeApp();
         }
+        else {
+            window.location.href = '/login';
+        }
     }
     catch (error) { }
 };

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

@@ -1,6 +1,7 @@
 import axios from '../../plugins/axios';
 import { dataProfile } from '../../utils/chat/auth';
 const BARE_WEBSOCKET_URL = 'https://web-socket.dev01.dtsmart.dev';
+// const BARE_WEBSOCKET_URL = 'https://web-socket-test.dev01.dtsmart.dev'
 // const BARE_WEBSOCKET_URL = 'http://192.168.1.173:3000'
 export const getIceService = async () => {
     const res = await axios.post('/api/v1/message/call/ice-servers', {
@@ -16,12 +17,12 @@ export const getIceService = async () => {
 //   })
 //   return res
 // }
-export const callClient = async (body) => {
-    const url = BARE_WEBSOCKET_URL + '/call/answer';
+export const callClient = async (data) => {
+    const url = BARE_WEBSOCKET_URL + '/ws/answer';
     try {
         const response = await fetch(url, {
             method: 'POST',
-            body: JSON.stringify(body),
+            body: JSON.stringify(data),
             headers: {
                 ['Content-Type']: 'application/json'
             }
@@ -64,8 +65,10 @@ export const plivoCall = async (user) => {
     const response = await fetch(url, {
         method: 'POST',
         body: JSON.stringify({
+            // from: '18668259612' || dataProfile.value?.phone,
             from: '18668259612' || dataProfile.value?.phone,
-            to: user?.phone || ''
+            to: user?.phone || '',
+            // clientId: dataProfile.value?.tenant_id
         }),
         headers: {
             ['Content-Type']: 'application/json'
@@ -80,7 +83,7 @@ export const plivoCall = async (user) => {
     return result;
 };
 export const plivoEndCall = async (uuid) => {
-    const url = BARE_WEBSOCKET_URL + '/plivo/end-call';
+    const url = BARE_WEBSOCKET_URL + '/ws/end-call';
     const response = await fetch(url, {
         method: 'POST',
         body: JSON.stringify({
@@ -96,3 +99,27 @@ export const plivoEndCall = async (uuid) => {
     const result = await response.json();
     console.log(result);
 };
+export const downloadRecord = async (url_pub) => {
+    const url = BARE_WEBSOCKET_URL + '/ws/download-record';
+    const response = await fetch(url, {
+        method: 'POST',
+        body: JSON.stringify({
+            url: url_pub
+        }),
+        headers: {
+            ['Content-Type']: 'application/json'
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Response status: ${response.status}`);
+    }
+    const blob = await response.blob();
+    const url_blob = window.URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url_blob;
+    a.download = "recording.mp3";
+    a.click();
+    a.remove();
+    // const result = await response.json()
+    console.log(a);
+};

package/dist/test/utils/chat/phone-string.js

@@ -0,0 +1,4 @@
+export const formatPhone10number = (phone, dial) => {
+    let result = phone.replace(/\D/g, '');
+    return result?.startsWith(dial) ? result.slice(dial.length) : result;
+};