Documentação para programadores

Javascript SDK

Visão geral

O skd em javascript é um cliente leve para interagir com a api Speaqr em tempo real. Permite ao programador aceder aos métodos da API, fornecendo determinadas funcionalidades. É compatível com os ambientes browser e Node.jsO pacote é publicado no npm.Para utilizar o SDK , necessita de uma chave API válida. Para a obter, contacte-nos através do formulário de encomenda.

Instalação

Através do npm


					npm install @speaqr/javascript-sdk

Via cdn


					<script src="https://unpkg.com/@speaqr/javascript-sdk@latest/dist/sdk.min.js"></script>

Descarregar os ficheiros

sdk.js
sdk.min.js

Instanciar a classe

O Speaqr SDK pode ser instanciado e utilizado numa variedade de ambientes, como navegadores, Node.js e módulos importados de uma CDN. De seguida, explicamos as diferentes formas de o inicializar em função do ambiente.No pacote npm, existem exemplos específicos de idiomas na pasta: dist/examples/howInstantiateSdk

Navegadores (utilizando CDN)

O SDK está disponível através de uma CDN para ser utilizado diretamente no browser, sem necessidade de instalação prévia.

					<html>
						<script src="https://unpkg.com/@speaqr/javascript-sdk@latest/dist/sdk.min.js"></script>
						<script src="https://my_code.js"></script>
					</html>	
				

					// my_code.js
					const sdk = new SpeaqrSDK({
						apiKey: "YOUR_API_KEY",
						showLogs: true
					});

Node.js

Num ambiente Node.js, podes instalar o SDK através do npm e importá-lo com require ou import, dependendo da tua configuração.

					// Using CommonJS (require)
					const SpeaqrSDK = require("@speaqr/javascript-sdk");

					const sdk = new SpeaqrSDK({
						apiKey: "YOUR_API_KEY",
						showLogs: true
					});

TypeScript

Se trabalhar num ambiente TypeScript, o SDK inclui definições de tipos (index.d.ts) que facilitam a utilização do SDK com tipagem forte.

					import { SpeaqrSDK } from "@speaqr/javascript-sdk";

					const sdk = new SpeaqrSDK({
						apiKey: "YOUR_API_KEY",
						showLogs: true
					});

Ambientes do módulo ES (ESM)

Se estiver a trabalhar num ambiente que suporte módulos ES, como os browsers modernos ou um ambiente de desenvolvimento com suporte ESM, pode utilizar a importação . 

					import SpeaqrSDK from "https://unpkg.com/@speaqr/javascript-sdk@latest/dist/sdk.min.js";

					const sdk = new SpeaqrSDK({
						apiKey: "YOUR_API_KEY",
						showLogs: true
					});

RequireJS

