As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Noções básicas sobre os eventos de transcrição ao vivo do SDK do Amazon Chime
<a name="process-msgs"></a>

O serviço do SDK do Amazon Chime compartilha informações de transcrição com os participantes enviando objetos `TranscriptEvent` em mensagens de dados. Um `TranscriptEvent` entrega uma `Transcript` ou um `TranscriptionStatus`. 

Uma `Transcript` inclui resultados com registro de data e hora, palavras atribuídas pelo usuário e pontuação. Um resultado pode ser “parcial”; nesse caso, o sistema geralmente o atualiza em um `TranscriptEvent` posterior. Isso permite que você veja as transcrições rapidamente e aplique atualizações em linha posteriormente, conforme necessário.

Um `TranscriptStatus` pode realizar um dos eventos `TranscriptionStatusType`, listados no exemplo na próxima seção.

As versões mais recentes dos SDKs do Amazon Chime incluem tipos de dados adicionais e funções auxiliares para processamento comum de um `TranscriptEvent`.

## TranscriptEvent
<a name="transcript-event"></a>

Este exemplo mostra um evento de transcrição típico.

```
type TranscriptEvent = Transcript | TranscriptionStatus;

export class TranscriptEventConverter {
  static from(dataMessage: DataMessage): TranscriptEvent[] {
    // convert DataMessage to TranscriptEvents
    return ...
  }
}

export default class TranscriptionStatus {
    type: TranscriptionStatusType;
    eventTimeMs:                   number;
    transcriptionRegion:           string;
    transcriptionConfiguration:    string;
    message?:                      string;
}

enum TranscriptionStatusType {
    STARTED        =    'started',
    INTERRUPTED    =    'interrupted',
    RESUMED        =    'resumed',
    STOPPED        =    'stopped',
    FAILED         =    'failed',
}

export default class Transcript {
    results: TranscriptResult[];    // at least one
}

export class TranscriptResult {
    resultId:        string;
    isPartial:       boolean;
    startTimeMs:     number;
    endTimeMs:       number;
    alternatives:    TranscriptAlternative[];    // most confident first
    }

export default class TranscriptAlternative {
    items: TranscriptItem[];    // in start time order
    transcript: string; //concatenated transcript items
    entities?: TranscriptEntity[];
}

export default class TranscriptItem {
    type:                      TranscriptItemType;
    startTimeMs:               number;
    endTimeMs:                 number;
    attendee:                  Attendee;
    content:                   string;
    vocabularyFilterMatch?:    boolean;
    confidence?:               number;  
    stable?:                   boolean;
}

enum TranscriptItemType {
    PRONUNCIATION    =    'pronunciation',// content is a word
    PUNCTUATION      =    'punctuation',// content is punctuation
}

export default class TranscriptEntity {  
    category:       string;  
    confidence:     number;  
    content:        string;  
    endTimeMs:      number;  
    startTimeMs:    number;  
    type?:          string;
}

// This is an existing SDK model
export default class Attendee {
    attendeeId:        string;
    externalUserId:    string;
}
```

## Diretrizes de dados
<a name="data-guidelines"></a>

Lembre-se dessas diretrizes à medida que avança.

1. `transcription.results` pode apresentar mais de um resultado.

1. Se `transcription.results[i].isPartial = true`, pode haver uma atualização para todo o resultado. A atualização é provável, mas não garantida. A atualização tem o mesmo `transcript.result[i].resultId`. Se você quiser evitar transcrições de baixa confiança, pode ignorar completamente os resultados parciais. Se quiser resultados de baixa latência, você pode exibir resultados parciais e, em seguida, sobrescrever completamente quando a atualização chegar.

1. `transcription.results[i].alternatives` sempre contém pelo menos uma entrada. Se contiver mais de uma entrada, a entrada mais confiável será a primeira na lista. Na maioria dos casos, você pode pegar a primeira entrada em `transcription.results[i].alternatives` e ignorar as outras.

1. `transcription.results[i].alternatives[j].items` inclui uma entrada para cada palavra ou sinal de pontuação.

1. O conteúdo `transcription.results[i].alternatives[j].items[k].` é o que foi falado.

1. `transcription.results[i].alternatives[j].items[k].attendee` é a atribuição do conteúdo pelo usuário (quem).

1. `transcription.results[i].alternatives[j].items[k].startTimeMs` é o "quando" do conteúdo. Isso permite a renderização palavra por palavra da transcrição atribuída pelo usuário em diferentes usuários na ordem em que as palavras foram faladas.

1. Geralmente, o campo `transcription.results[i].alternatives[j].items[k].endTimeMs` pode ser ignorado, mas é fornecido para determinar quem disse o quê e quando.

