Compartilhar via

Adicionar transcrição em tempo real ao seu aplicativo

  • Artigo

Importante

A funcionalidade descrita neste artigo está atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Este guia ajuda você a entender melhor as diferentes maneiras de usar a oferta dos Serviços de Comunicação do Azure de transcrição em tempo real por meio de SDKs de Automação de Chamadas.

Pré-requisitos

Configurar um servidor WebSocket

Os Serviços de Comunicação do Azure exigem que o aplicativo de servidor configure um servidor WebSocket para transmitir a transcrição em tempo real. O WebSocket é um protocolo padronizado que fornece um canal de comunicação full-duplex sobre uma única conexão TCP. Opcionalmente, é possível usar os Aplicativos Web do Azure dos serviços do Azure para criar um aplicativo que receba transcrições por uma conexão WebSocket. Siga este início rápido.

Estabelecer uma chamada

Neste início rápido, presumimos que você já esteja familiarizado com as chamadas iniciais. Para saber como iniciar e estabelecer chamadas, siga nosso início rápido. Para este início rápido, estamos passando pelo processo de iniciar a transcrição tanto para chamadas de entrada quanto chamadas de saída.

Ao trabalhar com transcrição em tempo real, você tem algumas opções sobre quando e como iniciar a transcrição:

Opção 1 – Iniciando no momento da resposta ou da criação de uma chamada

Opção 2 – Iniciando a transcrição durante uma chamada em andamento

Neste tutorial, estamos demonstrando a opção 2, iniciando a transcrição durante uma chamada em andamento. Por padrão, o 'startTranscription' é definido como false no momento da criação de uma chamada ou ao respondê-la.

Criar uma chamada e fornecer os detalhes da transcrição

Defina as TranscriptionOptions para ACS para saber se você deve iniciar a transcrição imediatamente ou em um momento posterior, em qual localidade transcrever e a conexão de soquete da Web a ser usada para enviar a transcrição.

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

Iniciar Transcrição

Quando estiver pronto para iniciar a transcrição, você poderá fazer uma chamada explícita para a Automação de Chamadas para começar a transcrever a chamada.

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

Recebendo fluxo de transcrição

Quando a transcrição for iniciada, o websocket receberá o conteúdo de metadados de transcrição como o primeiro pacote. Esse conteúdo carrega os metadados de chamada e a localidade da configuração.

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

Recebendo dados de transcrição

Após os metadados, os próximos pacotes recebidos pelo soquete da Web serão TranscriptionData para o áudio transcrito.

{
    "kind": "TranscriptionData",
    "transcriptionData": {
        "text": "Testing transcription.",
        "format": "display",
        "confidence": 0.695223331451416,
        "offset": 2516998782481234400,
        "words": [
            {
                "text": "testing",
                "offset": 2516998782481234400
            },
            {
                "text": "testing",
                "offset": 2516998782481234400
            }
        ],
        "participantRawID": "8:acs:",
        "resultStatus": "Final"
    }
}

Manipulando o fluxo de transcrição no servidor de soquete da 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();

Atualizações em seu código para o manipulador 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);
        }
    }
}

Atualizar transcrição

Para situações em que seu aplicativo permite que os usuários selecionem o idioma de preferência deles, talvez você também queira capturar a transcrição nesse idioma. Para fazer isso, o SDK de Automação de Chamadas permite que você atualize a localidade da transcrição.

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

Interromper transcrição

Quando o aplicativo precisa parar de escutar a transcrição, você pode usar a solicitação StopTranscription para informar a Automação de Chamadas para interromper o envio de dados de transcrição para o soquete da Web.

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

await callMedia.StopTranscriptionAsync(stopOptions);

Criar uma chamada e fornecer os detalhes da transcrição

Defina as TranscriptionOptions para ACS para saber se você deve iniciar a transcrição imediatamente ou em um momento posterior, em qual localidade transcrever e a conexão de soquete da Web a ser usada para enviar a transcrição.

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

Iniciar Transcrição

Quando estiver pronto para iniciar a transcrição, você poderá fazer uma chamada explícita para a Automação de Chamadas para começar a transcrever a chamada.

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

Recebendo fluxo de transcrição