O SDK é compatível com sistemas de carregamento como o RequireJS.

					<html>
						<script data-main="app" src="https://requirejs.org/docs/release/2.3.6/minified/require.js"></script>
						<script src="https://my_code.js"></script>
					</html>	
				

					// my_code.js
					require(["https://unpkg.com/@speaqr/javascript-sdk@latest/dist/sdk.min.js"], 
					function(SpeaqrSDK) {
						const sdk = new SpeaqrSDK({
						apiKey: "YOUR_API_KEY",
						showLogs: true
					});

Construção e destruição

A classe SpeaqrSDK inclui duas formas de instanciação: um construtor síncrono e um método de criação estático assíncrono. Além disso, fornece um método destroy() para libertar recursos quando a instância do SDK já não é necessária.

Construtor síncrono

Este construtor cria imediatamente uma instância do SDK. Requer que a chave da API seja fornecida, mas não efectua a validação na inicialização.

Parâmetros

Exemplo


							const sdk = new SpeaqrSDK({
								apiKey: "YOUR_API_KEY",
								showLogs: true
							});

Construtor assíncrono

Este método estático devolve uma promessa que resolve uma instância do SDK, validando a chave da API antes de concluir a inicialização.

Parâmetros

Exemplo


							try {
								const sdk = await SpeaqrSDK.create({
									apiKey: "YOUR_API_KEY",
									showLogs: true
								});
								console.log("SDK initialized:", sdk);
							} catch (error) {
								console.error("Error initializing SDK:", error);
							}

Método destroy() (libertação de recursos)

O SDK fornece o método destroy() para libertar recursos quando a instância já não é necessária. O método é assíncrono e devolve uma promessa. Este método:
  • Fecha as ligações de socket activas.
  • Remover os ouvintes dos eventos registados.
  • Liberta referências internas para evitar fugas de memória.
  • Substitui todos os métodos SDK para evitar utilizações não intencionais após a destruição.

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							// SDK use
							sdk.languages()
							.then((languages) => console.log("Supported languages:", languages))
							.catch((error) => console.error(error));

							//When the SDK is no longer needed
							await sdk.destroy();
Se tentar chamar um método depois de a instância ter sido destruída, será lançado um erro:

							sdk.languages(); // Error: Method "languages" cannot be called after the SDK instance has been destroyed.

Propriedades

A classe SpeaqrSDK contém várias propriedades acessíveis que permitem configurar e obter informações sobre o estado do SDK.

apiKey

Armazena a chave api utilizada para autenticar os pedidos à api Speaqr.

Acesso


						get apiKey(): string;
						set apiKey(apiKey: string);

Exemplo


							// Get the current API key
							console.log("Current API key:", sdk.apiKey);
	
							// Set a new API key
							sdk.apiKey = "NEW_API_KEY";

logs

Indica se os registos do SDK estão activados na consola.

Acesso


						get logs(): boolean;
						set logs(show: boolean);

Exemplo


							// Enable logs
							sdk.logs = true;

							// Check if logs are enabled
							console.log("Logs enabled:", sdk.logs);

socketOpened

Indica se a ligação do socket está aberta.

Acesso


						get socketOpened(): boolean;

Exemplo


							// Check if the socket connection is open
							if (sdk.socketOpened) {
								console.log("Socket is currently open.");
							} else {
								console.log("Socket is closed.");
							}

Métodos

O SDK fornece vários métodos para interagir com a api Speaqr em lote. As suas utilizações e configurações são descritas em seguida.

languajes

Obtém a lista de idiomas suportados pelo SDK para transcrição, tradução e síntese de voz.

Sintaxe


						languages(): Promise<{
							id: string;
							name: string;
						}[]>;

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							// Fetch the list of supported languages
							sdk.languages()
							.then((languages) => {
								console.log("Supported languages:", languages);
							})
							.catch((error) => {
								console.error("Error fetching languages:", error);
							});

Resposta

Este método devolve uma promessa que resolve um conjunto de objectos, em que cada objeto representa um idioma suportado. O id do idioma será devolvido em ISO3 e o nome do idioma em inglês.

voices

Obtém a lista de vozes disponíveis para a síntese de voz (TTS) numa língua. Opcionalmente, o resultado pode ser filtrado por género de voz, modo de resposta e/ou motor de voz.Desta forma, é possível descobrir se uma configuração de língua, género, modo de resposta e motor pode ser realizada, uma vez que não existem vozes para todas as combinações.

Sintaxe


						voices( 
							language: string,
							mode?: 'block' | 'streaming',
							voiceGender?: 'F' | 'M',
							voiceEngine?: Array<'standard' | 'neural' | 'generative'>
						): Promise<{
							uuid: string;
							language: string;
							gender: VoiceGender;
							engines: Array<'standard' | 'neural' | 'generative'>;
							modes: Array<'block' | 'streaming'>;
						}[]>;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

							// Fetch the list of available voices for English (UK) with a block mode
							sdk.voices('en-gb', 'block')
							.then( (response) => {
								divResponse.innerText = JSON.stringify(response, null, 4);
							})
							.catch( (err) => {
								alert('An error occurred while requesting available voices.');
							});

Resposta

file

Processa um Blob contendo uma forma de onda de áudio e executa a operação especificada em mode. O resultado dependerá do modo selecionado e será devolvido numa promessa.

Sintaxe


						file(params: { 
							mode?: 'sts' | 'stt' | 'stt+translation';
							languageIdSource?: string;
							languageIdTarget?: string;
							voiceGender?: 'F' | 'M';
							file: Blob;
						}): Promise<{ 
							transcription: string
							languageIdSource: string
							translation?: string
							languageIdTarget?: string
							file?: {
								type: string
								data: ArrayBuffer
							}
						}>;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

							// Process an audio file with speech-to-text and translation
							sdk.file({
								mode: "stt+translation",
								file: audioBlob,
								languageIdTarget: "en-us"
							})
							.then((result) => {
								console.log("Processing result:", result);
							})
							.catch((error) => {
								console.error("Error processing file:", error);
							});

Resposta

O resultado do ficheiro dependerá do modo utilizado. Uma resposta com mode=sts conteria todos os campos. O campo file.data é um ArrayBuffer em formato mp3.

Erros

Comunicação com sockets

O Speaqr SDK permite a comunicação em tempo real através de sockets. Estes métodos permitem enviar e receber dados de áudio e de texto sem esperar por uma resposta de bloqueio, melhorando a latência e optimizando a interação com a API.

Fluxo de utilização

A utilização de sockets no SDK segue o seguinte fluxo:
  • Inicializar a configuração da sessão com socketsInstance.
  • Configurar a escuta de respostas com socketsAddListener.
  • Abrir a ligação com socketsOpen.
  • Enviar dados através de socketSendText ou socketsSendStream.
  • Feche a ligação quando esta já não for necessária com socketsClose.

Manuseamento de Socket.IO

O Speaqr SDK utiliza o Socket.IO para a comunicação em tempo real. Para garantir a compatibilidade em todos os ambientes, no caso de o socket.io-client não estar presente, este trata automaticamente da sua carga da seguinte forma:

Deteção de ambiente

Antes de inicializar uma ligação de socket (chamando socketsInstance), o SDK verifica o ambiente em que está a ser executado:
  • Se estiver num navegador, tente carregar socket.io-client a partir de um CDN.
  • Se estiver no Node.js, tente importar socket.io-client dos módulos instalados(require("socket.io-client")).
  • Se ele não puder carregar o socket.io-client, ele lança um erro indicando que ele deve ser instalado manualmente.
A função do SDK que detecta o ambiente é:

						#loadSocketIO() {
							return new Promise((resolve, reject) => {
								//We check if we are in a browser
								if (
									typeof document !== 'undefined' &&
									typeof document.nodeType !== 'undefined' &&
									typeof window !== 'undefined' &&
									window.document === document &&
									document.nodeType === 9
								){
									//Browser
									this.#loadSocketIOBrowser()
									.then( resolve )
									.catch( reject );
								}else{
									//We check if we are in Node
									if (
										typeof process !== 'undefined' &&
										typeof process.versions !== 'undefined' &&
										typeof process.versions.node !== 'undefined'
									  ){
										this.#loadSocketIONode()
										.then( resolve )
										.catch( reject );
									  }else{
										reject('Socket IO cannot be loaded dynamically. You must instantiate it in your project.');
									  }
								}
							});
						}

Carregamento dinâmico nos browsers

Se o SDK detecta que está num navegador e io não está definido, ele carrega socket.io-client a partir do Socket.IO CDN. Se o socket.io-client já estiver disponível no navegador, o SDK não o recarrega. A função do SDK que cuida do carregamento é:

					// static #SOCKETIO_SRC = 'https://cdn.socket.io/4.8.1/socket.io.min.js';
					// static #SOCKETIO_INTEGRITY = 'sha384-mkQ3/7FUtcGyoppY6bz/PORYoGqOl7/aSUMn2ymDOJcapfS6PHqxhRTMh1RR0Q6+';
					#loadSocketIOBrowser() {
						return new Promise((resolve, reject) => {
							if (typeof io!='undefined'){	//If it is already present we do not load it
								resolve();
								return;
							}
			
							const script = document.createElement('script');
							script.src = SpeaqrSDK.#SOCKETIO_SRC;
							script.integrity = SpeaqrSDK.#SOCKETIO_INTEGRITY;
							script.crossOrigin = 'anonymous';
			
							// When the script is loaded successfully
							script.onload = () => resolve();
							
							// En caso de error durante la carga
							script.onerror = () => reject(new Error(`Failed to load script ${script.src}`));
			
							// We add the script to the document
							document.head.appendChild(script);
						});
					}

