Documentation pour les développeurs

SDK Javascript

Vue d'ensemble

Le skd en javascript est un client léger pour interagir avec l'api de Speaqr en temps réel. Il facilite l'accès du programmeur aux méthodes de l'api en lui fournissant certaines fonctionnalités prêtes à l'emploi. Il est compatible avec les environnements de navigateur et de Node.jsLe paquet est publié sur npm.Pour utiliser le SDK tu as besoin d'une clé API valide. Pour l'obtenir, contactez-nous via le formulaire de contact.

Installation

Via npm


					npm install @speaqr/javascript-sdk

Via cdn


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

Télécharger les fichiers

sdk.js
sdk.min.js

Instancier la classe

Le SDK de Speaqr peut être instancié et utilisé dans divers environnements, tels que les navigateurs, Node.js et les modules importés depuis un CDN. Ci-dessous, les différentes manières de l'initialiser en fonction de l'environnement sont expliquées.Dans le paquet npm, tu as des exemples avec des langues spécifiques dans le dossier :dist/examples/howInstantiateSdk

Navigateurs (avec CDN)

Le SDK est disponible via un CDN pour être utilisé directement dans le navigateur, sans besoin d'installation préalable.

					<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

Dans un environnement Node.js, tu peux installer le SDK via npm et l'importer avec require ou import selon ton configuration.

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

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

TypeScript

Si tu travaillez dans un environnement TypeScript, le SDK inclut des définitions de type (index.d.ts) qui facilitent l'utilisation du SDK avec un typage fort.

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

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

Environnements Modules ES (ESM)

Si tu travaillez dans un environnement qui prend en charge les modules ES, comme les navigateurs modernes ou un environnement de développement prenant en charge ESM, tu peux utiliser import. 

					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

Le SDK est compatible avec des systèmes de chargement comme 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
					});

Bâtisseurs et destructeurs

La classe SpeaqrSDK inclut deux façons d'instanciation : un constructeur synchrone et une méthode statique asynchrone create. De plus, elle fournit la méthode destroy() pour libérer les ressources lorsque l'instance du SDK n'est plus nécessaire.

Constructeur synchrone

Ce constructeur crée une instance du SDK de manière immédiate. Il nécessite que la clé API soit fournie, mais ne réalise pas de validations au moment de l'initialisation.

Paramètres

Exemple


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

Constructeur asynchrone

Cette méthode statique renvoie une promesse qui se résout avec une instance du SDK, en validant la clé API avant de terminer l'initialisation.

Paramètres

Exemple


							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éthode destroy() (libération des ressources)

Le SDK fournit la méthode destroy() pour libérer des ressources lorsque l'instance n'est plus nécessaire. La méthode est asynchrone et retourne une promesse. Cette méthode :
  • Ferme les connexions de sockets actives.
  • Supprime les écouteurs d'événements enregistrés.
  • Libérez les références internes pour éviter les fuites de mémoire.
  • Annule toutes les méthodes du SDK pour prévenir les utilisations indésirables après la destruction.

Exemple


							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();
Si tu essayez d'appeler une méthode après avoir détruit l'instance, une erreur sera lancée :

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

Propriétés

La classe SpeaqrSDK contient plusieurs propriétés accessibles qui permettent de configurer et d'obtenir des informations sur l'état du SDK.

apiKey

Stocke la clé API utilisée pour authentifier les requêtes à l'API de Speaqr.

Accès


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

Exemple


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

logs

Indique si les journaux du SDK sont activés dans la console.

Accès


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

Exemple


							// Enable logs
							sdk.logs = true;

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

socketOpened

Indique si la connexion des sockets est ouverte.

Accès


						get socketOpened(): boolean;

Exemple


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

Méthodes

Le SDK fournit plusieurs méthodes pour interagir avec l'API de Speaqr en batch. Ci-dessous, leurs utilisations et configurations sont détaillées.

languajes

Obtenez la liste des langues prises en charge par le SDK pour la transcription, la traduction et la synthèse vocale.

Syntaxe


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

Exemple


							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);
							});

