Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Comprendre les messages de transcription en direct du SDK Amazon Chime
<a name="process-msgs"></a>

Le service Amazon Chime SDK partage les informations de transcription avec les participants en envoyant des `TranscriptEvent` objets dans des messages de données. A `TranscriptEvent` livre un `Transcript` ou un`TranscriptionStatus`. 

A `Transcript` inclut les résultats horodatés, les mots attribués par l'utilisateur et la ponctuation. Un résultat peut être « partiel », auquel cas le système le met généralement à jour ultérieurement`TranscriptEvent`. Cela vous permet de consulter rapidement les transcriptions et d'appliquer des mises à jour en ligne ultérieurement si nécessaire.

A `TranscriptStatus` peut présenter l'un des `TranscriptionStatusType` événements répertoriés dans l'exemple de la section suivante.

Les nouvelles versions d'Amazon Chime SDKs incluent des types de données supplémentaires et des fonctions d'assistance pour le traitement courant a. `TranscriptEvent`

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

Cet exemple montre un événement de transcription typique.

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

## Directives relatives aux données
<a name="data-guidelines"></a>

Gardez ces directives à l'esprit au fur et à mesure.

1. `transcription.results`peut avoir plus d'un résultat.

1. Si c'est `transcription.results[i].isPartial = true` le cas, il se peut qu'il y ait une mise à jour pour l'ensemble du résultat. La mise à jour est probable, mais elle n'est pas garantie. Il en va de même pour la mise à jour`transcript.result[i].resultId`. Si vous souhaitez éviter les transcriptions peu fiables, vous pouvez ignorer complètement les résultats partiels. Si vous souhaitez obtenir des résultats à faible latence, vous pouvez afficher des résultats partiels, puis les remplacer complètement lorsque la mise à jour arrive.

1. `transcription.results[i].alternatives`contient toujours au moins une entrée. S'il contient plusieurs entrées, l'entrée la plus sûre est la première de la liste. Dans la plupart des cas, vous pouvez accepter la première entrée `transcription.results[i].alternatives` et ignorer les autres.

1. `transcription.results[i].alternatives[j].items`inclut une entrée pour chaque mot ou signe de ponctuation.

1. `transcription.results[i].alternatives[j].items[k].`le contenu est ce qui a été dit.

1. `transcription.results[i].alternatives[j].items[k].attendee`est l'attribution du contenu à l'utilisateur (qui).

1. `transcription.results[i].alternatives[j].items[k].startTimeMs`est le « quand » du contenu. Cela permet de word-by-word restituer la transcription attribuée par l'utilisateur à différents utilisateurs dans l'ordre dans lequel les mots ont été prononcés.

1. Le `transcription.results[i].alternatives[j].items[k].endTimeMs` champ peut généralement être ignoré, mais il est fourni par souci d'exhaustivité pour savoir qui a dit quoi et quand.

1. `transcription.results[i].alternatives[j].items[k].vocabularyFilterMatch`est vrai si le contenu correspond à un mot du filtre, sinon il est faux.

1. `transcription.results[i].alternatives[j].items[k].confidence`est une valeur comprise entre 0 et 1. Cela indique que le moteur est sûr que le contenu de l'élément correspond correctement au mot prononcé, 0 étant le niveau de confiance le plus faible et 1 le niveau de confiance le plus élevé.

1. `transcription.results[i].alternatives[j].items[k].stable`indique si le mot actuel sera modifié lors des futures mises à jour partielles des résultats. Cette valeur ne peut être vraie que si vous activez la fonction de stabilisation des résultats partiels `true` en `EnablePartialResultsStabilization` la définissant dans votre demande.

1. `transcription.results[i].alternatives[j].entities`inclut une entrée pour chaque entité détectée par les fonctionnalités d'identification du contenu ou de rédaction. La liste n'est remplie que si vous activez l'identification ou la rédaction du contenu. Une entité peut être constituée de données telles que des informations personnelles identifiables ou des informations personnelles sur la santé. Vous pouvez utiliser des entités pour mettre en évidence les mots qui vous intéressent ou agir sur ceux-ci lors de la transcription.

1. `transcription.results[i].alternatives[j].entities[k].category`est la catégorie de l'entité. Il correspond au type d'identification ou de rédaction du contenu, tel que « PII » ou « PHI », fourni dans la demande.

1. `transcription.results[i].alternatives[j].entities[k].confidence`mesure la puissance du moteur pour faire en sorte que le contenu en question soit réellement une entité. Notez que cela est différent de la confiance au niveau de l'élément, qui mesure le degré de confiance du moteur dans l'exactitude des mots eux-mêmes.

1. `transcription.results[i].alternatives[j].entities[k].content`est le texte réel qui constitue l'entité. Il peut s'agir de plusieurs éléments, tels qu'une adresse.

1. `transcription.results[i].alternatives[j].entities[k].startTimeMs`capture l'heure à laquelle l'entité a commencé à être parlée.

1. `transcription.results[i].alternatives[j].entities[k].endTimeMs`capture l'heure à laquelle l'entité a fini d'être prononcée.

1. `transcription.results[i].alternatives[j].entities[k].type`n'est pris en charge que pour le moteur Transcribe et fournit le sous-type de l'entité. Il s'agit de valeurs telles que `ADDRESS`, `CREDIT\$1DEBIT\$1NUMBER`, etc.

## Enregistrement de gestionnaires d'événements pour TranscriptEvents
<a name="register-handler"></a>

Les exemples suivants utilisent la bibliothèque cliente du SDK Amazon Chime pour. JavaScript Cependant, le schéma est le même sur tous les Amazon Chime SDKs.

Le `TranscriptionController` in the `RealtimeController` et `RealtimeControllerFacade` inclut des fonctions spécifiques pour ajouter un gestionnaire qui traite `TranscriptionEvents` :

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

`TranscriptionController`Il dispose de deux fonctions pour gérer l'abonnement et le désabonnement aux rappels : `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;
}
```

**Utilisation de l'option `TranscriptionController`**  
Nous fournissons une implémentation par défaut de `TranscriptionController` l'interface nommée`DefaultTranscriptionController`. L'implémentation par défaut dans `DefaultRealtimeController` et `DefaultAudioVideoFacade` renvoie un `DefaultTranscriptionController` objet :

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

`DefaultRealtimeController`prend également un `TranscriptionController` objet optionnel dans son constructeur. Cela vous permet de modifier le `DefaultTranscriptionController` comportement. Les applications de développement s'abonnent et se désabonnent à un ou plusieurs rappels via l'`TranscriptionController`objet de l'`AudioVideoFacade`objet :

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

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