Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Esta guía le ayuda a comprender mejor las distintas formas en que puede utilizar la oferta de Azure Communication Services de transcripción en tiempo real a través de los SDK de automatización de llamadas.
Requisitos previos
- Cuenta de Azure con una suscripción activa: consulte Crear una cuenta gratuita.
- Recurso Azure Communication Services, consulte Crear un recurso Azure Communication Services
- Crea y conecta los servicios de Azure AI al recurso de Azure Communication Services.
- Crea un subdominio personalizado para el recurso de servicios de Azure AI.
- Cree una nueva aplicación de servicio web mediante el SDK de automatización de llamadas.
Configuración de un servidor WebSocket
Azure Communication Services requiere que su aplicación de servidor configure un servidor WebSocket para transmitir la transcripción 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 utilizar los servicios Azure WebApps de Azure que le permite crear una aplicación para recibir transcripciones a través de una conexión websocket. Siga este inicio rápido.
Establecimiento de una llamada
En esta guía rápida, asumimos que ya está familiarizado con el inicio de llamadas. Si necesita más información sobre cómo iniciar y establecer llamadas, puede seguir nuestro inicio rápido. En esta guía rápida, vamos a iniciar la transcripción tanto de las llamadas entrantes como de las salientes.
Al trabajar con la transcripción en tiempo real, tiene varias opciones sobre cuándo y cómo empezar a transcribir:
Opción 1: a partir del momento en que se responde o se crea una llamada
Opción 2: iniciar la transcripción durante una llamada en curso
Opción 3: inicio de la transcripción al conectarse a una llamada de Azure Communication Services Rooms
En este tutorial, vamos a demostrar las opciones 2 y 3, iniciando la transcripción durante una llamada en curso o al conectarse a una llamada de Salas. De forma predeterminada, "startTranscription" se establece en falso en el momento de responder o crear una llamada.
Cree una convocatoria y proporcione los datos de transcripción
Defina las TranscriptionOptions para que ACS especifique cuándo iniciar la transcripción, especifique la configuración regional para la transcripción y la conexión de socket web para enviar la transcripción.
var createCallOptions = new CreateCallOptions(callInvite, callbackUri)
{
CallIntelligenceOptions = new CallIntelligenceOptions() { CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint) },
TranscriptionOptions = new TranscriptionOptions(new Uri(""), "en-US", false, TranscriptionTransport.Websocket)
};
CreateCallResult createCallResult = await callAutomationClient.CreateCallAsync(createCallOptions);
Conectarse a una llamada de Salas y proporcionar detalles de la transcripción
Si se conecta a una sala ACS y desea utilizar la transcripción, configure las opciones de transcripción como se indica a continuación:
var transcriptionOptions = new TranscriptionOptions(
transportUri: new Uri(""),
locale: "en-US",
startTranscription: false,
transcriptionTransport: TranscriptionTransport.Websocket,
//Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
SpeechRecognitionModelEndpointId = "YourCustomSpeechRecognitionModelEndpointId"
);
var connectCallOptions = new ConnectCallOptions(new RoomCallLocator("roomId"), callbackUri)
{
CallIntelligenceOptions = new CallIntelligenceOptions()
{
CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint)
},
TranscriptionOptions = transcriptionOptions
};
var connectResult = await client.ConnectCallAsync(connectCallOptions);
Iniciar transcripción
Una vez que esté listo para iniciar la transcripción, puede realizar una llamada explícita a Automatización de llamadas para comenzar a transcribir la llamada.
// Start transcription with options
StartTranscriptionOptions options = new StartTranscriptionOptions()
{
OperationContext = "startMediaStreamingContext",
//Locale = "en-US",
//Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
SpeechRecognitionModelEndpointId = "YourCustomSpeechRecognitionModelEndpointId"
};
await callMedia.StartTranscriptionAsync(options);
// Alternative: Start transcription without options
// await callMedia.StartTranscriptionAsync();
Encabezados adicionales:
El identificador de correlación y el identificador de conexión de llamada ahora se incluyen en los encabezados de WebSocket para mejorar la rastreabilidad x-ms-call-correlation-id y x-ms-call-connection-id.
Recepción del flujo de transcripciones
Cuando se inicia la transcripción, su websocket recibe la carga útil de metadatos de transcripción como primer paquete.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Recepción de datos de transcripción
Luego de los metadatos, los siguientes paquetes que recibirá su web socket serán TranscriptionData para el audio transcrito.
{
"kind": "TranscriptionData",
"transcriptionData": {
"text": "Testing transcription.",
"format": "display",
"confidence": 0.695223331451416,
"offset": 2516998782481234400,
"words": [
{
"text": "testing",
"offset": 2516998782481234400
},
{
"text": "testing",
"offset": 2516998782481234400
}
],
"participantRawID": "8:acs:",
"resultStatus": "Final"
}
}
Manejo del flujo de transcripción en el servidor web socket
using WebServerApi;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
app.UseWebSockets();
app.Map("/ws", async context =>
{
if (context.WebSockets.IsWebSocketRequest)
{
using var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await HandleWebSocket.Echo(webSocket);
}
else
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
}
});
app.Run();
Actualice su código para el controlador de websocket
using Azure.Communication.CallAutomation;
using System.Net.WebSockets;
using System.Text;
namespace WebServerApi
{
public class HandleWebSocket
{
public static async Task Echo(WebSocket webSocket)
{
var buffer = new byte[1024 * 4];
var receiveResult = await webSocket.ReceiveAsync(
new ArraySegment(buffer), CancellationToken.None);
while (!receiveResult.CloseStatus.HasValue)
{
string msg = Encoding.UTF8.GetString(buffer, 0, receiveResult.Count);
var response = StreamingDataParser.Parse(msg);
if (response != null)
{
if (response is AudioMetadata audioMetadata)
{
Console.WriteLine("***************************************************************************************");
Console.WriteLine("MEDIA SUBSCRIPTION ID-->"+audioMetadata.MediaSubscriptionId);
Console.WriteLine("ENCODING-->"+audioMetadata.Encoding);
Console.WriteLine("SAMPLE RATE-->"+audioMetadata.SampleRate);
Console.WriteLine("CHANNELS-->"+audioMetadata.Channels);
Console.WriteLine("LENGTH-->"+audioMetadata.Length);
Console.WriteLine("***************************************************************************************");
}
if (response is AudioData audioData)
{
Console.WriteLine("***************************************************************************************");
Console.WriteLine("DATA-->"+audioData.Data);
Console.WriteLine("TIMESTAMP-->"+audioData.Timestamp);
Console.WriteLine("IS SILENT-->"+audioData.IsSilent);
Console.WriteLine("***************************************************************************************");
}
if (response is TranscriptionMetadata transcriptionMetadata)
{
Console.WriteLine("***************************************************************************************");
Console.WriteLine("TRANSCRIPTION SUBSCRIPTION ID-->"+transcriptionMetadata.TranscriptionSubscriptionId);
Console.WriteLine("LOCALE-->"+transcriptionMetadata.Locale);
Console.WriteLine("CALL CONNECTION ID--?"+transcriptionMetadata.CallConnectionId);
Console.WriteLine("CORRELATION ID-->"+transcriptionMetadata.CorrelationId);
Console.WriteLine("***************************************************************************************");
}
if (response is TranscriptionData transcriptionData)
{
Console.WriteLine("***************************************************************************************");
Console.WriteLine("TEXT-->"+transcriptionData.Text);
Console.WriteLine("FORMAT-->"+transcriptionData.Format);
Console.WriteLine("OFFSET-->"+transcriptionData.Offset);
Console.WriteLine("DURATION-->"+transcriptionData.Duration);
Console.WriteLine("PARTICIPANT-->"+transcriptionData.Participant.RawId);
Console.WriteLine("CONFIDENCE-->"+transcriptionData.Confidence);
foreach (var word in transcriptionData.Words)
{
Console.WriteLine("TEXT-->"+word.Text);
Console.WriteLine("OFFSET-->"+word.Offset);
Console.WriteLine("DURATION-->"+word.Duration);
}
Console.WriteLine("***************************************************************************************");
}
}
await webSocket.SendAsync(
new ArraySegment(buffer, 0, receiveResult.Count),
receiveResult.MessageType,
receiveResult.EndOfMessage,
CancellationToken.None);
receiveResult = await webSocket.ReceiveAsync(
new ArraySegment(buffer), CancellationToken.None);
}
await webSocket.CloseAsync(
receiveResult.CloseStatus.Value,
receiveResult.CloseStatusDescription,
CancellationToken.None);
}
}
}
Actualizar transcripción
En situaciones en las que su aplicación permite a los usuarios seleccionar su idioma preferido, es posible que también desee capturar la transcripción en ese idioma. Para ello, Call Automation SDK le permite actualizar la configuración regional de transcripción.
UpdateTranscriptionOptions updateTranscriptionOptions = new UpdateTranscriptionOptions(locale)
{
OperationContext = "UpdateTranscriptionContext",
//Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
SpeechRecognitionModelEndpointId = "YourCustomSpeechRecognitionModelEndpointId"
};
await client.GetCallConnection(callConnectionId).GetCallMedia().UpdateTranscriptionAsync(updateTranscriptionOptions);
Detener la transcripción
Cuando su aplicación necesite dejar de escuchar la transcripción, puede utilizar la petición StopTranscription para indicar a Call Automation que deje de enviar datos de transcripción a su socket web.
StopTranscriptionOptions stopOptions = new StopTranscriptionOptions()
{
OperationContext = "stopTranscription"
};
await callMedia.StopTranscriptionAsync(stopOptions);
Cree una convocatoria y proporcione los datos de transcripción
Defina las TranscriptionOptions para que ACS especifique cuándo iniciar la transcripción, la configuración regional para la transcripción y la conexión de socket web para enviar la transcripción.
CallInvite callInvite = new CallInvite(target, caller);
CallIntelligenceOptions callIntelligenceOptions = new CallIntelligenceOptions()
.setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint());
TranscriptionOptions transcriptionOptions = new TranscriptionOptions(
appConfig.getWebSocketUrl(),
TranscriptionTransport.WEBSOCKET,
"en-US",
false,
"your-endpoint-id-here" // speechRecognitionEndpointId
);
CreateCallOptions createCallOptions = new CreateCallOptions(callInvite, appConfig.getCallBackUri());
createCallOptions.setCallIntelligenceOptions(callIntelligenceOptions);
createCallOptions.setTranscriptionOptions(transcriptionOptions);
Response result = client.createCallWithResponse(createCallOptions, Context.NONE);
return result.getValue().getCallConnectionProperties().getCallConnectionId();
Conectarse a una llamada de Salas y proporcionar detalles de la transcripción
Si se conecta a una sala ACS y desea utilizar la transcripción, configure las opciones de transcripción como se indica a continuación:
TranscriptionOptions transcriptionOptions = new TranscriptionOptions(
appConfig.getWebSocketUrl(),
TranscriptionTransport.WEBSOCKET,
"en-US",
false,
"your-endpoint-id-here" // speechRecognitionEndpointId
);
ConnectCallOptions connectCallOptions = new ConnectCallOptions(new RoomCallLocator("roomId"), appConfig.getCallBackUri())
.setCallIntelligenceOptions(
new CallIntelligenceOptions()
.setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint())
)
.setTranscriptionOptions(transcriptionOptions);
ConnectCallResult connectCallResult = Objects.requireNonNull(client
.connectCallWithResponse(connectCallOptions)
.block())
.getValue();
Iniciar transcripción
Una vez que esté listo para iniciar la transcripción, puede realizar una llamada explícita a Automatización de llamadas para comenzar a transcribir la llamada.
//Option 1: Start transcription with options
StartTranscriptionOptions transcriptionOptions = new StartTranscriptionOptions()
.setOperationContext("startMediaStreamingContext");
client.getCallConnection(callConnectionId)
.getCallMedia()
.startTranscriptionWithResponse(transcriptionOptions, Context.NONE);
// Alternative: Start transcription without options
// client.getCallConnection(callConnectionId)
// .getCallMedia()
// .startTranscription();
Encabezados adicionales:
El identificador de correlación y el identificador de conexión de llamada ahora se incluyen en los encabezados de WebSocket para mejorar la rastreabilidad x-ms-call-correlation-id y x-ms-call-connection-id.
Recepción del flujo de transcripciones
Cuando se inicia la transcripción, su websocket recibe la carga útil de metadatos de transcripción como primer paquete.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Recepción de datos de transcripción
Luego de los metadatos, los siguientes paquetes que recibirá su web socket serán TranscriptionData para el audio transcrito.
{
"kind": "TranscriptionData",
"transcriptionData": {
"text": "Testing transcription.",
"format": "display",
"confidence": 0.695223331451416,
"offset": 2516998782481234400,
"words": [
{
"text": "testing",
"offset": 2516998782481234400
},
{
"text": "testing",
"offset": 2516998782481234400
}
],
"participantRawID": "8:acs:",
"resultStatus": "Final"
}
}
Manejo del flujo de transcripción en el servidor web socket
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();
}
}
}
Actualice su código para el controlador de websocket
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;
import com.azure.communication.callautomation.models.streaming.transcription.TranscriptionData;
import com.azure.communication.callautomation.models.streaming.transcription.TranscriptionMetadata;
import com.azure.communication.callautomation.models.streaming.transcription.Word;
@ServerEndpoint("/server")
public class WebSocketServer {
@OnMessage
public void onMessage(String message, Session session) {
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) {
AudioData audioData = (AudioData) data;
System.out.println("----------------------------------------------------------------");
System.out.println("DATA: --> " + audioData.getData());
System.out.println("TIMESTAMP: --> " + audioData.getTimestamp());
System.out.println("IS SILENT: --> " + audioData.isSilent());
System.out.println("----------------------------------------------------------------");
}
if (data instanceof TranscriptionMetadata) {
TranscriptionMetadata transcriptionMetadata = (TranscriptionMetadata) data;
System.out.println("----------------------------------------------------------------");
System.out.println("TRANSCRIPTION SUBSCRIPTION ID: --> " + transcriptionMetadata.getTranscriptionSubscriptionId());
System.out.println("IS SILENT: --> " + transcriptionMetadata.getLocale());
System.out.println("CALL CONNECTION ID: --> " + transcriptionMetadata.getCallConnectionId());
System.out.println("CORRELATION ID: --> " + transcriptionMetadata.getCorrelationId());
System.out.println("----------------------------------------------------------------");
}
if (data instanceof TranscriptionData) {
TranscriptionData transcriptionData = (TranscriptionData) data;
System.out.println("----------------------------------------------------------------");
System.out.println("TEXT: --> " + transcriptionData.getText());
System.out.println("FORMAT: --> " + transcriptionData.getFormat());
System.out.println("CONFIDENCE: --> " + transcriptionData.getConfidence());
System.out.println("OFFSET: --> " + transcriptionData.getOffset());
System.out.println("DURATION: --> " + transcriptionData.getDuration());
System.out.println("RESULT STATUS: --> " + transcriptionData.getResultStatus());
for (Word word : transcriptionData.getWords()) {
System.out.println("Text: --> " + word.getText());
System.out.println("Offset: --> " + word.getOffset());
System.out.println("Duration: --> " + word.getDuration());
}
System.out.println("----------------------------------------------------------------");
}
}
}
Actualizar transcripción
En situaciones en las que su aplicación permite a los usuarios seleccionar su idioma preferido, es posible que también desee capturar la transcripción en ese idioma. Para ello, Call Automation SDK le permite actualizar la configuración regional de transcripción.
UpdateTranscriptionOptions transcriptionOptions = new UpdateTranscriptionOptions()
.setLocale(newLocale)
.setOperationContext("transcriptionContext")
.setSpeechRecognitionEndpointId("your-endpoint-id-here");
client.getCallConnection(callConnectionId)
.getCallMedia()
.updateTranscriptionWithResponse(transcriptionOptions, Context.NONE);
Detener la transcripción
Cuando su aplicación necesite dejar de escuchar la transcripción, puede utilizar la petición StopTranscription para indicar a Call Automation que deje de enviar datos de transcripción a su socket web.
// Option 1: Stop transcription with options
StopTranscriptionOptions stopTranscriptionOptions = new StopTranscriptionOptions()
.setOperationContext("stopTranscription");
client.getCallConnection(callConnectionId)
.getCallMedia()
.stopTranscriptionWithResponse(stopTranscriptionOptions, Context.NONE);
// Alternative: Stop transcription without options
// client.getCallConnection(callConnectionId)
// .getCallMedia()
// .stopTranscription();
Cree una convocatoria y proporcione los datos de transcripción
Defina las TranscriptionOptions para que ACS especifique cuándo iniciar la transcripción, la configuración regional para la transcripción y la conexión de socket web para enviar la transcripción.
const transcriptionOptions = {
transportUrl: "",
transportType: "websocket",
locale: "en-US",
startTranscription: false,
speechRecognitionModelEndpointId: "YOUR_CUSTOM_SPEECH_RECOGNITION_MODEL_ID"
};
const options = {
callIntelligenceOptions: {
cognitiveServicesEndpoint: process.env.COGNITIVE_SERVICES_ENDPOINT
},
transcriptionOptions: transcriptionOptions
};
console.log("Placing outbound call...");
acsClient.createCall(callInvite, process.env.CALLBACK_URI + "/api/callbacks", options);
Conectarse a una llamada de Salas y proporcionar detalles de la transcripción
Si se conecta a una sala ACS y desea utilizar la transcripción, configure las opciones de transcripción como se indica a continuación:
const transcriptionOptions = {
transportUri: "",
locale: "en-US",
transcriptionTransport: "websocket",
startTranscription: false,
speechRecognitionModelEndpointId: "YOUR_CUSTOM_SPEECH_RECOGNITION_MODEL_ID"
};
const callIntelligenceOptions = {
cognitiveServicesEndpoint: process.env.COGNITIVE_SERVICES_ENDPOINT
};
const connectCallOptions = {
callIntelligenceOptions: callIntelligenceOptions,
transcriptionOptions: transcriptionOptions
};
const callLocator = {
id: roomId,
kind: "roomCallLocator"
};
const connectResult = await client.connectCall(callLocator, callBackUri, connectCallOptions);
Iniciar transcripción
Una vez que esté listo para iniciar la transcripción, puede realizar una llamada explícita a Automatización de llamadas para comenzar a transcribir la llamada.
const startTranscriptionOptions = {
locale: "en-AU",
operationContext: "startTranscriptionContext"
};
// Start transcription with options
await callMedia.startTranscription(startTranscriptionOptions);
// Alternative: Start transcription without options
// await callMedia.startTranscription();
Encabezados adicionales:
El identificador de correlación y el identificador de conexión de llamada ahora se incluyen en los encabezados de WebSocket para mejorar la rastreabilidad x-ms-call-correlation-id y x-ms-call-connection-id.
Recepción del flujo de transcripciones
Cuando se inicia la transcripción, su websocket recibe la carga útil de metadatos de transcripción como primer paquete.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Recepción de datos de transcripción
Luego de los metadatos, los siguientes paquetes que recibirá su web socket serán TranscriptionData para el audio transcrito.
{
"kind": "TranscriptionData",
"transcriptionData": {
"text": "Testing transcription.",
"format": "display",
"confidence": 0.695223331451416,
"offset": 2516998782481234400,
"words": [
{
"text": "testing",
"offset": 2516998782481234400
},
{
"text": "testing",
"offset": 2516998782481234400
}
],
"participantRawID": "8:acs:",
"resultStatus": "Final"
}
}
Manejo del flujo de transcripción en el servidor web socket
import WebSocket from 'ws';
import { streamingData } from '@azure/communication-call-automation/src/util/streamingDataParser';
const wss = new WebSocket.Server({ port: 8081 });
wss.on('connection', (ws) => {
console.log('Client connected');
ws.on('message', (packetData) => {
const decoder = new TextDecoder();
const stringJson = decoder.decode(packetData);
console.log("STRING JSON => " + stringJson);
const 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((word) => {
console.log(word.text);
console.log(word.duration);
console.log(word.offset);
});
}
});
ws.on('close', () => {
console.log('Client disconnected');
});
});
console.log('WebSocket server running on port 8081');
Actualizar transcripción
En situaciones en las que su aplicación permite a los usuarios seleccionar su idioma preferido, es posible que también desee capturar la transcripción en ese idioma. Para realizar esta tarea, el SDK de automatización de llamadas le permite actualizar la configuración regional de transcripción.
async function updateTranscriptionAsync() {
const options: UpdateTranscriptionOptions = {
operationContext: "updateTranscriptionContext",
speechRecognitionModelEndpointId: "YOUR_CUSTOM_SPEECH_RECOGNITION_MODEL_ID"
};
await acsClient
.getCallConnection(callConnectionId)
.getCallMedia()
.updateTranscription("en-au", options);
}
Detener la transcripción
Cuando su aplicación necesite dejar de escuchar la transcripción, puede utilizar la petición StopTranscription para indicar a Call Automation que deje de enviar datos de transcripción a su socket web.
const stopTranscriptionOptions = {
operationContext: "stopTranscriptionContext"
};
// Stop transcription with options
await callMedia.stopTranscription(stopTranscriptionOptions);
// Alternative: Stop transcription without options
// await callMedia.stopTranscription();
Cree una convocatoria y proporcione los datos de transcripción
Defina las TranscriptionOptions para que ACS especifique cuándo iniciar la transcripción, la configuración regional para la transcripción y la conexión de socket web para enviar la transcripción.
transcription_options = TranscriptionOptions(
transport_url="WEBSOCKET_URI_HOST",
transport_type=TranscriptionTransportType.WEBSOCKET,
locale="en-US",
start_transcription=False,
#Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
speech_recognition_model_endpoint_id = "YourCustomSpeechRecognitionModelEndpointId"
);
)
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,
transcription=transcription_options
)
Conectarse a una llamada de Salas y proporcionar detalles de la transcripción
Si se conecta a una sala ACS y desea utilizar la transcripción, configure las opciones de transcripción como se indica a continuación:
transcription_options = TranscriptionOptions(
transport_url="",
transport_type=TranscriptionTransportType.WEBSOCKET,
locale="en-US",
start_transcription=False,
#Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
speech_recognition_model_endpoint_id = "YourCustomSpeechRecognitionModelEndpointId"
)
connect_result = client.connect_call(
room_id="roomid",
CALLBACK_EVENTS_URI,
cognitive_services_endpoint=COGNITIVE_SERVICES_ENDPOINT,
operation_context="connectCallContext",
transcription=transcription_options
)
Iniciar transcripción
Una vez que esté listo para iniciar la transcripción, puede realizar una llamada explícita a Automatización de llamadas para comenzar a transcribir la llamada.
# Start transcription without options
call_connection_client.start_transcription()
# Option 1: Start transcription with locale and operation context
# call_connection_client.start_transcription(locale="en-AU", operation_context="startTranscriptionContext")
# Option 2: Start transcription with operation context
# call_connection_client.start_transcription(operation_context="startTranscriptionContext")
Encabezados adicionales:
El identificador de correlación y el identificador de conexión de llamada ahora se incluyen en los encabezados de WebSocket para mejorar la rastreabilidad x-ms-call-correlation-id y x-ms-call-connection-id.
Recepción del flujo de transcripciones
Cuando se inicia la transcripción, su websocket recibe la carga útil de metadatos de transcripción como primer paquete.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Recepción de datos de transcripción
Después de los metadatos, los siguientes paquetes que recibirá su websocket serán TranscriptionData para el audio transcrito.
{
"kind": "TranscriptionData",
"transcriptionData": {
"text": "Testing transcription.",
"format": "display",
"confidence": 0.695223331451416,
"offset": 2516998782481234400,
"words": [
{
"text": "testing",
"offset": 2516998782481234400
},
{
"text": "testing",
"offset": 2516998782481234400
}
],
"participantRawID": "8:acs:",
"resultStatus": "Final"
}
}
Manejo del flujo de transcripción en el servidor web socket
import asyncio
import json
import websockets
from azure.communication.callautomation._shared.models import identifier_from_raw_id
async def handle_client(websocket, path):
print("Client connected")
try:
async for message in websocket:
json_object = json.loads(message)
kind = json_object['kind']
if kind == 'TranscriptionMetadata':
print("Transcription metadata")
print("-------------------------")
print("Subscription ID:", json_object['transcriptionMetadata']['subscriptionId'])
print("Locale:", json_object['transcriptionMetadata']['locale'])
print("Call Connection ID:", json_object['transcriptionMetadata']['callConnectionId'])
print("Correlation ID:", json_object['transcriptionMetadata']['correlationId'])
if kind == 'TranscriptionData':
participant = identifier_from_raw_id(json_object['transcriptionData']['participantRawID'])
word_data_list = json_object['transcriptionData']['words']
print("Transcription data")
print("-------------------------")
print("Text:", json_object['transcriptionData']['text'])
print("Format:", json_object['transcriptionData']['format'])
print("Confidence:", json_object['transcriptionData']['confidence'])
print("Offset:", json_object['transcriptionData']['offset'])
print("Duration:", json_object['transcriptionData']['duration'])
print("Participant:", participant.raw_id)
print("Result Status:", json_object['transcriptionData']['resultStatus'])
for word in word_data_list:
print("Word:", word['text'])
print("Offset:", word['offset'])
print("Duration:", word['duration'])
except websockets.exceptions.ConnectionClosedOK:
print("Client disconnected")
except websockets.exceptions.ConnectionClosedError as e:
print("Connection closed with error: %s", e)
except Exception as e:
print("Unexpected error: %s", e)
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()
Actualizar transcripción
En situaciones en las que su aplicación permite a los usuarios seleccionar su idioma preferido, es posible que también desee capturar la transcripción en ese idioma. Para realizar esta tarea, el SDK de automatización de llamadas le permite actualizar la configuración regional de transcripción.
await call_automation_client.get_call_connection(
call_connection_id=call_connection_id
).update_transcription(
operation_context="UpdateTranscriptionContext",
locale="en-au",
#Only add the SpeechRecognitionModelEndpointId if you have a custom speech model you would like to use
speech_recognition_model_endpoint_id = "YourCustomSpeechRecognitionModelEndpointId"
)
Detener la transcripción
Cuando su aplicación necesite dejar de escuchar la transcripción, puede utilizar la petición StopTranscription para indicar a Call Automation que deje de enviar datos de transcripción a su socket web.
# Stop transcription without options
call_connection_client.stop_transcription()
# Alternative: Stop transcription with operation context
# call_connection_client.stop_transcription(operation_context="stopTranscriptionContext")
Códigos de evento
| Evento | código | subcódigo | Mensaje |
|---|---|---|---|
| TranscripciónIniciado | 200 | 0 | La acción se ha completado correctamente. |
| Transcripción detenida | 200 | 0 | La acción se ha completado correctamente. |
| TranscriptionUpdated | 200 | 0 | La acción se ha completado correctamente. |
| TranscriptionFailed | 400 | 8581 | Acción fallida, StreamUrl no es válido. |
| TranscriptionFailed | 400 | 8565 | Acción fallida debido a una mala solicitud a Cognitive Services. Compruebe los parámetros de entrada. |
| TranscriptionFailed | 400 | 8565 | La acción falló debido a que se agotó el tiempo de espera de la solicitud a los Cognitive Services. Vuelva a intentarlo más tarde o compruebe si hay algún problema con el servicio. |
| TranscriptionFailed | 400 | 8605 | No se admite el modelo de reconocimiento de voz personalizado para la transcripción. |
| TranscriptionFailed | 400 | 8523 | Solicitud no válida, falta la configuración regional. |
| TranscriptionFailed | 400 | 8523 | Solicitud no válida, solo se admiten las configuraciones locales que contienen información sobre la región. |
| TranscriptionFailed | 405 | 8520 | La función de transcripción no está disponible en este momento. |
| TranscriptionFailed | 405 | 8520 | UpdateTranscription no es compatible con la conexión creada con la interfaz Connect. |
| TranscriptionFailed | 400 | 8528 | La acción no es válida, la llamada ya ha finalizado. |
| TranscriptionFailed | 405 | 8520 | La funcionalidad de actualización de transcripciones no está disponible en este momento. |
| TranscriptionFailed | 405 | 8522 | Solicitud no permitida cuando la URL de transcripción no está configurada durante la configuración de la llamada. |
| TranscriptionFailed | 405 | 8522 | Solicitud no permitida cuando la Configuración del Cognitive Service no se ha establecido durante el establecimiento de la llamada. |
| TranscriptionFailed | 400 | 8501 | La acción no es válida cuando la llamada no está en estado Establecido. |
| TranscriptionFailed | 401 | 8565 | La acción ha fallado debido a un error de autenticación de Cognitive Services. Compruebe la entrada de autorización y asegúrese de que es correcta. |
| TranscriptionFailed | 403 | 8565 | La acción falló debido a una solicitud prohibida a Cognitive Services. Compruebe el estado de su suscripción y asegúrese de que está activa. |
| TranscriptionFailed | 429 | 8565 | Acción fallida, las peticiones excedieron el número de peticiones concurrentes permitidas para la suscripción de servicios cognitivos. |
| TranscriptionFailed | 500 | 8578 | Acción fallida, no se ha podido establecer la conexión WebSocket. |
| TranscriptionFailed | 500 | 8580 | Acción fallida, el servicio de transcripción se cerró. |
| TranscriptionFailed | 500 | 8579 | La acción falló, la transcripción fue cancelada. |
| TranscriptionFailed | 500 | 9999 | Error interno desconocido del servidor. |
Problemas conocidos
- Para llamadas 1:1 con usuarios de ACS que utilicen SDKs de cliente, startTranscription = True no está soportado actualmente.