Carregamento dinâmico no Node.js

Se o SDK detetar que está num ambiente Node.js e que globalThis.io não está definido, tenta importar socket.io-client diretamente. Se não for possível importar, ele lançará um erro indicando que ele deve ser instalado manualmente. A função que lida com a importação é:

					#loadSocketIONode() {
						return new Promise((resolve, reject) => {
							if (typeof globalThis.io !== 'undefined') {
								resolve();
								return;
							}

							try {
								const { io } = require('socket.io-client');
								globalThis.io = io;
								resolve();
							} catch (error) {
								reject(new Error(`Failed to load socket.io-client on Node. Please install with "npm install socket.io-client". Error: ${error}`));
							}
						});
					}

Para evitar problemas

Se trabalhares com Node.js, instala manualmente o socket.io-client. Isso evitará que o SDK falhe se tentar importá-lo e não conseguir encontrá-lo.

						npm install socket.io-client
Se estiveres a trabalhar num browser com restrições de rede (firewalls, CSP), certifica-te de que o teu ambiente te permite carregar scripts a partir de https://cdn.socket.io/. Caso contrário, instala o socket.io-client manualmente no teu projeto e carrega-o antes de inicializar o SDK.

socketsInstance

Configura uma instância de sockets para comunicação em tempo real com a API. Este método deve ser chamado antes de abrir a conexão com socketsOpen(). Retorna uma promessa que é resolvida quando o Socket.io é instanciado.Consoante a funcionalidade pretendida, será escolhido o espaço combres, stt, tradutor, tts ou sts adequado.