Réponse

Cette méthode renvoie une promesse qui se résout avec un tableau d'objets, où chaque objet représente une langue prise en charge. L'identifiant de la langue sera retourné en ISO3, et le nom de la langue en anglais.

voices

Obtenez la liste des voix disponibles pour la synthèse vocale (TTS) dans une langue. Il est possible de filtrer le résultat par genre de voix, mode de réponse et/ou moteur de voix.Par ce moyen, on peut savoir si une configuration de langue, de genre, de mode de réponse et de moteur peut être réalisée, car il n'existe pas de voix pour toutes les combinaisons.

Syntaxe


						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'>;
						}[]>;

Paramètres

Exemple


							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.');
							});

Réponse

file

Traitez un Blob contenant une onde audio et effectuez l'opération spécifiée dans mode. Le résultat dépendra du mode sélectionné et sera retourné dans une promesse.

Syntaxe


						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
							}
						}>;

Paramètres

Exemple


							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);
							});

Réponse

Le résultat de file dépendra du mode utilisé. Une réponse avec mode=sts inclurait tous les champs. Le champ file.data est un ArrayBuffer au format mp3.

Erreurs

Communication avec les sockets

Le SDK de Speaqr permet la communication en temps réel via des sockets. Ces méthodes permettent d'envoyer et de recevoir des données audio et texte sans avoir besoin d'attendre une réponse bloquante, améliorant ainsi la latence et optimisant l'interaction avec l'api.

Flux d'utilisation

L'utilisation des sockets dans le SDK suit le flux suivant :
  • Initialiser la configuration de la session avec socketsInstance.
  • Configurer l'écoute des réponses avec socketsAddListener.
  • Ouvrir la connexion avec socketsOpen.
  • Envoyer des données via socketSendText ou socketsSendStream.
  • Fermer la connexion lorsqu'elle n'est plus nécessaire avec socketsClose.

Gestion de Socket.IO

Le SDK de Speaqr utilise Socket.IO pour la communication en temps réel. Pour garantir la compatibilité dans tous les environnements, au cas où socket.io-client ne serait pas présent, il gère automatiquement son chargement de la manière suivante :

Détection de l'environnement

Avant d'initialiser une connexion de sockets (en appelant socketsInstance), le SDK vérifie l'environnement dans lequel il s'exécute :
  • Si tu es sur un navigateur, essayez de charger socket.io-client depuis un CDN.
  • Si tu es sur Node.js, essayez d'importer socket.io-client depuis les modules installés (require("socket.io-client")).
  • Si tu ne pouvez pas charger socket.io-client, lancez une erreur indiquant qu'il doit être installé manuellement.
La fonction du SDK qui détecte l'environnement est :

						#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.');
									  }
								}
							});
						}

Chargement dynamique dans les navigateurs

Si le SDK détecte que tu es dans un navigateur et que io n'est pas défini, il charge socket.io-client à partir du CDN Socket.IO. Si socket.io-client est déjà disponible dans le navigateur, le SDK ne le recharge pas. La fonction du SDK qui se charge du chargement est la suivante :

					// 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);
						});
					}

Chargement dynamique en Node.js

Si le SDK détecte que tu es dans un environnement Node.js et que globalThis.io n'est pas défini, il tente d'importer socket.io-client directement. S'il ne peut pas l'importer, il lancera une erreur indiquant qu'il doit être installé manuellement. La fonction qui gère l'importation est la suivante :

					#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}`));
							}
						});
					}

Pour éviter les problèmes

Si tu travaillez avec Node.js, installez manuellement socket.io-client. Ainsi, tu éviterez que le SDK échoue s'il essaie de l'importer et ne le trouve pas.

						npm install socket.io-client
Si tu travaillez dans un navigateur avec des restrictions réseau (pare-feux, CSP), assurez-tu que ton environnement permet de charger des scripts depuis https://cdn.socket.io/. Sinon, installez socket.io-client manuellement dans ton projet et chargez-le avant d'initialiser le SDK.

socketsInstance

