Geekly articles weekly

Barrymore, o que há em torno do Voximplant? Soquetes da Web implementados, senhor


O WebSocket é um padrão progressivo para comunicação full-duplex (bidirecional) entre um cliente e um serviço de terceiros em tempo real. Os soquetes da Web são usados ​​para organizar a troca contínua de dados sem solicitações HTTP adicionais.

E temos o prazer de informar que tudo isso se tornou possível no Voximplant, graças ao novo módulo VoxEngine , chamado - surpresa - WebSocket . A partir de agora, você poderá transferir texto e áudio, aproveitando ao máximo os soquetes da web. Simplificando, você tem outra ferramenta para atualizar seu aplicativo.

Neste artigo, você aprenderá como criar uma conexão WebSocket de saída, transferir um fluxo de áudio e convertê-lo em texto usando a API de fala para texto do Google Cloud .
Observe que o Voximplant possui funcionalidade incorporada para converter fala em texto em tempo real, sob o controle do módulo ASR . Este módulo utiliza funções do Google, Yandex e Tinkoff, veja detalhes aqui .

O artigo atual descreve o caso em que você deseja usar um serviço de terceiros para converter fala em texto e / ou gastar dinheiro com a conta dele, e não com a conta Voximplant.

Nosso módulo fornece dois formatos de trabalho:
  • criando uma conexão de saída;
  • recebendo uma conexão de entrada e criando um soquete da Web para ela.

Saída


A primeira coisa que você precisa fazer ao criar uma conexão de saída é executar o script VoxEngine. Em seguida, chame o método VoxEngine.createWebSocket , que criará o objeto WebSocket . Este método utiliza 2 parâmetros: URL no formato 'wss: // + domain + path' e protocolos (opcional). Aqui está como ficaria no código:

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

Se tudo funcionar, o método call.sendMediaTo enviará o fluxo de áudio ao soquete e o WebSocket.send , por sua vez, enviará o fluxo de áudio decodificado no formato JSON por ele. Como resultado, você receberá mensagens do serviço que processa as solicitações.

O método WebSocket.close é necessário para fechar a conexão. Observe que a conexão pode ser fechada no lado do cliente e no servidor.

Caixa de entrada


Para permitir conexões de entrada, você deve notificá-lo por meio do VoxEngine.allowWebSocketConnections e também assinar o evento AppEvents.WebSocket . Em seguida, será possível aceitar a conexão recebida e obter o objeto WebSocket: event.WebSocket. Veja o código abaixo:

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

Para criar um soquete da Web de entrada, você precisa do controle accessSecureURL. Pode ser obtido no evento AppEvents.Started ou na resposta à solicitação HTTP que iniciou a sessão. Observe que "https" deve ser alterado para 'wss' no URL.

As etapas restantes são idênticas às apresentadas no esquema de conexão de saída.

Você vai precisar


Para implementar a tecnologia WebSocket e o reconhecimento de fala em seu aplicativo, você precisará de:
  • Conta Voximplant. Se você não o possui, sinta-se à vontade para se registrar aqui ;
  • Aplicativo Voximplant, bem como um script, uma regra e um único usuário. Tudo isso será criado neste tutorial;
  • back-end simples (iniciaremos o servidor no node.js) com a biblioteca do cliente em nuvem conectada à API de fala para texto;
  • cliente da web para fazer uma ligação (usaremos o telefone da web em phone.voximplant.com ).

1. Configurações do VOXIMPLANT


Para começar, faça login na sua conta em manage.voximplant.com/auth . No menu à esquerda, clique em "Aplicativos", crie um novo e denomine websocket. Entre no seu aplicativo, alterne para a guia Scripts, crie um script e cole o seguinte código nele:

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

Esse script do VoxEngine envia um fluxo de áudio para o WebSocket e também rastreia seus eventos (ERRO, CLOSE, OPEN, MESSAGE). Podemos nos aprofundar nos detalhes do script um pouco mais tarde.

Agora, vamos para a guia "Roteamento", clique em "Nova regra" e chame-a de socketRule. Agora resta apenas selecionar seu script e deixar a máscara por padrão (. *).


A última coisa que você precisa fazer nesta fase é criar um usuário. Alterne para a guia "Usuários", clique em "Criar usuário", especifique um nome (por exemplo, socketUser) e uma senha e clique em "Criar". Vamos precisar desse par de nome de usuário / senha para autenticação no cliente da Web na última etapa.


