Partilhar via

Adicione transcrição em tempo real à sua aplicação

  • Artigo

Importante

A funcionalidade descrita neste artigo está atualmente em visualização pública. Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações 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 seu aplicativo de servidor configure um servidor WebSocket para transmitir transcrição em tempo real. WebSocket é um protocolo padronizado que fornece um canal de comunicação full-duplex através de uma única conexão TCP. Opcionalmente, você pode usar os serviços do Azure Azure WebApps que permitem criar um aplicativo para receber transcrições em uma conexão websocket. Siga este guia de início rápido.

Estabeleça uma chamada

Neste guia de início rápido, assumimos que você já está familiarizado com o início de chamadas. Se precisar de saber mais sobre como iniciar e estabelecer chamadas, pode seguir o nosso guia de início rápido. Para os fins deste início rápido, estamos passando pelo processo de iniciar a transcrição para chamadas de entrada e 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 - Começar no momento de atender ou criar uma chamada

Opção 2 - Iniciar a transcrição durante uma chamada em curso

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 de atender ou criar uma chamada.

Crie uma chamada e forneça os detalhes da transcrição

Defina as TranscriptionOptions para que o ACS saiba se deve iniciar a transcrição imediatamente ou posteriormente, 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ê pode fazer uma chamada explícita para o Call Automation 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, seu websocket receberá a carga útil de metadados de transcrição como o primeiro pacote. Essa carga carrega os metadados da chamada e a localidade da configuração.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "835be116-f750-48a4-a5a4-ab85e070e5b0",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Receber dados de transcrição

Após os metadados, os próximos pacotes que seu soquete da Web receberá 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 do 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 seu idioma preferido, você também pode querer capturar a transcrição nesse idioma. Para fazer isso, o Call Automation SDK permite que você atualize a localidade de transcrição.

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

Parar transcrição

Quando seu aplicativo precisar parar de ouvir a transcrição, você poderá usar a solicitação StopTranscription para informar a Automação de Chamadas para parar de enviar dados de transcrição para seu soquete da Web.

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

await callMedia.StopTranscriptionAsync(stopOptions);

Crie uma chamada e forneça os detalhes da transcrição

Defina as TranscriptionOptions para que o ACS saiba se deve iniciar a transcrição imediatamente ou posteriormente, 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ê pode fazer uma chamada explícita para o Call Automation 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, seu websocket receberá a carga útil de metadados de transcrição como o primeiro pacote. Essa carga carrega os metadados da chamada e a localidade da configuração.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "835be116-f750-48a4-a5a4-ab85e070e5b0",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Receber dados de transcrição

Após os metadados, os próximos pacotes que seu soquete da Web receberá 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 do 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 seu idioma preferido, você também pode querer capturar a transcrição nesse idioma. Para fazer isso, o Call Automation SDK permite que você atualize a localidade de transcrição.

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

Parar transcrição

Quando seu aplicativo precisar parar de ouvir a transcrição, você poderá usar a solicitação StopTranscription para informar a Automação de Chamadas para parar de enviar dados de transcrição para seu 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();

Crie uma chamada e forneça os detalhes da transcrição

Defina as Opções de Transcrição para o ACS para saber se a transcrição deve ser iniciada imediatamente ou posteriormente, 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 pronto para iniciar a transcrição, você pode fazer uma chamada explícita para o Call Automation 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, seu websocket receberá a carga útil de metadados de transcrição como o primeiro pacote. Essa carga carrega os metadados da chamada e a localidade da configuração.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "835be116-f750-48a4-a5a4-ab85e070e5b0",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Recebimento de dados de transcrição

Após os metadados, os próximos pacotes que seu soquete da Web receberá 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 seu idioma preferido, você também pode querer 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");

Parar transcrição

Quando seu aplicativo precisar parar de ouvir a transcrição, você poderá usar a solicitação StopTranscription para informar a Automação de Chamadas para parar de enviar dados de transcrição para seu soquete da Web.

const stopTranscriptionOptions = {
    operationContext: "stopTranscriptionContext"
};

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

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