Sintaxe


						socketsInstance(
							namespace: 'stt' | 'translator' | 'tts' | 'sts',
							params: 'STTSocketParams' | 'TranslatorSocketParams' | 'TTSSocketParams' | 'STSSocketParams'
						): Promise<void>;

STT

Parâmetros
Exemplo
Configure uma sessão de tomada em tempo real para transcrever áudio.

								const apiKey='xxxxx';	//Your valid apiKey
								sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

								sdk.socketsInstance("stt", {
									languageIdSource: "en-us",
									sendAudio: {
										broadcastVia: "chunk"
									}
								});

TRANSLATOR

Parâmetros
Exemplo
Configurar uma sessão de socket em tempo real para tradução.

								const apiKey='xxxxx';	//Your valid apiKey
								sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

								sdk.socketsInstance("translator", {
									languageIdSource: "en-us",
									languageIdTarget: "es-es",
								});

TTS

Parâmetros
Exemplo
Configurar uma sessão de tomada em tempo real para sintetizar áudio a partir de texto.

								const apiKey='xxxxx';	//Your valid apiKey
								sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

								sdk.socketsInstance("tts", {
									languageIdTarget: "en-us",
									receiveAudio: {
										obtainVia: "chunk"
									}
								});

STS

Parâmetros
Exemplo
Configurar uma sessão de tomada de voz em tempo real.

								const apiKey='xxxxx';	//Your valid apiKey
								sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

								sdk.socketsInstance("sts", {
									languageIdSource: "en-us",
									languageIdTarget: "en-us",
									sendAudio: {
										broadcastVia: "chunk"
									},
									receiveAudio: {
										obtainVia: "chunk"
									}
								});

socketsOpen

Abre a ligação de socket previamente configurada com socketsInstance(). A falha em chamar socketsInstance resultará em um erro. Este método devolve uma promessa que resolve para um booleano, ou o url para receber o fluxo de áudio se receiveAudio.obtainVia = url.