Quando a transcrição for iniciada, o websocket receberá o conteúdo de metadados de transcrição como o primeiro pacote. Esse conteúdo carrega os metadados de chamada e a localidade da configuração.

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

Recebendo dados de transcrição

Após os metadados, os próximos pacotes recebidos pelo soquete da Web serão TranscriptionData para o áudio transcrito.

{
    "kind": "TranscriptionData",
    "transcriptionData": {
        "text": "Testing transcription.",
        "format": "display",
        "confidence": 0.695223331451416,
        "offset": 2516998782481234400,
        "words": [
            {
                "text": "testing",
                "offset": 2516998782481234400
            },
            {
                "text": "testing",
                "offset": 2516998782481234400
            }
        ],
        "participantRawID": "8:acs:",
        "resultStatus": "Final"
    }
}

Manipulando o fluxo de transcrição no servidor de soquete da 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();
        }
    }
}

Atualizações em seu código para o manipulador 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("----------------------------------------------------------------");
        }
    }
}

Atualizar transcrição

Para situações em que seu aplicativo permite que os usuários selecionem o idioma de preferência deles, talvez você também queira capturar a transcrição nesse idioma. Para fazer isso, o SDK de Automação de Chamadas permite que você atualize a localidade da transcrição.

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

Interromper transcrição

Quando o aplicativo precisa parar de escutar a transcrição, você pode usar a solicitação StopTranscription para informar a Automação de Chamadas para interromper o envio de dados de transcrição para o soquete da 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();

Criar uma chamada e fornecer os detalhes da transcrição

Defina as TranscriptionOptions para ACS para saber se você deve iniciar a transcrição imediatamente ou em um momento posterior, em qual localidade transcrever e a conexão de soquete da Web a ser usada para enviar a transcrição.

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

Iniciar Transcrição

Quando estiver tudo pronto para iniciar a transcrição, você poderá fazer uma chamada explícita para a Automação de Chamadas para começar a transcrever a chamada.

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

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

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

Recebendo fluxo de transcrição

Quando a transcrição for iniciada, o websocket receberá o conteúdo de metadados de transcrição como o primeiro pacote. Esse conteúdo carrega os metadados de chamada e a localidade da configuração.

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

Recebendo dados de transcrição

Após os metadados, os próximos pacotes recebidos pelo soquete da Web serão TranscriptionData para o áudio transcrito.

{
    "kind": "TranscriptionData",
    "transcriptionData": {
        "text": "Testing transcription.",
        "format": "display",
        "confidence": 0.695223331451416,
        "offset": 2516998782481234400,
        "words": [
            {
                "text": "testing",
                "offset": 2516998782481234400
            },
            {
                "text": "testing",
                "offset": 2516998782481234400
            }
        ],
        "participantRawID": "8:acs:",
        "resultStatus": "Final"
    }
}

Manipulando o fluxo de transcrição no servidor de soquete da 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');

Atualizar transcrição

Para situações em que seu aplicativo permite que os usuários selecionem o idioma de preferência deles, talvez você também queira capturar a transcrição nesse idioma. Para fazer isso, o SDK de Automação de Chamadas permite que você atualize a localidade de transcrição.

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

Interromper transcrição

Quando o aplicativo precisa parar de escutar a transcrição, você pode usar a solicitação StopTranscription para informar a Automação de Chamadas para interromper o envio de dados de transcrição para o soquete da Web.

const stopTranscriptionOptions = {
    operationContext: "stopTranscriptionContext"
};

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

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

Criar uma chamada e fornecer os detalhes da transcrição

Defina as TranscriptionOptions para ACS para saber se você deve iniciar a transcrição imediatamente ou em um momento posterior, em qual localidade transcrever e a conexão de soquete da Web a ser usada para enviar a transcrição.

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
)

Iniciar Transcrição

Quando estiver tudo pronto para iniciar a transcrição, você poderá fazer uma chamada explícita para a Automação de Chamadas para começar a transcrever a chamada.

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

Recebendo fluxo de transcrição

Quando a transcrição for iniciada, o websocket receberá o conteúdo de metadados de transcrição como o primeiro pacote. Esse conteúdo carrega os metadados de chamada e a localidade da configuração.

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

