# SDK di trasmissione IVS: scambio di token \| Streaming in tempo reale
Lo scambio di token consente di effettuare l'aggiornamento o il downgrade delle funzionalità dei token dei partecipanti e di aggiornare gli attributi dei token all'interno dell'SDK per la trasmissione, senza richiedere ai partecipanti di riconnettersi. Questa funzione si rivela utile in scenari come il co-hosting, in cui i partecipanti possono iniziare con funzionalità riservate ai soli abbonati e solo in seguito avranno bisogno di accedere a funzionalità di pubblicazione.
Lo scambio di token è supportato sia negli SDK per la trasmissione mobile che in quelli per la trasmissione web. Quando un partecipante scambia un token, la composizione lato server rileva gli attributi aggiornati in tempo reale e regola automaticamente il layout, ad esempio riassegnando lo slot in primo piano, riordinando i partecipanti o spostando un partecipante nella sovrapposizione picture-in-picture, senza richiedere una riconnessione.
Limitazione: lo scambio di token funziona solo con i token creati sul server utilizzando una [coppia di chiavi](https://docs.aws.amazon.com//ivs/latest/RealTimeUserGuide/getting-started-distribute-tokens.html#getting-started-distribute-tokens-self-signed). Non funziona con i token creati tramite l'[API CreateParticipantToken.](https://docs.aws.amazon.com/ivs/latest/RealTimeAPIReference/API_CreateParticipantToken.html)
## Scambio di token
Lo scambio di token è semplice: chiama l'API `exchangeToken` sull'oggetto `Stage` / `IVSStage` e indica il nuovo token. Se le `capabilities` del nuovo token sono diverse da quelle del token precedente, le funzionalità del nuovo token vengono valutate immediatamente. Ad esempio, se il token precedente non ne aveva la funzionalità di `publish`, mentre il nuovo token ne è dotata, vengono invocate le funzioni della strategia della fase per la pubblicazione, che consentono all'applicazione host di decidere se pubblicare subito con la nuova funzionalità o attendere. Lo stesso vale per le funzionalità eliminate: se il token precedente aveva la funzionalità di `publish`, mentre il nuovo token non ne è dotata, il partecipante annulla immediatamente la pubblicazione senza invocare le funzioni della strategia della fase per la pubblicazione.
Quando si scambia un token, il token precedente e quello nuovo devono avere gli stessi valori per i seguenti campi di payload:
+ `topic`
+ `resource`
+ `jti`
+ `whip_url`
+ `events_url`
Questi campi non sono modificabili. Lo scambio di un token che modifica un campo non modificabile comporta il rifiuto immediato dello scambio da parte dell'SDK.
Sarà invece possibile modificare i campi rimanenti, tra i quali:
+ `attributes`
+ `capabilities`
+ `user`
+ `_id`
+ `iat`
+ `exp`
### iOS
```
let stage = try IVSStage(token: originalToken, strategy: self)
stage.join()
stage.exchangeToken(newToken)
```
### Android
```
val stage = Stage(context, originalToken, strategy)
stage.join()
stage.exchangeToken(newToken)
```
### App
```
const stage = new Stage(originalToken, strategy);
await stage.join();
await stage.exchangeToken(newToken);
```
## Ricezione degli aggiornamenti
Una funzione in `StageRenderer` / `IVSStageRenderer` riceve aggiornamenti sugli elementi già pubblicati dai partecipanti remoti che si scambiano i token per aggiornare i propri `userId` o i propri `attributes`. Se i partecipanti remoti non hanno già pubblicato elementi, i rispettivi `userId` e `attributes` verranno esposti tramite le funzioni`onParticipantJoined` / `participantDidJoin` esistenti del renderer solo se alla fine effettuano la pubblicazione.
### iOS
```
class MyStageRenderer: NSObject, IVSStageRenderer {
func stage(_ stage: IVSStage, participantMetadataDidUpdate participant: IVSParticipantInfo) {
// participant will be a new IVSParticipantInfo instance with updated properties.
}
}
```
### Android
```
private val stageRenderer = object : StageRenderer {
override fun onParticipantMetadataUpdated(stage: Stage, participantInfo: ParticipantInfo) {
// participantInfo will be a new ParticipantInfo instance with updated properties.
}
}
```
### App
```
stage.on(StageEvents.STAGE_PARTICIPANT_METADATA_CHANGED, (participantInfo: StageParticipantInfo) => {
// participantInfo properties will be updated with the changed properties
}
);
```
## Visibilità degli aggiornamenti
Quando un partecipante scambia un token per aggiornare il proprio `userId` o i propri `attributes`, la visibilità di queste modifiche dipende dallo stato di pubblicazione corrente:
+ **Se il partecipante *non ha pubblicato elementi*:** l'aggiornamento viene elaborato in modo invisibile. Se alla fine effettua la pubblicazione, tutti gli SDK riceveranno gli `userId` e gli `attributes` aggiornati nell'ambito dell'evento di pubblicazione iniziale.
+ **Se il partecipante *sta* già pubblicando:** l'aggiornamento viene trasmesso immediatamente ai partecipanti che utilizzano gli SDK per dispositivi mobili v1.37.0\+, l'SDK Web e la composizione lato server. I partecipanti che usano SDK per dispositivi mobili precedenti non vedono la modifica finché il partecipante non annulla la pubblicazione e pubblica nuovamente l'elemento.
Questa tabella illustra la matrice di supporto:
| Stato del partecipante | Osservatore: SDK 1.37.0\+ per dispositivi mobili, SDK Web, composizione lato server | Osservatore: SDK mobili meno recenti |
| --- | --- | --- |
| Non pubblica elementi (processo avviato) | ✅ Visibile (in caso di pubblicazione tramite un evento a cui il partecipante ha preso parte) | ✅ Visibile (in caso di pubblicazione tramite un evento a cui il partecipante ha preso parte) |
| Ha pubblicato elementi (nessuna nuova pubblicazione) | ✅ Visibile (immediatamente tramite l'evento aggiornato dei metadati dei partecipanti) | ❌ Non visibile |
| Ha pubblicato elementi (annullamento e nuova pubblicazione) | ✅ Visibile (immediatamente tramite l'evento aggiornato dei metadati dei partecipanti) | ⚠️ Visibilità condizionata (solo in caso di nuova pubblicazione tramite un evento a cui il partecipante ha preso parte) |