Freigeben über

Hinzufügen einer Echtzeittranskription zu Ihrer Anwendung

  • Artikel

Wichtig

Die in diesem Artikel beschriebenen Funktionen befinden sich derzeit in der öffentlichen Vorschauphase. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und ist nicht für Produktionsworkloads vorgesehen. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

Dieser Leitfaden hilft Ihnen, die verschiedenen Möglichkeiten zu verstehen, wie Sie Azure Communication Services-Angebote für Echtzeittranskription über Anrufautomatisierungs-SDKs verwenden können.

Voraussetzungen

Einrichten eines WebSocket-Servers

Azure Communication Services erfordert die Einrichtung eines WebSocket-Servers für Ihre Serveranwendung, um das Streamen der Transkription in Echtzeit zu ermöglichen. WebSocket ist ein standardisiertes Protokoll, das einen Vollduplex-Kommunikationskanal über eine einzelne TCP-Verbindung bereitstellt. Sie können optional Azure-Web-Apps von Azure-Diensten verwenden, um eine Anwendung zu erstellen, die Transkripte über eine WebSocket-Verbindung empfängt. Eine entsprechende Schnellstartanleitung finden Sie hier.

Einrichten eines Anrufs

In diesem Schnellstart wird davon ausgegangen, dass Sie bereits mit dem Initiieren von Anrufen vertraut sind. Weitere Informationen zum Initiieren und Einrichten von Anrufen finden Sie in unserer Schnellstartanleitung. Im Rahmen dieser Schnellstartanleitung wird das Starten der Transkription sowohl für eingehende als auch für ausgehende Anrufe durchlaufen.

Beim Arbeiten mit Echtzeittranskription haben Sie eine Reihe von Optionen, wann und wie Sie mit der Transkription beginnen:

Option 1: Ab dem Zeitpunkt der Beantwortung oder Erstellung eines Anrufs

Option 2: Starten der Transkription während eines laufenden Anrufs

In diesem Tutorial zeigen wir Option 2, die Transkription während eines laufenden Anrufs zu starten. Standardmäßig ist „startTranscription“ zum Zeitpunkt der Beantwortung oder Erstellung eines Anrufs auf „FALSCH“ festgelegt.

Erstellen eines Anrufs und Bereitstellen der Transkriptionsdetails

Definieren Sie die TranscriptionOptions für ACS, um zu wissen, ob die Transkription sofort oder zu einem späteren Zeitpunkt gestartet werden soll, welches Gebietsschema transkribiert werden soll, und welche Websocketverbindung zum Senden des Transkripts verwendet werden soll.

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

Transkription starten

Sobald Sie bereit sind, die Transkription zu starten, können Sie einen expliziten Anruf an die Anrufautomatisierung tätigen, um das Transkribieren des Anrufs zu starten.

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

Transkriptionsstream empfangen

Wenn die Transkription gestartet wird, empfängt Ihr Websocket die Transkriptionsmetadaten-Nutzdaten als erstes Paket. Diese Nutzdaten enthalten die Aufrufmetadaten und das Gebietsschema für die Konfiguration.

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

Transkriptionsdaten empfangen

Nach den Metadaten erhält Ihr Websocket als nächstes Pakete mit TranscriptionData für die transkribierte Audiodaten.

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

Transkriptionsdatenstream im Websocketserver verarbeiten

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

Aktualisierungen des Codes für den 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);
        }
    }
}

Transkription aktualisieren

In Situationen, in denen Ihre Anwendung es Benutzer*innen ermöglicht, ihre bevorzugte Sprache auszuwählen, können Sie auch die Transkription in dieser Sprache erfassen. Dazu können Sie mit dem Anrufautomatisierungs-SDK das Transkriptionsgebietsschema aktualisieren.

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

Transkription beenden

Wenn Ihre Anwendung das Zuhören für die Transkription beenden muss, können Sie die StopTranscription-Anforderung verwenden, um die Anrufautomatisierung zu informieren und das Senden von Transkriptdaten an Ihren Websocket zu beenden.

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

await callMedia.StopTranscriptionAsync(stopOptions);

Erstellen eines Anrufs und Bereitstellen der Transkriptionsdetails

Definieren Sie die TranscriptionOptions für ACS, um zu wissen, ob die Transkription sofort oder zu einem späteren Zeitpunkt gestartet werden soll, welches Gebietsschema transkribiert werden soll, und welche Websocketverbindung zum Senden des Transkripts verwendet werden soll.

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