Recebendo dados de transcrição

Após os metadados, os próximos pacotes recebidos pelo websocket serão TranscriptionData para o áudio transcrito.

{
    "kind": "TranscriptionData",
    "transcriptionData": {
        "text": "Testing transcription.",
        "format": "display",
        "confidence": 0.695223331451416,
        "offset": 2516998782481234400,
        "words": [
            {
                "text": "testing",
                "offset": 2516998782481234400
            },
            {
                "text": "testing",
                "offset": 2516998782481234400
            }
        ],
        "participantRawID": "8:acs:",
        "resultStatus": "Final"
    }
}

Manipulando o fluxo de transcrição no servidor de soquete da 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()

Atualizar transcrição

Para situações em que seu aplicativo permite que os usuários selecionem o idioma de preferência deles, talvez você também queira capturar a transcrição nesse idioma. Para fazer isso, o SDK de Automação de Chamadas permite que você atualize a localidade de transcrição.

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

Interromper transcrição

Quando o aplicativo precisa parar de escutar a transcrição, você pode usar a solicitação StopTranscription para informar a Automação de Chamadas para interromper o envio de dados de transcrição para o soquete da Web.

# Stop transcription without options
call_connection_client.stop_transcription()

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

Códigos de evento

Evento código subcódigo Mensagem
TranscriptionStarted 200 0 Ação concluída com sucesso.
TranscriptionStopped 200 0 Ação concluída com sucesso.
TranscriptionUpdated 200 0 Ação concluída com sucesso.
TranscriptionFailed 400 8581 Falha na ação, StreamUrl não é válido.
TranscriptionFailed 400 8565 Falha na ação devido a uma solicitação incorreta aos Serviços Cognitivos. Verifique os parâmetros de entrada.
TranscriptionFailed 400 8565 Falha na ação devido a uma solicitação para o tempo limite dos Serviços Cognitivos. Tente novamente mais tarde ou verifique se há problemas com o serviço.
TranscriptionFailed 400 8605 Não há suporte para o modelo de reconhecimento de fala personalizado para Transcrição.
TranscriptionFailed 400 8523 Solicitação inválida, a localidade está ausente.
TranscriptionFailed 400 8523 Solicitação inválida, há suporte apenas para a localidade que contém informações de região.
TranscriptionFailed 405 8520 Não há suporte para a funcionalidade de transcrição no momento.
TranscriptionFailed 405 8520 Não há suporte para UpdateTranscription para conexão criada com a interface Connect.
TranscriptionFailed 400 8528 A ação é inválida, a chamada já foi encerrada.
TranscriptionFailed 405 8520 No momento, não há suporte para a funcionalidade de transcrição de atualização.
TranscriptionFailed 405 8522 Solicitação não permitida quando a URL de Transcrição não é definida durante a instalação da chamada.
TranscriptionFailed 405 8522 Solicitação não permitida quando a Configuração do Serviço Cognitivo não é definida durante a configuração da chamada.
TranscriptionFailed 400 8501 A ação é inválida quando a chamada não está no estado Estabelecido.
TranscriptionFailed 401 8565 Falha na ação devido a um erro de autenticação dos Serviços Cognitivos. Verifique sua entrada de autorização e confirme que ela está correta.
TranscriptionFailed 403 8565 Falha na ação devido a uma solicitação proibida aos Serviços Cognitivos. Verifique o status da assinatura e verifique se ela está ativa.
TranscriptionFailed 429 8565 Falha na ação, as solicitações excederam o número de solicitações simultâneas permitidas para a assinatura dos serviços cognitivos.
TranscriptionFailed 500 8578 Falha na ação, não foi possível estabelecer a conexão WebSocket.
TranscriptionFailed 500 8580 Falha na ação, o serviço de transcrição foi desligado.
TranscriptionFailed 500 8579 Falha na ação, a transcrição foi cancelada.
TranscriptionFailed 500 9999 Erro interno desconhecido do servidor.

Problemas conhecidos

  • No momento, não há suporte para chamadas 1:1 com usuários do ACS usando startTranscription = True de SDKs do cliente.