A configuração está concluída, mas antes de começarmos a criar o servidor, vejamos como o módulo WebSocket funciona em nosso cenário.

2. Detalhes do script


O módulo WebSocket permite que os desenvolvedores abram uma conexão estável e enviem dados através dela. Para usar este módulo, devemos conectá-lo no início do script:

 require(Modules.WebSocket);

Por meio do método createWebSocket, determinamos a URL e os protocolos (opcional). Você pode aprender como obter o URL do WebSocket na próxima seção.

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

Depois de criar o objeto WebSocket, continuamos a gerenciar a chamada dentro do manipulador. Ou seja, enviamos a mídia para o objeto WebSocket usando o método call.sendMediaTo.

Aqui você pode definir o formato de codificação preferido, a tag e alguns parâmetros personalizados. Se você não definir a codificação, o PCM8 será usado por padrão.

Este método é chamado quando uma mensagem de conexão bem-sucedida é recebida . Em nosso cenário, o código de chamada é assim:

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

Todos os outros eventos WebSocket que você vê no código são para depuração; eles enviam informações para o log da sessão do Voximplant. Você pode removê-los se quiser.

Por fim, adicionamos o manipulador de conclusão de transferência de dados correto. No nosso caso, a sessão Voximplant encerrará seu trabalho 1 segundo após o término da chamada estabelecida ( Desconectada ):

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

Agora que a lógica do script está clara, é hora de passar para a próxima parte muito importante do nosso exemplo.

3. Back-end


Primeiro, verifique se o Node.js. está instalado no seu computador. Você pode baixá-lo no site principal do Node.js. Em seguida, execute os seguintes comandos na janela do terminal, um após o outro, para configurar o ambiente de trabalho:

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

E quando isso for feito, crie um arquivo JS vazio e coloque o seguinte código lá (as nuances do código serão destacadas abaixo):

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

Agora que o servidor está configurado, ele nos ajudará a realizar o reconhecimento de fala. Teste sua solução localmente, criando um túnel no localhost 3000 usando o ngrok.

Para fazer isso, execute as seguintes etapas:
  1. Instale o ngrok seguindo as instruções em seu site .
  2. Especifique seu authtoken para o ngrok vincular o cliente a esta conta.
  3. Execute o node your_file_name.js do node your_file_name.js para iniciar o servidor no localhost: 3000.
  4. Vá para a pasta ngrok no seu computador e execute o comando ./ngrok http 3000 para criar um túnel entre o servidor local em execução e a URL pública.

Preste atenção à URL pública gerada, nós a usamos como uma URL WebSocket com o prefixo 'wss' no script:



4. reconhecimento de fala


Você provavelmente percebeu que nosso código de back-end contém linhas relacionadas ao Google Cloud.

A própria biblioteca é importada da seguinte maneira:

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

Agora você precisa especificar como processar a solicitação de reconhecimento de fala. Para fazer isso, selecione codificação, sampleRateHertz e languageCode na configuração gerada:

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

Em seguida, crie um fluxo de gravação que permita salvar os dados transferidos em um arquivo:

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

Quando tudo estiver configurado, você precisará analisar a mensagem e colocar os dados de áudio no formato base64 em acceptStream:

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

Imediatamente após isso, uma solicitação de reconhecimento será iniciada e o processamento dessa solicitação começará:

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

Por fim, forneça as credenciais da sua conta de serviço para conectar a biblioteca do Google ao back-end. Para fazer isso, vá para a página de autenticação do Google e siga todas as etapas listadas lá. Em seguida, execute o comando export no mesmo espaço de trabalho (na mesma guia "Terminal") que o node your_file_name.js: do node your_file_name.js:

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

Soquetes de lançamento


Abra phone.voximplant.com , preencha o formulário e clique em Entrar. Nome de usuário e senha referem-se ao usuário criado na etapa 1:


Após a autorização bem-sucedida, clique em Ligar e comece a falar. A nuvem de conversão de texto em texto converterá sua fala em texto em tempo real, e você poderá vê-lo na janela do terminal.

Você conseguiu, parabéns! Esperamos que você tenha gostado do artigo e desejamos mais integração e novos desafios.

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

More articles:


All Articles