Configurez une instance de sockets pour la communication en temps réel avec l'API. Cette méthode doit être appelée avant d'ouvrir la connexion avec socketsOpen(). Elle retourne une promesse qui se résout lorsque Socket.io a été instancié.Selon la fonctionnalité souhaitée, l'espace de noms approprié sera choisi : stt, translator, tts ou sts.

Syntaxe


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

STT

Paramètres
Exemple
Configurer une session de socket en temps réel pour transcrire l'audio.

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

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

TRANSLATOR

Paramètres
Exemple
Configurer une session de socket en temps réel pour la traduction.

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

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

TTS

Paramètres
Exemple
Configurer une session de socket en temps réel pour synthétiser de l'audio à partir d'un texte.

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

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

STS

Paramètres
Exemple
Configurer une session de socket en temps réel speech-to-speech.

								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

Ouvre la connexion de sockets préalablement configurée avec socketsInstance(). Si socketsInstance n'a pas été appelé, une erreur sera obtenue. Cette méthode renvoie une promesse qui se résout avec un booléen, ou avec l'URL pour recevoir l'audio en streaming si receiveAudio.obtainVia = url.

Syntaxe


						socketsOpen(): Promise<boolean | string>;

Exemple


							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

Renvoie une promesse qui se résout lorsque la connexion de sockets établie avec socketsOpen est fermée. Si socketsInstance n'a pas été appelé, une erreur sera obtenue. Si socketsOpen n'a pas été appelé, cette méthode n'effectue aucune action et résoudra néanmoins la promesse.

Syntaxe


						socketsClose(): Promise<void>;

Exemple


							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

Abonnez un écouteur à un événement spécifique de la connexion des sockets. Cela permet de recevoir des données en temps réel. Si socketsInstance n'a pas été appelé, une erreur se produira.

Syntaxe


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

Paramètres

Exemple


							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);
							});

Réponse

Selon l'événement, la réponse obtenue sera différente. Ils sont détaillés ci-dessous pour chacun d'eux.
connected
Cet événement ne renvoie pas l'objet avec lequel les sockets ont été instanciés.
start
Renvoie un booléen ou l'URL pour recevoir l'audio en streaming si receiveAudio.obtainVia = url.
result
Les champs de l'objet reçu dépendront de l'espace de noms avec lequel les sockets ont été instanciés. Voici un objet pour sts qui contient tous les champs possibles.
error
Cet événement reçoit un objet avec différentes descriptions d'erreurs qui pourraient survenir, soit en raison de défaillances dans la programmation de l'instanciation des modes d'utilisation, soit dans les données qui sont tentées d'être traitées. Les erreurs d'exécution possibles sont listées.

Erreurs

disconnect
Recevez une chaîne avec le motif de la déconnexion. Par exemple : "io client disconnect" ou "transport close"

socketsRemoveListener

Supprimez un écouteur d'un événement et d'une fonction spécifiques auxquels tu tu étiez précédemment abonné avec socketAddListener. Si tu n'aviez pas fait le socketAddListener à ce type d'événement et/ou à cette fonction, une erreur se produira. Si socketsInstance n'a pas été appelé, une erreur se produira.

Syntaxe


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

Paramètres

Exemple


							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

Envoyez un texte pour qu'il soit traité et renvoyez une promesse, qui se résout avec l'état de l'envoi reçu des sockets. Si les sockets ne sont pas ouverts, une erreur se produira. En cas d'erreur, elle sera rejetée en informant de l'erreur.

Syntaxe


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

Paramètres

Exemple


							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

Envoyez un extrait audio pour le traiter et renvoyez une promesse, qui se résout avec l'état de l'envoi reçu des sockets. Si les sockets ne sont pas ouverts, une erreur se produira. En cas d'erreur, elle sera rejetée en informant de l'erreur.

Syntaxe


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

Paramètres

Exemple


							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);
								}
							};

Ce site web utilise des cookies

Les cookies de ce site web sont utilisées pour personnaliser le contenu et analyser le trafic.
Tu pouvez trouver les détails de celles-ci dans la section Politique de confidentialité