Transkription starten

Sobald Sie bereit sind, die Transkription zu starten, können Sie einen expliziten Anruf an die Anrufautomatisierung tätigen, um das Transkribieren des Anrufs zu starten.

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

Transkriptionsstream empfangen

Wenn die Transkription gestartet wird, empfängt Ihr Websocket die Transkriptionsmetadaten-Nutzdaten als erstes Paket. Diese Nutzdaten enthalten die Aufrufmetadaten und das Gebietsschema für die Konfiguration.

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

Transkriptionsdaten empfangen

Nach den Metadaten erhält Ihr Websocket als nächstes Pakete mit TranscriptionData für die transkribierte Audiodaten.

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

Transkriptionsdatenstream im Websocketserver verarbeiten

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

Aktualisierungen des Codes für den 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("----------------------------------------------------------------");
        }
    }
}

Transkription aktualisieren

In Situationen, in denen Ihre Anwendung es Benutzer*innen ermöglicht, ihre bevorzugte Sprache auszuwählen, können Sie auch die Transkription in dieser Sprache erfassen. Dazu können Sie mit dem Anrufautomatisierungs-SDK das Transkriptionsgebietsschema aktualisieren.

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

Transkription beenden

Wenn Ihre Anwendung das Zuhören für die Transkription beenden muss, können Sie die StopTranscription-Anforderung verwenden, um die Anrufautomatisierung zu informieren und das Senden von Transkriptdaten an Ihren Websocket zu beenden.

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

Erstellen eines Anrufs und Bereitstellen der Transkriptionsdetails

Definieren Sie die TranscriptionOptions für ACS, um zu wissen, ob die Transkription sofort oder zu einem späteren Zeitpunkt gestartet werden soll, welches Gebietsschema transkribiert werden soll, und welche Websocketverbindung zum Senden des Transkripts verwendet werden soll.

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

Transkription starten

Sobald Sie bereit sind, die Transkription zu starten, können Sie einen expliziten Anruf an die Anrufautomatisierung tätigen, um das Transkribieren des Anrufs zu starten.

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

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

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

Transkriptionsstream empfangen

Wenn die Transkription gestartet wird, empfängt Ihr Websocket die Transkriptionsmetadaten-Nutzdaten als erstes Paket. Diese Nutzdaten enthalten die Aufrufmetadaten und das Gebietsschema für die Konfiguration.

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

Transkriptionsdaten empfangen

Nach den Metadaten erhält Ihr Websocket als nächstes Pakete mit TranskriptionData für die transkribierte Audiodaten.

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

Transkriptionsdatenstream im Websocketserver verarbeiten

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

Transkription aktualisieren

In Situationen, in denen Ihre Anwendung es Benutzer*innen ermöglicht, ihre bevorzugte Sprache auszuwählen, können Sie auch die Transkription in dieser Sprache erfassen. Dazu können Sie mit dem Anrufautomatisierungs-SDK das Transkriptionsgebietsschema aktualisieren.

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

Transkription beenden

Wenn Ihre Anwendung das Zuhören für die Transkription beenden muss, können Sie die StopTranscription-Anforderung verwenden, um die Anrufautomatisierung zu informieren und das Senden von Transkriptdaten an Ihren Websocket zu beenden.

const stopTranscriptionOptions = {
    operationContext: "stopTranscriptionContext"
};

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

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

Erstellen eines Anrufs und Bereitstellen der Transkriptionsdetails

Definieren Sie die TranscriptionOptions für ACS, um zu wissen, ob die Transkription sofort oder zu einem späteren Zeitpunkt gestartet werden soll, welches Gebietsschema transkribiert werden soll, und welche Websocketverbindung zum Senden des Transkripts verwendet werden soll.

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
)

Transkription starten

Sobald Sie bereit sind, die Transkription zu starten, können Sie einen expliziten Anruf an die Anrufautomatisierung tätigen, um das Transkribieren des Anrufs zu starten.

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

Transkriptionsstream empfangen

Wenn die Transkription gestartet wird, empfängt Ihr Websocket die Transkriptionsmetadaten-Nutzdaten als erstes Paket. Diese Nutzdaten enthalten die Aufrufmetadaten und das Gebietsschema für die Konfiguration.

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

Transkriptionsdaten empfangen

Nach den Metadaten erhält Ihr Websocket als nächstes Pakete mit TranskriptionData für die transkribierte Audiodaten.

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

