Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Informazioni sui messaggi di trascrizione live di Amazon Chime SDK
<a name="process-msgs"></a>

Il servizio Amazon Chime SDK condivide le informazioni di trascrizione con i partecipanti inviando oggetti nei messaggi di dati. `TranscriptEvent` A fornisce un o un. `TranscriptEvent` `Transcript` `TranscriptionStatus` 

A `Transcript` include risultati con parole e punteggiatura con data e ora attribuite dall'utente. Un risultato può essere «parziale», nel qual caso il sistema di solito lo aggiorna in un secondo momento. `TranscriptEvent` Ciò consente di visualizzare rapidamente le trascrizioni e di applicare gli aggiornamenti in linea in un secondo momento, se necessario.

A `TranscriptStatus` può fornire uno degli `TranscriptionStatusType` eventi, elencati nell'esempio nella sezione successiva.

Le versioni più recenti degli SDK Amazon Chime includono tipi di dati aggiuntivi e funzioni di supporto per l'elaborazione comune a. `TranscriptEvent`

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

Questo esempio mostra un tipico evento di trascrizione.

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

## Linee guida sui dati
<a name="data-guidelines"></a>

Tieni a mente queste linee guida mentre procedi.

1. `transcription.results`può avere più di un risultato.

1. Se`transcription.results[i].isPartial = true`, allora potrebbe esserci un aggiornamento per l'intero risultato. L'aggiornamento è probabile, ma non garantito. L'aggiornamento è lo stesso`transcript.result[i].resultId`. Se vuoi evitare trascrizioni con scarsa confidenza, puoi saltare completamente i risultati parziali. Se desideri risultati a bassa latenza, puoi visualizzare i risultati parziali e sovrascriverli completamente quando arriva l'aggiornamento.

1. `transcription.results[i].alternatives`contiene sempre almeno una voce. Se contiene più di una voce, la voce più sicura è la prima dell'elenco. Nella maggior parte dei casi, è possibile inserire la prima voce `transcription.results[i].alternatives` e ignorare le altre.

1. `transcription.results[i].alternatives[j].items`include una voce per ogni parola o segno di punteggiatura.

1. `transcription.results[i].alternatives[j].items[k].`il contenuto è ciò che è stato detto.

1. `transcription.results[i].alternatives[j].items[k].attendee`è l'attribuzione dell'utente (chi) del contenuto.

1. `transcription.results[i].alternatives[j].items[k].startTimeMs`è il «quando» del contenuto. Ciò consente la riproduzione parola per parola della trascrizione attribuita dall'utente tra diversi utenti nell'ordine in cui le parole sono state pronunciate.

1. Il `transcription.results[i].alternatives[j].items[k].endTimeMs` campo può generalmente essere ignorato, ma viene fornito per completezza di informazioni su chi ha detto cosa e quando.

1. `transcription.results[i].alternatives[j].items[k].vocabularyFilterMatch`è vero se il contenuto corrisponde a una parola nel filtro, altrimenti è falso.

1. `transcription.results[i].alternatives[j].items[k].confidence`è un valore compreso tra 0 e 1. Indica la fiducia del motore che il contenuto dell'elemento corrisponde correttamente alla parola pronunciata, dove 0 è la confidenza più bassa e 1 la massima.

1. `transcription.results[i].alternatives[j].items[k].stable`indica se la parola corrente cambierà nei futuri aggiornamenti parziali dei risultati. Questo valore può essere vero solo se si abilita la funzione di stabilizzazione parziale dei risultati `EnablePartialResultsStabilization` impostando su `true` nella richiesta.

1. `transcription.results[i].alternatives[j].entities`include una voce per ogni entità rilevata dalle funzioni di Content Identification o Redaction. L'elenco viene compilato solo se abiliti l'identificazione o la redazione dei contenuti. Un'entità può essere costituita da dati quali informazioni di identificazione personale o informazioni sanitarie personali. Puoi utilizzare le entità per evidenziare o agire in base alle parole che ti interessano durante la trascrizione.

1. `transcription.results[i].alternatives[j].entities[k].category`è la categoria dell'entità. È uguale al tipo di identificazione o redazione del contenuto, ad esempio «PII» o «PHI», fornito nella richiesta.

1. `transcription.results[i].alternatives[j].entities[k].confidence`misura quanto sia forte il motore del fatto che quel particolare contenuto sia realmente un'entità. Nota che questo valore è diverso dalla confidenza a livello di elemento, che misura la fiducia del motore nella correttezza delle parole stesse.

1. `transcription.results[i].alternatives[j].entities[k].content`è il testo effettivo che costituisce l'entità. Può trattarsi di più elementi, ad esempio un indirizzo.

1. `transcription.results[i].alternatives[j].entities[k].startTimeMs`registra il momento in cui l'entità ha iniziato a essere parlata.

1. `transcription.results[i].alternatives[j].entities[k].endTimeMs`cattura l'ora in cui l'entità ha finito di essere parlata.

1. `transcription.results[i].alternatives[j].entities[k].type`è supportato solo per il motore Transcribe e fornisce il sottotipo dell'entità. Si tratta di valori come `ADDRESS`, `CREDIT\_DEBIT\_NUMBER` e così via.

## Registrazione di gestori di eventi per TranscriptEvents
<a name="register-handler"></a>

I seguenti esempi utilizzano la libreria client Amazon Chime SDK per. JavaScript Tuttavia, lo schema è coerente in tutti gli SDK Amazon Chime.

The `TranscriptionController` in the `RealtimeController` and `RealtimeControllerFacade` include funzioni specifiche per l'aggiunta di un gestore che elabora: `TranscriptionEvents`

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

`TranscriptionController`Ha due funzioni per gestire l'iscrizione e l'annullamento dell'iscrizione ai callback: `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;
}
```

**Utilizzando l'opzione `TranscriptionController`**  
Forniamo un'implementazione predefinita dell'`TranscriptionController`interfaccia denominata`DefaultTranscriptionController`. L'implementazione predefinita in `DefaultRealtimeController` e `DefaultAudioVideoFacade` restituisce un `DefaultTranscriptionController` oggetto:

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

`DefaultRealtimeController`accetta anche un `TranscriptionController` oggetto opzionale nel suo costruttore. Ciò consente di sovrascrivere il `DefaultTranscriptionController` comportamento. Le applicazioni per sviluppatori si iscrivono e annullano l'iscrizione a uno o più callback tramite l'`TranscriptionController`oggetto dell'oggetto: `AudioVideoFacade`

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

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