Geekly articles weekly

Barrymore, wie ist das Treiben um Voximplant? Implementiert Web-Sockets, Sir


WebSocket ist ein fortschrittlicher Standard für die Vollduplex-Kommunikation (bidirektional) zwischen einem Client und einem Drittanbieter-Service in Echtzeit. Web-Sockets werden verwendet, um den kontinuierlichen Datenaustausch ohne zusätzliche HTTP-Anforderungen zu organisieren.

Und wir freuen uns, Ihnen mitteilen zu können, dass dies in Voximplant dank des neuen VoxEngine- Moduls möglich geworden ist, das - surprise - WebSocket heißt . Ab sofort können Sie Text und Audio unter voller Ausnutzung der Web-Sockets übertragen. Kurz gesagt, Sie haben ein weiteres Tool zum Aktualisieren Ihrer Anwendung.

In diesem Artikel erfahren Sie, wie Sie eine ausgehende WebSocket-Verbindung erstellen, einen Audiostream über diese Verbindung übertragen und mithilfe der Google Cloud-Sprach-Text-API in Text konvertieren.
Bitte beachten Sie, dass Voximplant eine integrierte Funktion zur Konvertierung von Sprache in Text in Echtzeit unter der Steuerung des ASR-Moduls besitzt . Dieses Modul verwendet Funktionen von Google, Yandex und Tinkoff, Details finden Sie hier .

Der aktuelle Artikel beschreibt den Fall, dass Sie einen Drittanbieter-Service zum Konvertieren von Sprache in Text und / oder Ausgeben von Geld von seinem Konto und nicht vom Voximplant-Konto aus verwenden möchten.

Unser Modul bietet zwei Arbeitsformate:
  • Herstellen einer ausgehenden Verbindung;
  • Empfangen einer eingehenden Verbindung und Erstellen eines Web-Sockets dafür.

Ausgehend


Wenn Sie eine ausgehende Verbindung erstellen, müssen Sie zunächst das VoxEngine-Skript ausführen. Rufen Sie dann die VoxEngine.createWebSocket- Methode auf, mit der das WebSocket- Objekt erstellt wird. Diese Methode akzeptiert 2 Parameter: URL im Format 'wss: // + domain + path' und Protokolle (optional). So würde es im Code aussehen:

