Inicio rápido: Streaming de audio del lado servidor

Importante

La funcionalidad descrita en este artículo se encuentra actualmente en versión preliminar pública. Esta versión preliminar se ofrece sin un Acuerdo de Nivel de Servicio y no se recomienda para cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas. Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

Introducción al uso de secuencias de audio a través de la API de Streaming de audio de Azure Communication Services. En este inicio rápido se da por supuesto que ya está familiarizado con las API de Automatización de llamadas para crear una solución de enrutamiento de llamadas automatizada.

La funcionalidad que se describe en este inicio rápido se encuentra actualmente en versión preliminar pública.

Requisitos previos

• Una cuenta de Azure con una suscripción activa: consulte Crear una cuenta gratuita.
• Un recurso de Azure Communication Services. Consulte Creación de un recurso de Azure Communication Services.
• Una nueva aplicación de servicio web creada con el SDK de automatización de llamadas.
• La biblioteca de .NET más reciente para el sistema operativo.
• Un servidor websocket que puede recibir secuencias multimedia.

Configuración de un servidor websocket

Azure Communication Services requiere que la aplicación de servidor configure un servidor WebSocket para transmitir audio en tiempo real. WebSocket es un protocolo estandarizado que proporciona un canal de comunicación dúplex completo a través de una única conexión TCP. Opcionalmente, puede usar los servicios de Azure WebApps que le permiten crear una aplicación para recibir secuencias de audio a través de una conexión de websocket. Siga este inicio rápido.

Establecimiento de una llamada

Establecer una llamada y proporcionar detalles de streaming

MediaStreamingOptions mediaStreamingOptions = new MediaStreamingOptions( 
    new Uri("<WEBSOCKET URL>"), 
    MediaStreamingContent.Audio, 
    MediaStreamingAudioChannel.Mixed, 
    MediaStreamingTransport.Websocket, 
    false); 

 var createCallOptions = new CreateCallOptions(callInvite, callbackUri) 
 { 
     CallIntelligenceOptions = new CallIntelligenceOptions() { CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint) }, 
     MediaStreamingOptions = mediaStreamingOptions, 
 }; 

 CreateCallResult createCallResult = await callAutomationClient.CreateCallAsync(createCallOptions); 

Iniciar streaming de audio

Cómo iniciar el streaming de audio:

StartMediaStreamingOptions options = new StartMediaStreamingOptions() 
    { 
        OperationCallbackUri = new Uri(callbackUriHost), 
        OperationContext = "startMediaStreamingContext" 
    };
    await callMedia.StartMediaStreamingAsync(options); 

Cuando Azure Communication Services recibe la dirección URL del servidor WebSocket, crea una conexión a él. Una vez que Azure Communication Services se conecta correctamente al servidor de WebSocket y se inicia el streaming, se enviará a través del primer paquete de datos que contiene metadatos sobre los paquetes multimedia entrantes.

El paquete de metadatos tendrá este aspecto:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
} 

Detener el streaming de audio

Cómo detener el streaming de audio

StopMediaStreamingOptions stopOptions = new StopMediaStreamingOptions() 
    { 
        OperationCallbackUri = new Uri(callbackUriHost) 
    }; 
    await callMedia.StopMediaStreamingAsync(stopOptions); 

Control de secuencias de audio en el servidor de websocket

En el ejemplo siguiente se muestra cómo escuchar secuencias de audio mediante el servidor de websocket.

HttpListener httpListener = new HttpListener(); 
httpListener.Prefixes.Add("http://localhost:80/"); 
httpListener.Start(); 

while (true) 
{ 
    HttpListenerContext httpListenerContext = await httpListener.GetContextAsync(); 
    if (httpListenerContext.Request.IsWebSocketRequest) 
    { 
        WebSocketContext websocketContext; 
        try 
        { 
            websocketContext = await httpListenerContext.AcceptWebSocketAsync(subProtocol: null); 
        } 
        catch (Exception ex) 
        { 
            return; 
        } 
        WebSocket webSocket = websocketContext.WebSocket; 
        try 
        { 
            while (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.CloseSent) 
            { 
                byte[] receiveBuffer = new byte[2048]; 
                var cancellationToken = new CancellationTokenSource(TimeSpan.FromSeconds(60)).Token; 
                WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), cancellationToken); 
                if (receiveResult.MessageType != WebSocketMessageType.Close) 
                { 
                    var data = Encoding.UTF8.GetString(receiveBuffer).TrimEnd('\0'); 
                    try 
                    { 
                        var eventData = JsonConvert.DeserializeObject<AudioBaseClass>(data); 
                        if (eventData != null) 
                        { 
                            if(eventData.kind == "AudioMetadata") 
                            { 
                                //Process audio metadata 
                            } 
                            else if(eventData.kind == "AudioData")  
                            { 
                                //Process audio data 
                                var byteArray = eventData.audioData.data; 
                               //use audio byteArray as you want 
                            } 
                        } 
                    } 
                    catch { } 
                } 
            } 
        } 
        catch (Exception ex) { } 
    } 
} 

