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, pode instalar o SDK através do npm e importá-lo com require ou import, dependendo da sua 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 você trabalha com Node.js, instale manualmente o socket.io-client. Isso evitará que o SDK falhe se ele tentar importá-lo e não conseguir encontrá-lo.

						npm install socket.io-client
Se estiver a trabalhar num browser com restrições de rede (firewalls, CSP), certifique-se de que o seu ambiente lhe permite carregar scripts a partir de https://cdn.socket.io/. Caso contrário, instale o socket.io-client manualmente no seu projeto e carregue-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',
							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.
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.