VoxEngine.addEventListener(AppEvents.CallAlerting, function(e) { const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_link/"); //       });

Wenn alles funktioniert, sendet die call.sendMediaTo- Methode den Audiostream an den Socket, und WebSocket.send sendet wiederum den decodierten Audiostream im JSON-Format über diesen Socket. Infolgedessen erhalten Sie Nachrichten von dem Dienst, der die Anforderungen verarbeitet.

Die WebSocket.close- Methode wird benötigt, um die Verbindung zu schließen. Bitte beachten Sie, dass die Verbindung sowohl auf der Client-Seite als auch auf der Server-Seite geschlossen werden kann.

Posteingang


Um eingehende Verbindungen zuzulassen, müssen Sie dies über VoxEngine.allowWebSocketConnections melden und das Ereignis AppEvents.WebSocket abonnieren. Dann ist es möglich, die eingehende Verbindung zu akzeptieren und das WebSocket: event.WebSocket-Objekt abzurufen. Siehe den Code unten:

 VoxEngine.allowWebSocketConnections(); VoxEngine.addEventListener(AppEvents.WebSocket, function(e) { //       });

Um einen eingehenden Web-Socket zu erstellen, benötigen Sie das accessSecureURL-Steuerelement. Sie kann dem Ereignis AppEvents.Started oder der Antwort auf die HTTP-Anforderung entnommen werden, mit der die Sitzung gestartet wurde. Beachten Sie, dass "https" in der URL in "wss" geändert werden muss.

Die übrigen Schritte sind mit denen im Schema für ausgehende Verbindungen identisch.

Du wirst brauchen


Um die WebSocket-Technologie und die Spracherkennung in Ihre Anwendung zu implementieren, benötigen Sie:
  • Voximplant-Konto. Wenn Sie es nicht haben, können Sie sich hier registrieren.
  • Voximplant-Anwendung sowie ein Skript, eine Regel und ein einzelner Benutzer. All dies wird in diesem Tutorial erstellt.
  • einfaches Backend (wir starten den Server auf node.js) mit der Cloud-Client-Bibliothek, die für die Speech-to-Text-API verbunden ist;
  • Web-Client zum Tätigen eines Anrufs (wir verwenden das Web-Telefon unter phone.voximplant.com ).

1. VOXIMPLANT Einstellungen


Melden Sie sich zunächst unter manage.voximplant.com/auth in Ihrem Konto an. Klicken Sie im Menü links auf "Programme", erstellen Sie ein neues und nennen Sie es websocket. Gehen Sie in Ihre Anwendung, wechseln Sie zur Registerkarte Skripte, erstellen Sie ein Skript und fügen Sie den folgenden Code ein:

 require(Modules.WebSocket); VoxEngine.addEventListener(AppEvents.CallAlerting, function(e) { call = e.call; call.answer(); const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_ngrok_link/"); webSocket.addEventListener(WebSocketEvents.ERROR, function(e) { Logger.write("LOG OUTGOING: WebSocketEvents.ERROR"); call.sendMessage("LOG OUTGOING: WebSocketEvents.ERROR"); }); webSocket.addEventListener(WebSocketEvents.CLOSE, function(e) { Logger.write("LOG OUTGOING: WebSocketEvents.CLOSE: " + e.reason); call.sendMessage("LOG OUTGOING: WebSocketEvents.CLOSE: " + e.reason); }); webSocket.addEventListener(WebSocketEvents.OPEN, function(e) { Logger.write("LOG OUTGOING: WebSocketEvents.OPEN"); Logger.write(JSON.stringify(e)) call.sendMessage("LOG OUTGOING: WebSocketEvents.OPEN"); }); webSocket.addEventListener(WebSocketEvents.MESSAGE, function(e) { Logger.write("LOG OUTGOING: WebSocketEvents.MESSAGE: " + e.text); call.sendMessage("LOG OUTGOING: WebSocketEvents.MESSAGE: " + e.text); if (e.text == "Hi there, I am a WebSocket server") { call.sendMediaTo(webSocket, { encoding: WebSocketAudioEncoding.ULAW, "tag": "MyAudioStream", "customParameters": { "param1": "12345" } }); } }); call.addEventListener(CallEvents.Disconnected, function(e) { Logger.write("LOG OUTGOING: terminating in 1 sec"); webSocket.close(); setTimeout(VoxEngine.terminate, 1000); }); });

Dieses VoxEngine-Skript sendet einen Audio-Stream an WebSocket und verfolgt auch dessen Ereignisse (ERROR, CLOSE, OPEN, MESSAGE). Wir können uns etwas später mit den Details des Drehbuchs befassen.

Gehen wir nun zur Registerkarte "Routing", klicken Sie auf "Neue Regel" und nennen Sie es "Socket-Regel". Jetzt müssen Sie nur noch Ihr Skript auswählen und die Maske standardmäßig verlassen (. *).


Das Letzte, was Sie in dieser Phase tun müssen, ist, einen Benutzer zu erstellen. Wechseln Sie zur Registerkarte „Benutzer“, klicken Sie auf „Benutzer erstellen“, geben Sie einen Namen (z. B. socketUser) und ein Kennwort ein und klicken Sie dann auf „Erstellen“. Wir benötigen dieses Benutzername / Passwort-Paar für die Authentifizierung im Web-Client im letzten Schritt.


Die Konfiguration ist abgeschlossen, aber bevor wir mit der Erstellung des Servers beginnen, schauen wir uns an, wie das WebSocket-Modul in unserem Szenario funktioniert.

2. Details des Skripts


Mit dem WebSocket-Modul können Entwickler eine stabile Verbindung herstellen und Daten über diese senden. Um dieses Modul zu verwenden, müssen wir es ganz am Anfang des Skripts verbinden:

 require(Modules.WebSocket);

Über die Methode createWebSocket bestimmen wir die URL und die Protokolle (optional). Wie Sie die URL für WebSocket erhalten, erfahren Sie im nächsten Abschnitt.

 const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_ngrok_link/");

Nach dem Erstellen des WebSocket-Objekts wird der Aufruf weiterhin im Handler verwaltet. Das heißt, wir senden die Medien mit der Methode call.sendMediaTo an das WebSocket-Objekt.

Hier können Sie das bevorzugte Kodierungsformat, das Tag und einige benutzerdefinierte Parameter festlegen. Wenn Sie die Kodierung nicht einstellen, wird standardmäßig PCM8 verwendet.

Diese Methode wird aufgerufen, wenn eine erfolgreiche Verbindungsnachricht empfangen wird . In unserem Szenario sieht der Anrufcode folgendermaßen aus:

 call.sendMediaTo(webSocket, { encoding: WebSocketAudioEncoding.ULAW, "tag": "MyAudioStream", "customParameters": { "param1": "12345" } });

Alle anderen WebSocket-Ereignisse, die Sie im Code sehen, dienen dem Debugging und senden Informationen an das Protokoll der Voximplant-Sitzung. Sie können sie entfernen, wenn Sie möchten.

Schließlich fügen wir den richtigen Datenübertragungsabschluss-Handler hinzu. In unserem Fall beendet die Voximplant-Sitzung ihre Arbeit 1 Sekunde nach dem Ende des festgelegten Anrufs (getrennt):

 call.addEventListener(CallEvents.Disconnected, function(e) { Logger.write("LOG OUTGOING: terminating in 1 sec"); webSocket.close(); setTimeout(VoxEngine.terminate, 1000); });

Nachdem die Logik des Skripts klar ist, ist es Zeit, mit dem nächsten, sehr wichtigen Teil unseres Beispiels fortzufahren.

3. Backend


Stellen Sie zunächst sicher, dass Node.js. auf Ihrem Computer installiert ist. Sie können es von der Node.js- Hauptseite herunterladen. Führen Sie anschließend die folgenden Befehle nacheinander im Terminalfenster aus, um die Arbeitsumgebung einzurichten:

 npm install express npm install ws npm install @google-cloud/speech

Und wenn dies erledigt ist, erstellen Sie eine leere JS-Datei und platzieren Sie den folgenden Code dort (die Nuancen des Codes werden unten hervorgehoben):

 const app = require('express')(); const http = require('http').createServer(app); const WebSocket = require('ws'); const fs = require('fs'); const wss = new WebSocket.Server({ server: http }); //     Google Cloud const speech = require('@google-cloud/speech'); //    const client = new speech.SpeechClient(); const config = { encoding: 'MULAW', sampleRateHertz: 8000, languageCode: 'ru-RU', }; const request = { config, interimResults: true, }; let audioInput = []; let recognizeStream = null; process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = 0; app.get('/', function(req, res) { res.send('<h1>Hello world</h1>'); }); wss.on('connection', (ws) => { //  ,       var wstream = fs.createWriteStream('myBinaryFile'); //   audioInput audioInput = []; //    recognizeStream = client .streamingRecognize(request) .on('error', err => { ws.close(); }) .on('data', data => { ws.send(data.results[0].alternatives[0].transcript) process.stdout.write( data.results[0] && data.results[0].alternatives[0] ? `Transcription: ${data.results[0].alternatives[0].transcript}\n` : `\n\nError occurred, press Ctrl+C\n` ) }); ws.on('close', (message) => { console.log('The time limit for speech recognition has been reached. Please disconnect and call again.'); wstream.end(); }) //  ,     message ws.on('message', (message) => { //     base64  recognizeStream try { let data = JSON.parse(message) if (data.event == "media") { let b64data = data.media.payload; let buff = new Buffer.from(b64data, 'base64'); recognizeStream.write(buff); wstream.write(buff); } } catch (err) { console.log(message) } }); //      ws.send('Hi there, I am a WebSocket server'); }); http.listen(3000, function() { console.log('listening on *:3000'); });

Jetzt, da der Server konfiguriert ist, können wir die Spracherkennung durchführen. Testen Sie Ihre Lösung lokal, indem Sie mit ngrok einen Tunnel auf localhost 3000 erstellen.

Gehen Sie hierzu folgendermaßen vor
  1. Installieren Sie ngrok, indem Sie den Anweisungen auf der Website folgen.
  2. Geben Sie Ihr Authtoken für ngrok an, um den Client an dieses Konto zu binden.
  3. Führen Sie den node your_file_name.js , um Ihren Server auf localhost: 3000 zu starten.
  4. Wechseln Sie zum Ordner ngrok auf Ihrem Computer, und führen Sie den Befehl ./ngrok http 3000 , um einen Tunnel zwischen dem ./ngrok http 3000 lokalen Server und der öffentlichen URL herzustellen.

Achten Sie auf die generierte öffentliche URL, wir verwenden sie als WebSocket-URL mit dem Präfix 'wss' im Skript:



4. Spracherkennung


Sie haben wahrscheinlich bemerkt, dass unser Back-End-Code Zeilen enthält, die sich auf Google Cloud beziehen.

Die Bibliothek selbst wird wie folgt importiert:

 const speech = require('@google-cloud/speech');

Nun müssen Sie angeben, wie die Spracherkennungsanforderung verarbeitet werden soll. Wählen Sie dazu Encoding, SampleRateHertz und LanguageCode in der generierten Konfiguration:

 const config = { encoding: 'MULAW', sampleRateHertz: 8000, languageCode: 'en-US', };

Erstellen Sie als Nächstes einen Schreibstrom, mit dem Sie die übertragenen Daten in einer Datei speichern können:

 var wstream = fs.createWriteStream('myBinaryFile');

Wenn alles eingerichtet ist, müssen Sie die Nachricht analysieren und die Audiodaten im base64-Format in detectStream ablegen:

 let data = JSON.parse(message) if (data.event == "media") { b64data = data.media.payload; let buff = new Buffer.from(b64data, 'base64'); recognizeStream.write(buff); wstream.write(buff); }

Unmittelbar danach wird eine Erkennungsanforderung initiiert und die Verarbeitung dieser Anforderung beginnt:

 recognizeStream = client .streamingRecognize(request) .on('data', data => { ws.send(data.results[0].alternatives[0].transcript) });

Geben Sie abschließend die Anmeldeinformationen Ihres Dienstkontos ein, um die Google-Bibliothek mit ihrem Back-End zu verbinden. Rufen Sie dazu die Google-Authentifizierungsseite auf und befolgen Sie alle dort aufgeführten Schritte. Führen Sie dann den Befehl export in demselben Arbeitsbereich (auf derselben Registerkarte „Terminal“) wie den node your_file_name.js:

 export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/[FILE_NAME].json"

Sockets starten


Öffnen Sie phone.voximplant.com , füllen Sie das Formular aus und klicken Sie auf Anmelden . Benutzername und Passwort beziehen sich auf den in Schritt 1 erstellten Benutzer:


Klicken Sie nach erfolgreicher Autorisierung auf Anrufen und sprechen Sie. Die Speech-to-Text-Cloud wandelt Ihre Sprache in Echtzeit in Text um, und Sie können diesen Text im Terminalfenster sehen.

Du hast es geschafft, Glückwunsch! Wir hoffen, dass Ihnen der Artikel gefallen hat und wünschen Ihnen mehr Integration und neue Herausforderungen.

Source: https://habr.com/ru/post/de476902/

More articles:


All Articles