Ajouter une transcription en temps réel à votre application
Important
Les fonctionnalités décrites dans cet article sont actuellement en préversion publique. Cette préversion est fournie sans contrat de niveau de service et n’est pas recommandée pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.
Ce guide vous aide à mieux comprendre les différentes façons d’utiliser l’offre Azure Communication Services de transcription en temps réel via les SDK Call Automation.
Prérequis
- Compte Azure avec un abonnement actif. Pour plus d’informations, consultez Créez un compte gratuitement.
- Une ressource Azure Communication Services, consultez Créer une ressource Communication Services
- Créez et connectez les Azure AI services à votre ressource Azure Communication Services.
- Créez un sous-domaine personnalisé pour votre ressource Azure AI services.
- Créez une application de service web à l’aide du kit SDK d’automatisation des appels.
Configurer un serveur WebSocket
Azure Communication Services nécessite que votre application serveur configure un serveur WebSocket pour diffuser la transcription en temps réel. WebSocket est un protocole normalisé qui fournit un canal de communication en duplex intégral sur une seule connexion TCP. Vous pouvez éventuellement utiliser les services Azure WebApps qui vous permettent de créer une application pour recevoir des transcriptions sur une connexion WebSocket. Suivez ce guide de démarrage rapide.
Établir un appel
Dans ce guide de démarrage rapide, nous partons du principe que vous savez déjà démarrer des appels. Si vous avez besoin d’en savoir plus sur le démarrage et l’établissement d’appels, vous pouvez suivre notre guide de démarrage rapide. Pour les besoins de ce guide de démarrage rapide, nous allons suivre le processus de démarrage de la transcription pour les appels à la fois entrants et sortants.
Lorsque vous utilisez la transcription en temps réel, vous avez quelques options sur le moment et la façon de démarrer la transcription :
Option 1 : démarrage au moment de la prise d’appel ou de la création d’un appel
Option 2 : démarrage de la transcription pendant un appel en cours
Option 3 : Démarrage de la transcription lors de la connexion à un appel Azure Communication Services Rooms
Dans ce tutoriel, nous montrons les options 2 et 3, démarrant la transcription pendant un appel en cours ou lors de la connexion à un appel de salles. Par défaut, le paramètre startTranscription est défini sur false au moment de la prise d’appel ou de la création d’un appel.
Créer un appel et fournir les détails de la transcription
Définissez le paramètre TranscriptionOptions pour ACS pour spécifier quand démarrer la transcription, spécifier les paramètres régionaux de transcription et la connexion de socket web pour l’envoi de la transcription.
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);
Se connecter à un appel Rooms et fournir les détails de la transcription
Si vous vous connectez à une salle ACS et souhaitez utiliser la transcription, configurez les options de transcription comme suit :
var transcriptionOptions = new TranscriptionOptions(
transportUri: new Uri(""),
locale: "en-US",
startTranscription: false,
transcriptionTransport: TranscriptionTransport.Websocket
);
var connectCallOptions = new ConnectCallOptions(new RoomCallLocator("roomId"), callbackUri)
{
CallIntelligenceOptions = new CallIntelligenceOptions()
{
CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint)
},
TranscriptionOptions = transcriptionOptions
};
var connectResult = await client.ConnectCallAsync(connectCallOptions);
Démarrer la transcription
Une fois que vous êtes prêt à démarrer la transcription, vous pouvez effectuer un appel explicite à Call Automation pour démarrer la transcription de l’appel.
// Start transcription with options
StartTranscriptionOptions options = new StartTranscriptionOptions()
{
OperationContext = "startMediaStreamingContext",
//Locale = "en-US",
};
await callMedia.StartTranscriptionAsync(options);
// Alternative: Start transcription without options
// await callMedia.StartTranscriptionAsync();
Réception du flux de transcription
Au démarrage de la transcription, votre serveur websocket reçoit la charge utile des métadonnées de transcription en tant que premier paquet.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Réception des données de transcription
Après les métadonnées, les paquets suivants reçus par votre socket web contiennent TranscriptionData pour l’audio transcrit.
{
"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"
}
}
Gestion du flux de transcription dans le serveur de socket web
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();
Mises à jour de votre code pour le gestionnaire 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);
}
}
}
Mettre à jour une transcription
Dans les cas où votre application permet aux utilisateurs de sélectionner leur langue préférée, vous pouvez également capturer la transcription dans cette langue. Pour ce faire, le SDK Call Automation vous permet de mettre à jour les paramètres régionaux de transcription.
await callMedia.UpdateTranscriptionAsync("en-US-NancyNeural");
Arrêter la transcription
Lorsque votre application doit cesser d’écouter la transcription, vous pouvez utiliser la demande StopTranscription pour informer Call Automation d’arrêter l’envoi de données de transcription à votre socket web.
StopTranscriptionOptions stopOptions = new StopTranscriptionOptions()
{
OperationContext = "stopTranscription"
};
await callMedia.StopTranscriptionAsync(stopOptions);
Créer un appel et fournir les détails de la transcription
Définissez le paramètre TranscriptionOptions pour ACS pour spécifier quand démarrer la transcription, les paramètres régionaux de transcription et la connexion de socket web pour l’envoi de la transcription.
CallInvite callInvite = new CallInvite(target, caller);
CallIntelligenceOptions callIntelligenceOptions = new CallIntelligenceOptions()
.setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint());
TranscriptionOptions transcriptionOptions = new TranscriptionOptions(
appConfig.getWebSocketUrl(),
TranscriptionTransport.WEBSOCKET,
"en-US",
false
);
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();
Se connecter à un appel Rooms et fournir les détails de la transcription
Si vous vous connectez à une salle ACS et souhaitez utiliser la transcription, configurez les options de transcription comme suit :
TranscriptionOptions transcriptionOptions = new TranscriptionOptions(
appConfig.getWebSocketUrl(),
TranscriptionTransport.WEBSOCKET,
"en-US",
false
);
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();
Démarrer la transcription
Une fois que vous êtes prêt à démarrer la transcription, vous pouvez effectuer un appel explicite à Call Automation pour démarrer la transcription de l’appel.
//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();
Réception du flux de transcription
Au démarrage de la transcription, votre serveur websocket reçoit la charge utile des métadonnées de transcription en tant que premier paquet.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Réception des données de transcription
Après les métadonnées, les paquets suivants reçus par votre socket web contiennent TranscriptionData pour l’audio transcrit.
{
"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"
}
}
Gestion du flux de transcription dans le serveur de socket web
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();
}
}
}
Mises à jour de votre code pour le gestionnaire 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("----------------------------------------------------------------");
}
}
}
Mettre à jour une transcription
Dans les cas où votre application permet aux utilisateurs de sélectionner leur langue préférée, vous pouvez également capturer la transcription dans cette langue. Pour ce faire, le SDK Call Automation vous permet de mettre à jour les paramètres régionaux de transcription.
client.getCallConnection(callConnectionId)
.getCallMedia()
.updateTranscription("en-US-NancyNeural");
Arrêter la transcription
Lorsque votre application doit cesser d’écouter la transcription, vous pouvez utiliser la demande StopTranscription pour informer Call Automation d’arrêter l’envoi de données de transcription à votre 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();
Créer un appel et fournir les détails de la transcription
Définissez le paramètre TranscriptionOptions pour ACS pour spécifier quand démarrer la transcription, les paramètres régionaux de transcription et la connexion de socket web pour l’envoi de la transcription.
const transcriptionOptions = {
transportUrl: "",
transportType: "websocket",
locale: "en-US",
startTranscription: false
};
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);
Se connecter à un appel Rooms et fournir les détails de la transcription
Si vous vous connectez à une salle ACS et souhaitez utiliser la transcription, configurez les options de transcription comme suit :
const transcriptionOptions = {
transportUri: "",
locale: "en-US",
transcriptionTransport: "websocket",
startTranscription: false
};
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);
Démarrer la transcription
Une fois que vous êtes prêt à démarrer la transcription, vous pouvez effectuer un appel explicite à Call Automation pour démarrer la transcription de l’appel.
const startTranscriptionOptions = {
locale: "en-AU",
operationContext: "startTranscriptionContext"
};
// Start transcription with options
await callMedia.startTranscription(startTranscriptionOptions);
// Alternative: Start transcription without options
// await callMedia.startTranscription();
Réception du flux de transcription
Au démarrage de la transcription, votre serveur websocket reçoit la charge utile des métadonnées de transcription en tant que premier paquet.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Réception des données de transcription
Après les métadonnées, les paquets suivants reçus par votre socket web contiennent TranscriptionData pour l’audio transcrit.
{
"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"
}
}
Gestion du flux de transcription dans le serveur de socket web
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');
Mettre à jour une transcription
Dans les cas où votre application permet aux utilisateurs de sélectionner leur langue préférée, vous pouvez également capturer la transcription dans cette langue. Pour effectuer cette tâche, le Kit de développement logiciel (SDK) Call Automation vous permet de mettre à jour les paramètres régionaux de transcription.
await callMedia.updateTranscription("en-US-NancyNeural");
Arrêter la transcription
Lorsque votre application doit cesser d’écouter la transcription, vous pouvez utiliser la demande StopTranscription pour informer Call Automation d’arrêter l’envoi de données de transcription à votre socket web.
const stopTranscriptionOptions = {
operationContext: "stopTranscriptionContext"
};
// Stop transcription with options
await callMedia.stopTranscription(stopTranscriptionOptions);
// Alternative: Stop transcription without options
// await callMedia.stopTranscription();
Créer un appel et fournir les détails de la transcription
Définissez le paramètre TranscriptionOptions pour ACS pour spécifier quand démarrer la transcription, les paramètres régionaux de transcription et la connexion de socket web pour l’envoi de la transcription.
transcription_options = TranscriptionOptions(
transport_url=" ",
transport_type=TranscriptionTransportType.WEBSOCKET,
locale="en-US",
start_transcription=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,
transcription=transcription_options
)
Se connecter à un appel Rooms et fournir les détails de la transcription
Si vous vous connectez à une salle ACS et souhaitez utiliser la transcription, configurez les options de transcription comme suit :
transcription_options = TranscriptionOptions(
transport_url="",
transport_type=TranscriptionTransportType.WEBSOCKET,
locale="en-US",
start_transcription=False
)
connect_result = client.connect_call(
room_id="roomid",
CALLBACK_EVENTS_URI,
cognitive_services_endpoint=COGNITIVE_SERVICES_ENDPOINT,
operation_context="connectCallContext",
transcription=transcription_options
)
Démarrer la transcription
Une fois que vous êtes prêt à démarrer la transcription, vous pouvez effectuer un appel explicite à Call Automation pour démarrer la transcription de l’appel.
# 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")
Réception du flux de transcription
Au démarrage de la transcription, votre serveur websocket reçoit la charge utile des métadonnées de transcription en tant que premier paquet.
{
"kind": "TranscriptionMetadata",
"transcriptionMetadata": {
"subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
"locale": "en-us",
"callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
"correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
}
}
Réception des données de transcription
Après les métadonnées, les paquets suivants reçus par votre serveur WebSocket contiennent TranscriptionData pour l’audio transcrit.
{
"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"
}
}
Gestion du flux de transcription dans le serveur de socket web
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()
Mettre à jour une transcription
Dans les cas où votre application permet aux utilisateurs de sélectionner leur langue préférée, vous pouvez également capturer la transcription dans cette langue. Pour effectuer cette tâche, le Kit de développement logiciel (SDK) Call Automation vous permet de mettre à jour les paramètres régionaux de transcription.
await call_connection_client.update_transcription(locale="en-US-NancyNeural")
Arrêter la transcription
Lorsque votre application doit cesser d’écouter la transcription, vous pouvez utiliser la demande StopTranscription pour informer Call Automation d’arrêter l’envoi de données de transcription à votre 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")
Codes d’événement
| Événement | code | subcode | Message |
|---|---|---|---|
| TranscriptionStarted | 200 | 0 | Action réalisée avec succès. |
| TranscriptionStopped | 200 | 0 | Action réalisée avec succès. |
| TranscriptionUpdated | 200 | 0 | Action réalisée avec succès. |
| TranscriptionFailed | 400 | 8581 | Échec de l’action, StreamUrl n’est pas valide. |
| TrasncriptionFailed | 400 | 8565 | L’action a échoué en raison d’une demande incorrecte adressée à Cognitive Services. Vérifiez vos paramètres d’entrée. |
| TranscriptionFailed | 400 | 8565 | L’action a échoué en raison de l’expiration d’une demande adressée à Cognitive Services. Réessayez ultérieurement ou recherchez les problèmes liés au service. |
| TranscriptionFailed | 400 | 8605 | Le modèle de reconnaissance vocale personnalisée pour la transcription n’est pas pris en charge. |
| TranscriptionFailed | 400 | 8523 | Demande non valide, les paramètres régionaux sont manquants. |
| TranscriptionFailed | 400 | 8523 | Demande non valide, seuls les paramètres régionaux qui contiennent des informations de région sont pris en charge. |
| TranscriptionFailed | 405 | 8520 | La fonctionnalité de transcription n’est pas prise en charge pour l’instant. |
| TranscriptionFailed | 405 | 8520 | UpdateTranscription n’est pas pris en charge pour la connexion créée avec l’interface Connect. |
| TranscriptionFailed | 400 | 8528 | L’action n’est pas valide, l’appel est déjà terminé. |
| TranscriptionFailed | 405 | 8520 | La fonctionnalité de mise à jour de la transcription n’est pas prise en charge pour l’instant. |
| TranscriptionFailed | 405 | 8522 | Demande non autorisée lorsque l’URL de transcription n’est pas définie lors de la configuration de l’appel. |
| TranscriptionFailed | 405 | 8522 | Demande non autorisée lorsque la configuration de Cognitive Service n’est pas définie lors de la configuration de l’appel. |
| TranscriptionFailed | 400 | 8501 | L’action n’est pas valide lorsque l’appel n’est pas dans l’état Établi. |
| TranscriptionFailed | 401 | 8565 | L’action a échoué en raison d’une erreur d’authentification à Cognitive Services. Vérifiez votre entrée d’autorisation et vérifiez qu’elle est correcte. |
| TranscriptionFailed | 403 | 8565 | L’action a échoué en raison d’une demande interdite à Cognitive Services. Vérifiez l’état de votre abonnement et vérifiez qu’il est actif. |
| TranscriptionFailed | 429 | 8565 | L’action a échoué, le nombre de demandes a dépassé le nombre de demandes simultanées autorisées pour l’abonnement Cognitive Services. |
| TranscriptionFailed | 500 | 8578 | L’action a échoué, impossible d’établir la connexion WebSocket. |
| TranscriptionFailed | 500 | 8580 | L’action a échoué, le service de transcription a été arrêté. |
| TranscriptionFailed | 500 | 8579 | L’action a échoué, la transcription a été annulée. |
| TranscriptionFailed | 500 | 9999 | Erreur interne du serveur inconnue. |
Problèmes connus
- Pour les appels 1:1 avec les utilisateurs ACS utilisant les SDK client, startTranscription = True n’est actuellement pas pris en charge.