Sintaxe


						socketsOpen(): Promise<boolean | string>;

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							sdk.socketsInstance("sts", {
								languageIdSource: "en-us",
								languageIdTarget: "en-us",
								sendAudio: {
									broadcastVia: "chunk"
								},
								receiveAudio: {
									obtainVia: "chunk"
								}
							})
							.then( () => {
								//We establish the connection with the sockets
								sdk.socketsOpen()
								.then( (response) => {
									//Open sockets
									console.log(response);
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

socketsClose

Devolve uma promessa que é resolvida quando a ligação de socket estabelecida com socketsOpen é fechada. A não chamada de socketsInstance resultará num erro. Se socketsOpen não tiver sido chamado, este método não executa qualquer ação e continua a resolver a promessa.

Sintaxe


						socketsClose(): Promise<void>;

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							sdk.socketsInstance("sts", {
								languageIdSource: "en-us",
								languageIdTarget: "en-us",
								sendAudio: {
									broadcastVia: "chunk"
								},
								receiveAudio: {
									obtainVia: "chunk"
								}
							})
							.then( () => {
								//We establish the connection with the sockets
								sdk.socketsOpen()
								.then( (response) => {
									//Open sockets
									console.log(response);

									// We close the sockets
									sdk.socketsClose()
									.then( () => {
										console.log('sockets are closed');
									})
									.catch( (err) => {
										console.error('There was an error closing the sockets.', err);
									});
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

socketsAddListener

Subscreve um ouvinte para um evento específico da ligação de socket. Isto permite receber dados em tempo real. A não chamada de socketsInstance resultará num erro.

Sintaxe


						socketsAddListener(
							eventType: 'connected' | 'start' | 'error' | 'result' | 'endSynth',
							listener: (data: any) => void
						): void;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							sdk.socketsInstance("sts", {
								languageIdSource: "en-us",
								languageIdTarget: "en-us",
								sendAudio: {
									broadcastVia: "chunk"
								},
								receiveAudio: {
									obtainVia: "chunk"
								}
							})
							.then( () => {
								// We subscribe to events
								sdk.socketsAddListener('result', (data) => {
									console.log(data);
								});

								sdk.socketsAddListener('error', (error) => {
									console.error(error);
								});

								//We establish the connection with the sockets
								sdk.socketsOpen()
								.then( (response) => {
									//Open sockets
									console.log(response);

									// We close the sockets
									sdk.socketsClose()
									.then( () => {
										console.log('sockets are closed');
									})
									.catch( (err) => {
										console.error('There was an error closing the sockets.', err);
									});
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

Resposta

Consoante o evento, a resposta obtida será diferente. Para cada uma delas, são apresentadas em pormenor as respostas obtidas.
connected
Este evento não devolve o objeto com o qual os sockets foram instanciados.
start
Devolve um booleano ou o url para receber o áudio em fluxo contínuo se receiveAudio.obtainVia = url.
result
Os campos do objeto a receber dependerão do espaço de nomes com que os sockets foram instanciados. Abaixo está um objeto para sts que contém todos os campos possíveis.
endSynth
Recebe o texto do qual se terminou a síntese de áudio.
error
Este evento recebe um objeto com diferentes descrições de erros que podem ocorrer, quer devido a erros de programação na instanciação dos modos de utilização, quer nos dados que estão a tentar ser processados. São enumerados os possíveis erros de execução.

Erros

disconnect
Recebe uma cadeia de caracteres com o motivo da desconexão. Por exemplo: "io client disconnect" ou "transport close"

socketsRemoveListener

Remove um ouvinte de um evento e função específicos previamente subscritos com socketAddListener. Se o socketAddListener não tiver sido feito para esse tipo de evento e/ou função, será devolvido um erro. A não chamada de socketsInstance resultará num erro.

Sintaxe


						socketsRemomveListener(
							eventType: 'connected' | 'start' | 'error' | 'result' | 'disconnect', 
							listener: (data: any) => void
						): void;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							sdk.socketsInstance("sts", {
								languageIdSource: "en-us",
								languageIdTarget: "en-us",
								sendAudio: {
									broadcastVia: "chunk"
								},
								receiveAudio: {
									obtainVia: "chunk"
								}
							})
							.then( () => {
								// We subscribe to events
								sdk.socketsAddListener('result', evt_result);

								sdk.socketsAddListener('start', (status) => {
									console.log(status);

									// Once the connection is established, I unsubscribe from "result"
									sdk.socketsRemoveListener('result', evt_result);
								});

								//We establish the connection with the sockets
								sdk.socketsOpen()
								.then( (response) => {
									//Open sockets
									console.log(response);

									// We close the sockets
									sdk.socketsClose()
									.then( () => {
										console.log('sockets are closed');
									})
									.catch( (err) => {
										console.error('There was an error closing the sockets.', err);
									});
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

							// Function for the "result" event
							function evt_result(data){
								console.log(data);
							}

socketsSendText

Envia um texto para ser processado e devolve uma promessa, que é resolvida com o estado do envio do socket recebido. Se os sockets não estiverem abertos, ocorrerá um erro. Se ocorrer um erro, a mensagem será rejeitada, comunicando o erro.

Sintaxe


						socketsSendText(text: string): Promise<boolean>;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});

							sdk.socketsInstance('translator', {
								languageIdSource:'en-gb',
								languageIdTarget:'fr-fr',
							})
							.then( () => {
								// We subscribe to events. Here we will receive the translation
								sdk.socketsAddListener('result', (data) => {
									console.log(data);
								});

								// We establish the connection with the sockets
								sdk.socketsOpen()
								.then( (response) => {
									//Open sockets
									console.log(response);

									//I send the text to process
									sdk.socketsSendText('Hello, world. How are you today?')
									.then( response => console.log('Send status', response))
									.catch( respose => console.error('Send status', response));
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

socketsSendStream

Envia um fragmento de áudio para processamento e devolve uma promessa, que é resolvida pelo estado do envio da tomada recebida. Se os sockets não estiverem abertos, ocorrerá um erro. Se ocorrer um erro, será rejeitado, comunicando o erro.

Sintaxe


						socketsSendStream(data: ArrayBuffer | Blob): Promise<boolean>;

Parâmetros

Exemplo


							const apiKey='xxxxx';	//Your valid apiKey
							sdk = await SpeaqrSDK.create({apiKey, showLogs:true});
							
							sdk.socketsInstance("sts", {
								languageIdSource: "en-us",
								languageIdTarget: "en-us",
								sendAudio: {broadcastVia: "chunk"},
								receiveAudio: {obtainVia: "chunk", codec: 'mp3', sampleRate: 16000}
							})
							.then( () => {
								//We subscribe to events.  Here we will receive the translation
								sdk.socketsAddListener('result', result => console.log(result));

								sdk.socketsAddListener('start', (status) => {
									console.log(status);

									// Once the connection is established, I unsubscribe from "result"
									sdk.socketsRemoveListener('result', evt_result);
								});

								//We establish the connection with the sockets
								sdk.socketsOpen()
								.then(async (response) => {
									//Open sockets
									console.log(response);

									await start();
									console.log('Speak now!!!!');
								})
								.catch( (err) => {
									console.error('An error occurred while connecting to the sockets.', err);
								});
							})
							.catch( (err) => {
								console.error('An error occurred while instantiating to the sockets.', err);
							});

							// Start capturing and processing microphone audio
							const start = async () => {
								navigator.mediaDevices.getUserMedia({ audio: true })
								.then(stream => {
									mediaRecorder = new MediaRecorder(stream);
									mediaRecorder.ondataavailable = ondataavailable;
									mediaRecorder.start(500);
								})
								.catch(error => {
									console.error("Error starting recording:", error);
								});
							}

							// Here you receive each audio fragment in a Blob
							const ondataavailable = (event) => {
								if (!sdk.socketOpened) return;

								if (event.data && event.data.size > 0) {
									const audioChunk = event.data;
									sdk.socketsSendStream(audioChunk);
								}
							};

Este sítio Web utiliza cookies

Os cookies neste sítio Web são utilizados para personalizar o conteúdo e analisar o tráfego.
Pode encontrar os detalhes destes cookies na secção Política de Privacidade.