1. `transcription.results[i].alternatives[j].items[k].vocabularyFilterMatch` é verdadeiro se o conteúdo corresponder a uma palavra no filtro, caso contrário, é falso.

1. `transcription.results[i].alternatives[j].items[k].confidence` é um valor entre 0 e 1. Isso indica a confiança do mecanismo de que o conteúdo do item corresponde corretamente à palavra falada, com 0 sendo a menor confiança e 1 sendo a maior confiança.

1. `transcription.results[i].alternatives[j].items[k].stable` indica se a palavra atual será alterada em futuras atualizações parciais de resultados. Esse valor só pode ser verdadeiro se você ativar o atributo de estabilização parcial de resultados configurando `EnablePartialResultsStabilization` como `true` em sua solicitação.

1. `transcription.results[i].alternatives[j].entities` inclui uma entrada para cada entidade que os atributos de identificação ou redação de conteúdo detectam. A lista só será preenchida se você ativar a Identificação ou Redação de conteúdo. Uma entidade pode ser dados como informações de identificação pessoal ou informações de saúde. Você pode usar entidades para destacar ou agir sobre palavras de interesse durante a transcrição.

1. `transcription.results[i].alternatives[j].entities[k].category` é a categoria da entidade. É igual ao tipo de identificação ou redação de conteúdo, como "PII" ou "PHI", que é fornecido na solicitação.

1. `transcription.results[i].alternatives[j].entities[k].confidence` mede o quão forte é o mecanismo para que o conteúdo específico seja realmente uma entidade. Observe que isso é diferente da confiança no nível do item, que mede a confiança do mecanismo na exatidão das palavras em si.

1. `transcription.results[i].alternatives[j].entities[k].content` é o texto real que compõe a entidade. Isso pode ser vários itens, como um endereço.

1. `transcription.results[i].alternatives[j].entities[k].startTimeMs` captura a hora em que a entidade começou a ser falada.

1. `transcription.results[i].alternatives[j].entities[k].endTimeMs` captura a hora em que a entidade parou de ser falada.

1. `transcription.results[i].alternatives[j].entities[k].type` só é compatível com o mecanismo de Transcrição e fornece o subtipo da entidade. Esses são valores como `ADDRESS`, `CREDIT\_DEBIT\_NUMBER` e assim por diante.

## Registrar manipuladores de eventos para TranscriptEvents
<a name="register-handler"></a>

Os exemplos a seguir usam a biblioteca cliente do Amazon Chime SDK para. JavaScript No entanto, o padrão é consistente em todos os SDKs do Amazon Chime.

O `TranscriptionController` no `RealtimeController` e no `RealtimeControllerFacade` inclui funções específicas para adicionar um manipulador que processa `TranscriptionEvents`:

```
/** 
 * Returns the [[TranscriptionController]] for this real-time controller. 
 */
readonly transcriptionController?: TranscriptionController;
```

O `TranscriptionController` tem duas funções para gerenciar a assinatura e o cancelamento da assinatura de retornos de chamada de `TranscriptionEvent`:

```
import TranscriptEvent from './TranscriptEvent';

export default interface TranscriptionController {
  /**
   * Subscribe a callback to handle received transcript event
   */
  subscribeToTranscriptEvent(callback: (transcriptEvent: TranscriptEvent) => void): void;

  /** 
   * Unsubscribe a callback from receiving transcript event 
   */
  unsubscribeFromTranscriptEvent(callback: (transcriptEvent: TranscriptEvent) => void): void;
}
```

**Como usar o `TranscriptionController` opcional**  
Nós fornecemos uma implementação-padrão da interface `TranscriptionController` chamada `DefaultTranscriptionController`. A implementação-padrão em `DefaultRealtimeController` e `DefaultAudioVideoFacade` retorna um objeto `DefaultTranscriptionController`:

```
/** 
get transcriptionController(): TranscriptionController {
   return this.realtimeController.transcriptionController;
}
```

O `DefaultRealtimeController` também usa um objeto `TranscriptionController` opcional em seu construtor. Isso permite que você anule o comportamento `DefaultTranscriptionController`. Os aplicativos do desenvolvedor assinam e cancelam a assinatura de um ou mais retornos de chamada por meio do objeto `TranscriptionController` do objeto `AudioVideoFacade`:

```
// Subscribe
this.audioVideo.transcriptionController?.subscribeToTranscriptEvent(this.transcriptEventHandler);

// Unsubscribe
this.audioVideo.transcriptionController?.unsubscribeFromTranscriptEvent(this.transcriptEventHandler););
```