Crie uma chamada e forneça os detalhes da transcrição

Defina as Opções de Transcrição para o ACS para saber se a transcrição deve ser iniciada imediatamente ou posteriormente, 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 pronto para iniciar a transcrição, você pode fazer uma chamada explícita para o Call Automation 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, seu websocket receberá a carga útil de metadados de transcrição como o primeiro pacote. Essa carga carrega os metadados da chamada e a localidade da configuração.

{
    "kind": "TranscriptionMetadata",
    "transcriptionMetadata": {
        "subscriptionId": "835be116-f750-48a4-a5a4-ab85e070e5b0",
        "locale": "en-us",
        "callConnectionId": "65c57654=f12c-4975-92a4-21668e61dd98",
        "correlationId": "65c57654=f12c-4975-92a4-21668e61dd98"
    }
}

Recebimento de dados de transcrição

Após os metadados, os próximos pacotes que seu websocket receberá 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 seu idioma preferido, você também pode querer 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")

Parar transcrição

Quando seu aplicativo precisar parar de ouvir a transcrição, você poderá usar a solicitação StopTranscription para informar a Automação de Chamadas para parar de enviar dados de transcrição para seu 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 code subcódigo Mensagem
TranscriçãoIniciado 200 0 Ação concluída com êxito.
TranscriçãoInterrompido 200 0 Ação concluída com êxito.
TranscriçãoAtualizado 200 0 Ação concluída com êxito.
TranscriçãoFalhou 400 8581 Falha na ação, StreamUrl não é válido.
TrasncriptionFailed 400 8565 A ação falhou devido a um mau pedido aos Serviços Cognitivos. Verifique os parâmetros de entrada.
TranscriçãoFalhou 400 8565 A ação falhou devido a um pedido aos Serviços Cognitivos de tempo limite. Tente novamente mais tarde ou verifique se há problemas com o serviço.
TranscriçãoFalhou 400 8605 Não há suporte para o modelo de reconhecimento de fala personalizado para transcrição.
TranscriçãoFalhou 400 8523 Solicitação inválida, localidade está faltando.
TranscriçãoFalhou 400 8523 Solicitação inválida, somente localidade que contém informações de região são suportadas.
TranscriçãoFalhou 405 8520 A funcionalidade de transcrição não é suportada no momento.
TranscriçãoFalhou 405 8520 UpdateTranscription não é suportado para conexão criada com a interface Connect.
TranscriçãoFalhou 400 8528 A ação é inválida, a chamada já foi encerrada.
TranscriçãoFalhou 405 8520 A funcionalidade de transcrição de atualização não é suportada no momento.
TranscriçãoFalhou 405 8522 Solicitação não permitida quando a URL de transcrição não estiver definida durante a configuração da chamada.
TranscriçãoFalhou 405 8522 Solicitação não permitida quando a Configuração do Serviço Cognitivo não estiver definida durante a configuração da chamada.
TranscriçãoFalhou 400 8501 A ação é inválida quando a chamada não está no estado Estabelecido.
TranscriçãoFalhou 401 8565 A ação falhou devido a um erro de autenticação dos Serviços Cognitivos. Verifique a sua entrada de autorização e certifique-se de que está correta.
TranscriçãoFalhou 403 8565 A ação falhou devido a um pedido proibido aos Serviços Cognitivos. Verifique o estado da sua subscrição e certifique-se de que está ativa.
TranscriçãoFalhou 429 8565 A ação falhou, as solicitações excederam o número de solicitações simultâneas permitidas para a assinatura de serviços cognitivos.
TranscriçãoFalhou 500 8578 Falha na ação, não é possível estabelecer a conexão WebSocket.
TranscriçãoFalhou 500 8580 A ação falhou, o serviço de transcrição foi encerrado.
TranscriçãoFalhou 500 8579 A ação falhou, a transcrição foi cancelada.
TranscriçãoFalhou 500 9999 Erro interno desconhecido do servidor.

Problemas conhecidos

  • Para chamadas 1:1 com usuários do ACS usando SDKs de cliente, startTranscription = True não é suportado no momento.