Transkriptionsdatenstream im Websocketserver verarbeiten

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

Transkription aktualisieren

In Situationen, in denen Ihre Anwendung es Benutzer*innen ermöglicht, ihre bevorzugte Sprache auszuwählen, können Sie auch die Transkription in dieser Sprache erfassen. Dazu können Sie mit dem Anrufautomatisierungs-SDK das Transkriptionsgebietsschema aktualisieren.

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

Transkription beenden

Wenn Ihre Anwendung das Zuhören für die Transkription beenden muss, können Sie die StopTranscription-Anforderung verwenden, um die Anrufautomatisierung zu informieren und das Senden von Transkriptdaten an Ihren Websocket zu beenden.

# Stop transcription without options
call_connection_client.stop_transcription()

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

Ereigniscodes

Ereignis code subcode `Message`
TranscriptionStarted 200 0 Die Aktion wurde erfolgreich abgeschlossen.
TranscriptionStopped 200 0 Die Aktion wurde erfolgreich abgeschlossen.
TranscriptionUpdated 200 0 Die Aktion wurde erfolgreich abgeschlossen.
TranscriptionFailed 400 8581 Aktion fehlgeschlagen, StreamUrl ist ungültig.
TrasncriptionFailed 400 8565 Die Aktion konnte aufgrund einer schlechten Anforderung an Cognitive Services nicht ausgeführt werden. Überprüfen Sie Ihre Eingabeparameter.
TranscriptionFailed 400 8565 Die Aktion konnte aufgrund des Timeouts einer Anforderung an Cognitive Services nicht ausgeführt werden. Versuchen Sie es später erneut, oder suchen Sie nach Problemen mit dem Dienst.
TranscriptionFailed 400 8605 Benutzerdefiniertes Spracherkennungsmodell für Transkription wird nicht unterstützt.
TranscriptionFailed 400 8523 Ungültige Anforderung, Gebietsschema fehlt.
TranscriptionFailed 400 8523 Ungültige Anforderung, nur Gebietsschemas, die Regionsinformationen enthalten, werden unterstützt.
TranscriptionFailed 405 8520 Die Transkriptionsfunktion wird derzeit nicht unterstützt.
TranscriptionFailed 405 8520 UpdateTranscription wird für die Verbindung, die mit der Connect-Schnittstelle erstellt wird, nicht unterstützt.
TranscriptionFailed 400 8528 Die Aktion ist ungültig, der Aufruf wurde bereits beendet.
TranscriptionFailed 405 8520 Das Aktualisieren der Transkriptionsfunktion wird derzeit nicht unterstützt.
TranscriptionFailed 405 8522 Anforderung nicht zulässig, wenn die Transkription-URL während der Anrufeinrichtung nicht festgelegt wurde.
TranscriptionFailed 405 8522 Anforderung nicht zulässig, wenn die Cognitive Service-Konfiguration während der Anrufeinrichtung nicht festgelegt wurde.
TranscriptionFailed 400 8501 Aktion ungültig, wenn sich der Aufruf nicht im Zustand „Hergestellt“ befindet.
TranscriptionFailed 401 8565 Die Aktion ist aufgrund eines Cognitive Services-Authentifizierungsfehlers fehlgeschlagen. Überprüfen Sie Ihre Autorisierungseingabe, und stellen Sie sicher, dass sie korrekt ist.
TranscriptionFailed 403 8565 Die Aktion ist aufgrund einer verbotenen Anforderung an Cognitive Services fehlgeschlagen. Überprüfen Sie Ihren Abonnementstatus, und stellen Sie sicher, dass er „aktiv“ lautet.
TranscriptionFailed 429 8565 Fehler bei der Aktion, Anzahl der zulässigen gleichzeitigen Anforderungen für das Cognitive Services-Abonnement überschritten.
TranscriptionFailed 500 8578 Fehler bei der Aktion, nicht in der Lage, eine WebSocket-Verbindung herzustellen.
TranscriptionFailed 500 8580 Aktion fehlgeschlagen, Transkriptionsdienst wurde heruntergefahren.
TranscriptionFailed 500 8579 Aktion fehlgeschlagen, Transkription wurde abgebrochen.
TranscriptionFailed 500 9999 Unbekannter interner Serverfehler.

Bekannte Probleme

  • Für 1:1-Aufrufe mit ACS-Benutzer*innen, die Client-SDKs verwenden, wird „startTranscription = True“ derzeit nicht unterstützt.