Delen via

Realtime transcriptie toevoegen aan uw toepassing

  • Artikel

Belangrijk

De functionaliteit die in dit artikel wordt beschreven, is momenteel beschikbaar als openbare preview. Deze preview-versie wordt geleverd zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.

Deze handleiding helpt u beter inzicht te krijgen in de verschillende manieren waarop u Azure Communication Services-aanbiedingen van realtimetranscriptie kunt gebruiken via Call Automation SDK's.

Vereisten

Een WebSocket-server instellen

Voor Azure Communication Services moet uw servertoepassing een WebSocket-server instellen om transcriptie in realtime te streamen. WebSocket is een gestandaardiseerd protocol dat een full-duplex communicatiekanaal biedt via één TCP-verbinding. U kunt eventueel Azure-services Azure WebApps gebruiken waarmee u een toepassing kunt maken voor het ontvangen van transcripties via een websocket-verbinding. Volg deze quickstart.

Een oproep tot stand brengen

In deze quickstart gaan we ervan uit dat u al bekend bent met het starten van oproepen. Als u meer wilt weten over het starten en tot stand brengen van gesprekken, kunt u onze quickstart volgen. Voor deze quickstart doorlopen we het proces van het starten van transcriptie voor zowel binnenkomende oproepen als uitgaande oproepen.

Wanneer u met realtime transcriptie werkt, hebt u een aantal opties voor wanneer en hoe u transcriptie start:

Optie 1: te beginnen bij het beantwoorden of maken van een oproep

Optie 2: transcriptie starten tijdens een doorlopend gesprek

In deze zelfstudie demonstreren we optie 2, waarbij transcriptie wordt gestart tijdens een doorlopend gesprek. Standaard is de 'startTranscription' ingesteld op false op het moment van beantwoorden of maken van een aanroep.

Een oproep maken en de transcriptiegegevens opgeven

Definieer de TranscriptionOptions voor ACS om te weten of de transcriptie direct moet worden gestart of op een later tijdstip, welke landinstelling moet worden getranscribeerd en de websocketverbinding die moet worden gebruikt voor het verzenden van de transcriptie.

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

Transcriptie starten

Zodra u klaar bent om de transcriptie te starten, kunt u een expliciete aanroep naar Gespreksautomatisering maken om te beginnen met het transcriberen van de oproep.

// 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();

Transcriptiestroom ontvangen

Wanneer transcriptie wordt gestart, ontvangt uw websocket de nettolading van de transcriptiemetagegevens als het eerste pakket. Deze nettolading bevat de metagegevens van de aanroep en landinstellingen voor de configuratie.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Transcriptiegegevens ontvangen

Na de metagegevens die de volgende pakketten ontvangen die uw websocket ontvangt, wordt TranscriptionData voor de getranscribeerde audio.

{
    "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"
    }
}

Transcriptiestroom verwerken in de websocketserver

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

Updates voor uw code voor de websocket-handler

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

Transcriptie bijwerken

In situaties waarin gebruikers in uw toepassing hun voorkeurstaal kunnen selecteren, kunt u ook de transcriptie in die taal vastleggen. Hiervoor kunt u de landinstelling voor transcriptie bijwerken met de Automation-SDK.

await callMedia.UpdateTranscriptionAsync("en-US-NancyNeural");

Transcriptie stoppen

Wanneer uw toepassing moet stoppen met luisteren naar de transcriptie, kunt u de StopTranscription-aanvraag gebruiken om Call Automation te laten weten dat ze geen transcriptiegegevens meer naar uw websocket verzenden.

StopTranscriptionOptions stopOptions = new StopTranscriptionOptions()
{
    OperationContext = "stopTranscription"
};

await callMedia.StopTranscriptionAsync(stopOptions);

Een oproep maken en de transcriptiegegevens opgeven

Definieer de TranscriptionOptions voor ACS om te weten of de transcriptie direct moet worden gestart of op een later tijdstip, welke landinstelling moet worden getranscribeerd en de websocketverbinding die moet worden gebruikt voor het verzenden van de transcriptie.

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

Transcriptie starten

Zodra u klaar bent om de transcriptie te starten, kunt u een expliciete aanroep naar Gespreksautomatisering maken om te beginnen met het transcriberen van de oproep.