Requisitos previos

• Cuenta de Azure con una suscripción activa: consulte Crear una cuenta gratuita.
• Un recurso de Azure Communication Services. Consulte Creación de un recurso de Azure Communication Services.
• Una nueva aplicación de servicio web creada con el SDK de automatización de llamadas.
• Kit de desarrollo de Java, versión 8 o posterior.
• Apache Maven.

Configuración de un servidor websocket

Azure Communication Services requiere que la aplicación de servidor configure un servidor WebSocket para transmitir audio en tiempo real. WebSocket es un protocolo estandarizado que proporciona un canal de comunicación dúplex completo a través de una única conexión TCP. Opcionalmente, puede usar los servicios de Azure WebApps que le permiten crear una aplicación para recibir secuencias de audio a través de una conexión de websocket. Siga este inicio rápido.

Establecimiento de una llamada

Establecer una llamada y proporcionar detalles de streaming

CallInvite callInvite = new CallInvite(target, caller);  
              
            CallIntelligenceOptions callIntelligenceOptions = new CallIntelligenceOptions().setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint());  
            MediaStreamingOptions mediaStreamingOptions = new MediaStreamingOptions(appConfig.getWebSocketUrl(), MediaStreamingTransport.WEBSOCKET, MediaStreamingContentType.AUDIO, MediaStreamingAudioChannel.UNMIXED);  
            mediaStreamingOptions.setStartMediaStreaming(false);  
          
            CreateCallOptions createCallOptions = new CreateCallOptions(callInvite, appConfig.getCallBackUri());  
            createCallOptions.setCallIntelligenceOptions(callIntelligenceOptions);  
            createCallOptions.setMediaStreamingOptions(mediaStreamingOptions);  
  
            Response<CreateCallResult> result = client.createCallWithResponse(createCallOptions, Context.NONE);  
            return result.getValue().getCallConnectionProperties().getCallConnectionId();  

Iniciar streaming de audio

Cómo iniciar el streaming de audio:

StartMediaStreamingOptions startOptions = new StartMediaStreamingOptions()  
                                                        .setOperationContext("startMediaStreamingContext")  
                                                        .setOperationCallbackUrl(appConfig.getBasecallbackuri());  
         client.getCallConnection(callConnectionId)  
                     .getCallMedia()  
                     .startMediaStreamingWithResponse(startOptions, Context.NONE);      

Cuando Azure Communication Services recibe la dirección URL del servidor WebSocket, crea una conexión a él. Una vez que Azure Communication Services se conecta correctamente al servidor de WebSocket y se inicia el streaming, se enviará a través del primer paquete de datos que contiene metadatos sobre los paquetes multimedia entrantes.

El paquete de metadatos tendrá este aspecto:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
} 

Detener el streaming de audio

Cómo detener el streaming de audio

StopMediaStreamingOptions stopOptions = new StopMediaStreamingOptions()  
                                                        .setOperationCallbackUrl(appConfig.getBasecallbackuri());  
         client.getCallConnection(callConnectionId)  
                     .getCallMedia()  
                     .stopMediaStreamingWithResponse(stopOptions, Context.NONE);

Control de flujos multimedia en el servidor de websocket

En el ejemplo siguiente se muestra cómo escuchar la secuencia multimedia mediante el servidor de websocket. Habrá dos archivos que deben ejecutarse: App.java y WebSocketServer.java

package com.example;

import org.glassfish.tyrus.server.Server;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class App {
    public static void main(String[] args) {

        Server server = new Server("localhost", 8081, "/ws", null, WebSocketServer.class);

        try {
            server.start();
            System.out.println("Web socket running on port 8081...");
            System.out.println("wss://localhost:8081/ws/server");
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            reader.readLine();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            server.stop();
        }
    }
}

package com.example;

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

import com.azure.communication.callautomation.models.streaming.StreamingData;
import com.azure.communication.callautomation.models.streaming.StreamingDataParser;
import com.azure.communication.callautomation.models.streaming.media.AudioData;
import com.azure.communication.callautomation.models.streaming.media.AudioMetadata;

@ServerEndpoint("/server")
public class WebSocketServer {
    @OnMessage
    public void onMessage(String message, Session session) {

        // System.out.println("Received message: " + message);

        StreamingData data = StreamingDataParser.parse(message);

        if (data instanceof AudioMetadata) {
            AudioMetadata audioMetaData = (AudioMetadata) data;
            System.out.println("----------------------------------------------------------------");
            System.out.println("SUBSCRIPTION ID:-->" + audioMetaData.getMediaSubscriptionId());
            System.out.println("ENCODING:-->" + audioMetaData.getEncoding());
            System.out.println("SAMPLE RATE:-->" + audioMetaData.getSampleRate());
            System.out.println("CHANNELS:-->" + audioMetaData.getChannels());
            System.out.println("LENGTH:-->" + audioMetaData.getLength());
            System.out.println("----------------------------------------------------------------");
        }
        if (data instanceof AudioData) {
            System.out.println("----------------------------------------------------------------");
            AudioData audioData = (AudioData) data;
            System.out.println("DATA:-->" + audioData.getData());
            System.out.println("TIMESTAMP:-->" + audioData.getTimestamp());
            // System.out.println("PARTICIPANT:-->" + audioData.getParticipant().getRawId()
            // != null
            // ? audioData.getParticipant().getRawId()
            // : "");
            System.out.println("IS SILENT:-->" + audioData.isSilent());
            System.out.println("----------------------------------------------------------------");
        }
    }
}

Requisitos previos

• Cuenta de Azure con una suscripción activa: consulte Crear una cuenta gratuita.
• Un recurso de Azure Communication Services. Consulte Creación de un recurso de Azure Communication Services.
• Una nueva aplicación de servicio web creada con el SDK de automatización de llamadas.
• Instalación de LTS de Node.js
• Un servidor websocket que puede recibir secuencias multimedia.

Configuración de un servidor websocket

Azure Communication Services requiere que la aplicación de servidor configure un servidor WebSocket para transmitir audio en tiempo real. WebSocket es un protocolo estandarizado que proporciona un canal de comunicación dúplex completo a través de una única conexión TCP. Opcionalmente, puede usar los servicios de Azure WebApps que le permiten crear una aplicación para recibir secuencias de audio a través de una conexión de websocket. Siga este inicio rápido.

Establecimiento de una llamada

Establecer una llamada y proporcionar detalles de streaming

const mediaStreamingOptions: MediaStreamingOptions = { 
          transportUrl: "<WEBSOCKET URL>", 
          transportType: "websocket", 
          contentType: "audio", 
          audioChannelType: "unmixed", 
          startMediaStreaming: false 
} 
const options: CreateCallOptions = { 
          callIntelligenceOptions: { cognitiveServicesEndpoint: process.env.COGNITIVE_SERVICES_ENDPOINT }, 
          mediaStreamingOptions: mediaStreamingOptions 
}; 

Iniciar streaming de audio

Cómo iniciar el streaming de audio:

const streamingOptions: StartMediaStreamingOptions = { 
        operationContext: "startMediaStreamingContext", 
        operationCallbackUrl: process.env.CALLBACK_URI + "/api/callbacks" 
    } 
await callMedia.startMediaStreaming(streamingOptions); 

Cuando Azure Communication Services recibe la dirección URL del servidor WebSocket, crea una conexión a él. Una vez que Azure Communication Services se conecta correctamente al servidor de WebSocket y se inicia el streaming, se enviará a través del primer paquete de datos que contiene metadatos sobre los paquetes multimedia entrantes.

El paquete de metadatos tendrá este aspecto:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
} 

Detener el streaming de audio

Cómo detener el streaming de audio

const stopMediaStreamingOptions: StopMediaStreamingOptions = { 
        operationCallbackUrl: process.env.CALLBACK_URI + "/api/callbacks" 
        } 
await callMedia.stopMediaStreaming(stopMediaStreamingOptions); 

Control de secuencias de audio en el servidor de websocket

En el ejemplo siguiente se muestra cómo escuchar secuencias de audio mediante el servidor de websocket.

import WebSocket from 'ws'; 
import { streamingData } from '@azure/communication-call-automation/src/utli/streamingDataParser' 
const wss = new WebSocket.Server({ port: 8081 }); 

wss.on('connection', (ws: WebSocket) => { 
    console.log('Client connected'); 
    ws.on('message', (packetData: ArrayBuffer) => { 
        const decoder = new TextDecoder(); 
        const stringJson = decoder.decode(packetData); 
        console.log("STRING JSON=>--" + stringJson) 

        //var response = streamingData(stringJson); 

        var response = streamingData(packetData); 
        if ('locale' in response) { 
            console.log("Transcription Metadata") 
            console.log(response.callConnectionId); 
            console.log(response.correlationId); 
            console.log(response.locale); 
            console.log(response.subscriptionId); 
        } 
        if ('text' in response) { 
            console.log("Transcription Data") 
            console.log(response.text); 
            console.log(response.format); 
            console.log(response.confidence); 
            console.log(response.offset); 
            console.log(response.duration); 
            console.log(response.resultStatus); 
            if ('phoneNumber' in response.participant) { 
                console.log(response.participant.phoneNumber); 
            } 
            response.words.forEach(element => { 
                console.log(element.text) 
                console.log(element.duration) 
                console.log(element.offset) 
            }); 
        } 
    }); 

    ws.on('close', () => { 
        console.log('Client disconnected'); 
    }); 
}); 