//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();

Transcriptiestroom ontvangen

Wanneer transcriptie wordt gestart, ontvangt uw websocket de nettolading van de transcriptiemetagegevens als het eerste pakket. Deze nettolading bevat de metagegevens van de aanroep en landinstellingen voor de configuratie.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Transcriptiegegevens ontvangen

Na de metagegevens die de volgende pakketten ontvangen die uw websocket ontvangt, wordt TranscriptionData voor de getranscribeerde audio.

{
    "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"
    }
}

Transcriptiestroom verwerken in de websocketserver

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

Updates voor uw code voor de websocket-handler

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

Transcriptie bijwerken

In situaties waarin gebruikers in uw toepassing hun voorkeurstaal kunnen selecteren, kunt u ook de transcriptie in die taal vastleggen. Hiervoor kunt u de landinstelling voor transcriptie bijwerken met de Automation-SDK.

client.getCallConnection(callConnectionId)
    .getCallMedia()
    .updateTranscription("en-US-NancyNeural");

Transcriptie stoppen

Wanneer uw toepassing moet stoppen met luisteren naar de transcriptie, kunt u de StopTranscription-aanvraag gebruiken om Call Automation te laten weten dat ze geen transcriptiegegevens meer naar uw websocket verzenden.

// 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();

Een oproep maken en de transcriptiegegevens opgeven

Definieer de TranscriptionOptions voor ACS om te weten of de transcriptie direct moet worden gestart of op een later tijdstip, welke landinstelling moet worden getranscribeerd en de websocketverbinding die moet worden gebruikt voor het verzenden van de transcriptie.

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

Transcriptie starten

Zodra u klaar bent om de transcriptie te starten, kunt u een expliciete aanroep naar Gespreksautomatisering maken om te beginnen met het transcriberen van de oproep.

const startTranscriptionOptions = {
    locale: "en-AU",
    operationContext: "startTranscriptionContext"
};

// Start transcription with options
await callMedia.startTranscription(startTranscriptionOptions);

// Alternative: Start transcription without options
// await callMedia.startTranscription();

Transcriptiestroom ontvangen

Wanneer transcriptie wordt gestart, ontvangt uw websocket de nettolading van de transcriptiemetagegevens als het eerste pakket. Deze nettolading bevat de metagegevens van de aanroep en landinstellingen voor de configuratie.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Transcriptiegegevens ontvangen

Na de metagegevens zijn de volgende pakketten die uw websocket ontvangt TranscriptionData voor de getranscribeerde audio.

{
    "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"
    }
}

Transcriptiestroom verwerken in de websocketserver

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

Transcriptie bijwerken

In situaties waarin gebruikers in uw toepassing hun voorkeurstaal kunnen selecteren, kunt u ook de transcriptie in die taal vastleggen. Hiervoor kunt u met de Call Automation SDK de transcriptielocatie bijwerken.

await callMedia.updateTranscription("en-US-NancyNeural");

Transcriptie stoppen

Wanneer uw toepassing moet stoppen met luisteren naar de transcriptie, kunt u de StopTranscription-aanvraag gebruiken om Call Automation te laten weten dat ze geen transcriptiegegevens meer naar uw websocket verzenden.

const stopTranscriptionOptions = {
    operationContext: "stopTranscriptionContext"
};

// Stop transcription with options
await callMedia.stopTranscription(stopTranscriptionOptions);

// Alternative: Stop transcription without options
// await callMedia.stopTranscription();

Een oproep maken en de transcriptiegegevens opgeven

Definieer de TranscriptionOptions voor ACS om te weten of de transcriptie direct moet worden gestart of op een later tijdstip, welke landinstelling moet worden getranscribeerd en de websocketverbinding die moet worden gebruikt voor het verzenden van de transcriptie.

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
)

Transcriptie starten

Zodra u klaar bent om de transcriptie te starten, kunt u een expliciete aanroep naar Gespreksautomatisering maken om te beginnen met het transcriberen van de oproep.

# 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")

Transcriptiestroom ontvangen

Wanneer transcriptie wordt gestart, ontvangt uw websocket de nettolading van de transcriptiemetagegevens als het eerste pakket. Deze nettolading bevat de metagegevens van de aanroep en landinstellingen voor de configuratie.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Transcriptiegegevens ontvangen