// function processData(data: ArrayBuffer) { 
//  const byteArray = new Uint8Array(data); 
// } 

console.log('WebSocket server running on port 8081'); 

Requisitos previos

• Cuenta de Azure con una suscripción activa: consulte Crear una cuenta gratuita.
• Un recurso de Azure Communication Services. Consulte Creación de un recurso de Azure Communication Services.
• Una nueva aplicación de servicio web creada con el SDK de automatización de llamadas.
• Versión 3.7 o superiores de Python.
• Un servidor websocket que puede recibir secuencias multimedia.

Configuración de un servidor websocket

Azure Communication Services requiere que la aplicación de servidor configure un servidor WebSocket para transmitir audio en tiempo real. WebSocket es un protocolo estandarizado que proporciona un canal de comunicación dúplex completo a través de una única conexión TCP. Opcionalmente, puede usar los servicios de Azure WebApps que le permiten crear una aplicación para recibir secuencias de audio a través de una conexión de websocket. Siga este inicio rápido.

Establecimiento de una llamada

Establecer una llamada y proporcionar detalles de streaming

media_streaming_options = MediaStreamingOptions( 
         transport_url="wss://e063-2409-40c2-4004-eced-9487-4dfb-b0e4-10fb.ngrok-free.app", 
         transport_type=MediaStreamingTransportType.WEBSOCKET, 
         content_type=MediaStreamingContentType.AUDIO, 
         audio_channel_type=MediaStreamingAudioChannelType.UNMIXED, 
         start_media_streaming=False 
         ) 

call_connection_properties = call_automation_client.create_call(target_participant,  
                                                                    CALLBACK_EVENTS_URI, 
                                                                    cognitive_services_endpoint=COGNITIVE_SERVICES_ENDPOINT, 
                                                                    source_caller_id_number=source_caller, 
                                                                    media_streaming=media_streaming_options
) 

Iniciar streaming de audio

Cómo iniciar el streaming de audio:

call_connection_client.start_media_streaming() 

Cuando Azure Communication Services recibe la dirección URL del servidor WebSocket, crea una conexión a él. Una vez que Azure Communication Services se conecta correctamente al servidor de WebSocket y se inicia el streaming, se enviará a través del primer paquete de datos que contiene metadatos sobre los paquetes multimedia entrantes.

El paquete de metadatos tendrá este aspecto:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
} 

Detener el streaming de audio

Cómo detener el streaming de audio

call_connection_client.stop_media_streaming() 

Control de secuencias de audio en el servidor de websocket

En el ejemplo siguiente se muestra cómo escuchar secuencias de audio mediante el servidor de websocket.

import asyncio 
import json 
import websockets 

async def handle_client(websocket, path): 
    print("Client connected") 
    try: 
        async for message in websocket: 
            print(message) 
            packet_data = json.loads(message) 
            packet_data = message.encode('utf-8') 
            print("Packet DATA:-->",packet_data) 

    except websockets.exceptions.ConnectionClosedOK: 
        print("Client disconnected") 

start_server = websockets.serve(handle_client, "localhost", 8081) 

print('WebSocket server running on port 8081') 

asyncio.get_event_loop().run_until_complete(start_server) 
asyncio.get_event_loop().run_forever() 

Esquema de streaming de audio

Después de enviar el paquete de metadatos, Azure Communication Services comenzará a transmitir contenido multimedia de audio al servidor de WebSocket. A continuación se muestra un ejemplo del aspecto del objeto multimedia que recibirá el servidor.

{
    "kind": <string>, // What kind of data this is, e.g. AudioMetadata, AudioData.
    "audioData":{
        "data": <string>, // Base64 Encoded audio buffer data
        "timestamp": <string>, // In ISO 8601 format (yyyy-mm-ddThh:mm:ssZ) 
        "participantRawID": <string>, 
        "silent": <boolean> // Indicates if the received audio buffer contains only silence.
    }
}

Limpieza de recursos

Si quiere limpiar y quitar una suscripción a Communication Services, puede eliminar el recurso o grupo de recursos. Al eliminar el grupo de recursos, también se elimina cualquier otro recurso que esté asociado a él. Obtenga más información sobre la limpieza de recursos.

Pasos siguientes

• Más información sobre Streaming de audio.
• Más información sobre la automatización de llamadas y sus características.
• Más información sobre la acción de reproducción.
• Obtenga más información sobre la acción Reconocer.