Na de metagegevens worden de volgende pakketten die uw websocket ontvangt, TranscriptionData voor de getranscribeerde audio.

{
    "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"
    }
}

Transcriptiestroom verwerken in de websocketserver

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()

Transcriptie bijwerken

In situaties waarin gebruikers in uw toepassing hun voorkeurstaal kunnen selecteren, kunt u ook de transcriptie in die taal vastleggen. Hiervoor kunt u met de Call Automation SDK de transcriptielocatie bijwerken.

await call_connection_client.update_transcription(locale="en-US-NancyNeural")

Transcriptie stoppen

Wanneer uw toepassing moet stoppen met luisteren naar de transcriptie, kunt u de StopTranscription-aanvraag gebruiken om Call Automation te laten weten dat ze geen transcriptiegegevens meer naar uw websocket verzenden.

# Stop transcription without options
call_connection_client.stop_transcription()

# Alternative: Stop transcription with operation context
# call_connection_client.stop_transcription(operation_context="stopTranscriptionContext")

Gebeurteniscodes

Gebeurtenis code subcode Bericht
Transcriptiestart 200 0 De actie is voltooid.
TranscriptieStopped 200 0 De actie is voltooid.
TranscriptionUpdated 200 0 De actie is voltooid.
TranscriptieFailed 400 8581 De actie is mislukt, StreamUrl is niet geldig.
TrasncriptionFailed 400 8565 De actie is mislukt vanwege een ongeldige aanvraag voor Cognitive Services. Controleer de invoerparameters.
TranscriptieFailed 400 8565 De actie is mislukt vanwege een time-out van een aanvraag voor Cognitive Services. Probeer het later opnieuw of controleer op eventuele problemen met de service.
TranscriptieFailed 400 8605 Aangepast spraakherkenningsmodel voor transcriptie wordt niet ondersteund.
TranscriptieFailed 400 8523 Ongeldige aanvraag, landinstelling ontbreekt.
TranscriptieFailed 400 8523 Ongeldige aanvraag, alleen landinstellingen die regiogegevens bevatten, worden ondersteund.
TranscriptieFailed 405 8520 Transcriptiefunctionaliteit wordt momenteel niet ondersteund.
TranscriptieFailed 405 8520 UpdateTranscription wordt niet ondersteund voor verbinding die is gemaakt met de Connect-interface.
TranscriptieFailed 400 8528 Actie is ongeldig, oproep is al beëindigd.
TranscriptieFailed 405 8520 De functionaliteit voor het bijwerken van transcriptie wordt momenteel niet ondersteund.
TranscriptieFailed 405 8522 Aanvraag is niet toegestaan wanneer transcriptie-URL niet is ingesteld tijdens het instellen van oproepen.
TranscriptieFailed 405 8522 Aanvraag is niet toegestaan wanneer Cognitive Service-configuratie niet is ingesteld tijdens het instellen van oproepen.
TranscriptieFailed 400 8501 De actie is ongeldig wanneer de aanroep niet de status Ingesteld heeft.
TranscriptieFailed 401 8565 De actie is mislukt vanwege een Cognitive Services-verificatiefout. Controleer uw autorisatie-invoer en controleer of deze juist is.
TranscriptieFailed 403 8565 De actie is mislukt vanwege een verboden aanvraag voor Cognitive Services. Controleer de status van uw abonnement en controleer of het actief is.
TranscriptieFailed 429 8565 Actie is mislukt, aanvragen hebben het aantal toegestane gelijktijdige aanvragen voor het cognitive services-abonnement overschreden.
TranscriptieFailed 500 8578 De actie is mislukt, kan geen WebSocket-verbinding tot stand brengen.
TranscriptieFailed 500 8580 De actie is mislukt, de transcriptieservice is afgesloten.
TranscriptieFailed 500 8579 Actie is mislukt, transcriptie is geannuleerd.
TranscriptieFailed 500 9999 Onbekende interne serverfout.

Bekende problemen

  • Voor 1:1-aanroepen met ACS-gebruikers met client-SDK's startTranscription = True wordt momenteel niet ondersteund.