

# SDK del lettore IVS
<a name="player"></a>

Per poter utilizzare Amazon Interactive Video Service (IVS), devi utilizzare il lettore Amazon IVS. Il lettore è una suite multipiattaforma di SDK per la riproduzione di flussi Amazon IVS. È progettato per sfruttare l'architettura di Amazon IVS ed è ottimizzato per la riproduzione di Amazon IVS.

L'unico lettore di cui possiamo garantire le prestazioni è il lettore Amazon IVS. Per avere una bassa latenza, è necessario il lettore Amazon IVS.

Le caratteristiche principali del lettore Amazon IVS sono:
+ **Streaming a bassa latenza**: la bassa latenza è un componente fondamentale nella creazione di buone esperienze utente interattive che migliorano l'esperienza del pubblico. La latenza si insinua in modo incrementale lungo tutto il percorso di trasmissione tra emittente e spettatore, influenzando la velocità di risposta.

  La latenza end-to-end è il ritardo che si verifica da quando un live streaming viene catturato sulla fotocamera a quando viene visualizzato sullo schermo di uno spettatore. Amazon IVS è progettato per fornire una latenza end-to-end bassa (meno di cinque secondi, a seconda della posizione di trasmissione e delle impostazioni dell'emittente). *Per ottenere questa bassa latenza, è necessario utilizzare il lettore Amazon IVS*.
+ **Coerenza multipiattaforma**: gli spettatori guardano le trasmissioni su una varietà di piattaforme. Dai dispositivi mobili ai browser Web, il lettore Amazon IVS offre a tutti gli spettatori un'esperienza simile. Questa coerenza è possibile perché ogni piattaforma utilizza la stessa libreria di funzioni del lettore. La libreria del lettore è un componente integrante dell'architettura di Amazon IVS. L'utilizzo di uno stack video garantisce che tutti i comportamenti di riproduzione video, tra cui la modalità a bassa latenza, i metadati temporizzati, l'analisi, il monitoraggio degli errori, la segnalazione e la registrazione, siano disponibili in modo coerente su tutte le piattaforme supportate.
+ **Streaming in bitrate adattivo (ABR)**. il lettore Amazon IVS utilizza algoritmi ABR ottimizzati per ambienti a bassa latenza. Il lettore misura la qualità del servizio e la disponibilità della larghezza di banda in tempo reale e adatta la qualità video e i livelli di buffer in modo da fornire una riproduzione senza interruzioni. Quando la qualità della connessione è scarsa, ABR passa a un bitrate inferiore; quando invece migliora, passa a un bitrate più elevato.
+ **Metadati temporizzati**: il lettore Amazon IVS supporta *metadata temporizzati* che possono essere utilizzati per creare elementi interattivi come sondaggi e quiz. I metadati sono un insieme di dati che descrive e fornisce informazioni su altri dati. Con i metadati "temporizzati", un codice temporale accompagna la parte dei dati relativi allo stream. Durante la riproduzione, il codice temporale funge da punto di partenza per attivare l'azione in base ai dati, ad esempio:
  + Invio delle statistiche dei giocatori per un flusso sportivo
  + Invio dei dettagli del prodotto per uno streaming di shopping live
  + Invio di domande per uno streaming di quiz dal vivo
+ **Solida gestione degli errori**: la gestione degli errori temporanei consente di evitare interruzioni nell'esperienza di visualizzazione. La solida gestione degli errori del lettore Amazon IVS consente di rilevare numerosi potenziali errori di streaming, passando automaticamente a un rendering alternativo. Gli spettatori continuano a guardare la trasmissione senza interruzioni e senza dover intraprendere alcuna azione correttiva.
+ **Semplicità di integrazione**: l'API del lettore Amazon IVS colma il divario tra le applicazioni dei clienti Amazon IVS e la libreria del lettore. L'API dispone di collegamenti per tutte le piattaforme supportate, semplificando l'integrazione del lettore nelle applicazioni tramite ambienti e tecniche di codifica familiari. Con il pieno controllo sugli elementi dell'interfaccia utente, i clienti possono personalizzare gli aspetti di branding e di presentazione delle loro applicazioni. 

Il lettore Amazon IVS non supporta il casting con Airplay, ma gli sviluppatori possono implementare Airplay trasferendo le sessioni ad AVPlayer. Tuttavia, la latenza in AVPlayer è superiore a quella dell'SDK Amazon IVS Player, quindi il passaggio non avverrà senza soluzione di continuità. Un esempio di come eseguire questa transizione è fornito [qui.](https://github.com/aws-samples/sample-for-airplay-on-ivs)

Il casting con Chromecast può essere implementato all'esterno del lettore utilizzando le app ricevitore Chromecast di default. Tuttavia, la latenza in queste app è superiore a quella dell'SDK Amazon IVS Player, quindi lo switch non sarà senza soluzione di continuità. Consulta anche la nostra documentazione sull'SDK di trasmissione Amazon IVS per[Streaming a bassa latenza](broadcast.md) e [Streaming in tempo reale](https://docs.aws.amazon.com//ivs/latest/RealTimeUserGuide/broadcast.html).

## Requisiti di piattaforma e browser
<a name="player-browser-platform-requirements"></a>

Per informazioni dettagliate sulle ultime versioni rilasciate di vari browser, consulta:
+ [Stato della piattaforma Chrome](https://chromestatus.com/roadmap)
+ [Versioni di Firefox](https://www.mozilla.org/en-US/firefox/releases/)
+ [Pianificazione dei rilasci di Microsoft Edge](https://learn.microsoft.com/en-us/deployedge/microsoft-edge-release-schedule)
+ [Note di rilascio di Safari](https://developer.apple.com/documentation/safari-release-notes)

Sebbene Amazon IVS possa funzionare con alcuni browser meno recenti, non risolviamo i bug relativi ai browser più vecchi.

L'SDK Web del lettore IVS (incluse le integrazioni Video.js e Player JW) non è supportato in ambienti di tipo browser. Tra questi WebViews nativi e “10-foot devices” (TV, console, set-top box) che supportano le applicazioni Web. Contatta il Supporto IVS se non sei sicuro del supporto specifico del browser al di fuori delle tabelle elencate di seguito.

### Browser desktop
<a name="player-browser-platform-requirements-desktop"></a>


| Browser desktop | Piattaforme supportate | Versioni supportate | 
| --- | --- | --- | 
| Chrome | Windows, macOS  | Due versioni principali (versione corrente e precedente più recente)  | 
| Firefox | Windows, macOS | Due versioni principali (versione corrente e precedente più recente) | 
| Edge | Windows 8.1 e versioni successive  | 44.0 e versioni successive In modalità qualità automatica su [Microsoft Edge Legacy](https://support.microsoft.com/en-us/microsoft-edge/what-is-microsoft-edge-legacy-3e779e55-4c55-08e6-ecc8-2333768c0fb0), è supportata solo la riproduzione a latenza normale, non la riproduzione a latenza ultrabassa. La modalità di qualità automatica dipende dall'abilitazione di ABR. Ad esempio, nel lettore Web, consulta `setAutoQualityMode`.  | 
| Safari | macOS | Due versioni principali (versione corrente e precedente più recente)In modalità qualità automatica su Safari per macOS 14 e versioni successive, IVS Player 1.3.0 e versioni successive supporta la riproduzione a latenza ultrabassa. Per le versioni precedenti di Safari e di IVS Player, è supportata solo la riproduzione a latenza normale. Vedi sopra per “Modalità qualità automatica”. | 

### Browser per dispositivi mobili
<a name="player-browser-platform-requirements-mobile"></a>


| Browser per dispositivi mobili | Versioni supportate | 
| --- | --- | 
| Chrome per iOS, Safari per iOS | Due versioni principali (versione corrente e precedente più recente) La riproduzione a latenza ultrabassa non è supportata. È supportata la riproduzione a latenza normale. Questo vincolo si applica a tutti i browser per iOS. (I metadati temporizzati sono supportati solo nel lettore 1.3.0 e versioni successive.) | 
| Chrome per iPadOS, Safari per iPadOS | Due versioni principali (versione corrente e precedente più recente) (Quando è selezionato "Richiedi sito web mobile": [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/ivs/latest/LowLatencyUserGuide/player.html)  | 
| Chrome per Android | Due versioni principali (versione corrente e precedente più recente) | 

### Piattaforme native
<a name="player-browser-platform-requirements-native"></a>


| Piattaforma | Versioni supportate | Dispositivi supportati | 
| --- | --- | --- | 
| Android | 6.0 e versioni successive | Telefoni e tablet | 
| iOS | 14\$1  | Tutti | 

IVS supporta un minimo di 4 versioni principali di iOS e 6 versioni principali di Android. Il nostro supporto per le versioni correnti potrebbe estendersi oltre questi minimi. I clienti verranno avvisati tramite note di rilascio dell'SDK con almeno 3 mesi di anticipo se una versione principale non è più supportata. 

## Riduzione della latenza nei giocatori di terze parti
<a name="player-reducing-latency"></a>

**Per i tipi di canale Basic e Standard**: per ottenere la latenza più bassa possibile, è necessario utilizzare Amazon IVS Player. Nei giocatori di terze parti (incluso iOS Safari), puoi ridurre la latenza a circa 10 secondi utilizzando la seguente configurazione:
+ Imposta l'intervallo dei fotogrammi chiave del tuo codificatore (ad esempio OBS) su 2 secondi o meno.
+ Aggiungi `?keyframeInterval=2` all'URL (RTMPS). Ad esempio, .: `rtmps://a1b2c3d4e5f6.global-contribute.live-video.net:443/app/sk_us-west-2_abcd1234efgh5678ijkl?keyframeInterval=2`

**Nota**: l'intervallo di fotogrammi chiave specificato come parte dell'URL RTMP deve essere maggiore o uguale al valore configurato nel codificatore; in caso contrario, potrebbero verificarsi problemi di riproduzione. È possibile impostare il valore su qualsiasi numero intero compreso tra 2 e 6 inclusi, ma 2 fornisce la latenza più bassa.

**Per i tipi di canali avanzati**: le indicazioni sopra riportate non si applicano. I tipi di canale avanzati generano automaticamente intervalli di fotogrammi chiave per l'efficienza della codifica, con un intervallo di massimo 2 secondi tra i fotogrammi chiave, indipendentemente dall'impostazione dell'intervallo dei fotogrammi chiave della codifica di origine.

### iOS Safari
<a name="player-reducing-latency-ios-safari"></a>

In iOS Safari, puoi ridurre la latenza a circa 6-8 secondi utilizzando il lettore IVS e configurandolo per utilizzare un worker di servizi. Consulta [Configurazione di un worker di servizi](https://docs.aws.amazon.com//ivs/latest/LowLatencyUserGuide/web-getting-started.html#web-service-worker) in *SDK del lettore: Guida per il Web* per i dettagli sull'implementazione e un esempio di riferimento.

**Nota**: per ottenere la latenza più bassa è necessario un flusso IVS con l'intervallo dei fotogrammi chiave impostato su 2 secondi.

## Riproduzione solo audio
<a name="player-audio-only-playback"></a>

Tutti i tipi di canali IVS supportano i rendering solo audio. Ciò può essere particolarmente utile per le applicazioni mobili. Ad esempio, nell'app per dispositivi mobili, è possibile impostare il lettore in modalità rendering solo audio quando l'utente esegue l'applicazione in background per risparmiare larghezza di banda.

Per i canali ADVANCED-SD e ADVANCED-HD, il rendering solo audio viene incluso automaticamente nella playlist multivariante. Per i canali BASIC e STANDARD, è necessario aggiungere il parametro di query `?allow_audio_only=true` all'URL di rendering affinché il rendering solo audio venga incluso. 

Nota: l'SDK IVS Player per il web supporta la riproduzione di solo audio solo nelle versioni 1.24.0 e successive.

## Supporto
<a name="player-support"></a>

Se si verifica un errore di riproduzione o un altro problema di riproduzione con il flusso, determinare l'identificatore univoco della sessione di riproduzione tramite l'API del lettore. 


| Per questo lettore Amazon IVS: | Usa questo: | 
| --- | --- | 
| Android | `sessionId`Funzione   | 
| iOS | `sessionId` Proprietà di `IVSPlayer`  | 
| App | `getSessionId`Funzione  | 

Condividi questo identificatore di sessione di riproduzione con AWS Support. Grazie a questo identificatore, si possono ottenere informazioni utili per risolvere il problema.

**Nota:** il lettore viene continuamente migliorato. Consulta le [Note di rilascio di Amazon IVS](release-notes.md)per le versioni disponibili e i problemi risolti. Se necessario, prima di contattare il supporto, aggiorna la versione del lettore e verifica se il problema è stato risolto.

### Controllo delle versioni
<a name="player-support-versioning"></a>

Gli SDK Amazon IVS Player utilizzano il [controllo semantico delle versioni](https://semver.org/).

Per questa discussione, supponiamo che:
+ La versione più recente sia la 4.1.3.
+ L'ultima versione della versione principale precedente sia 3.2.4.
+ La versione più recente della versione 1.x sia la 1.5.6.

Le nuove funzionalità compatibili con le versioni precedenti vengono aggiunte come versioni secondarie dell'ultima versione. In questo caso, il set successivo di nuove funzionalità verrà aggiunto come versione 4.2.0.

Le correzioni di bug minori compatibili con le versioni precedenti vengono aggiunte come versioni di patch dell'ultima versione. Nel nostro caso, il set di correzioni minori di bug successivo sarà aggiunto come versione 4.1.4.

Le correzioni di bug principali compatibili con le versioni precedenti sono gestite in modo diverso, ovvero vengono aggiunte alle diverse versioni:
+ Rilascio della patch dell'ultima versione. Nel nostro caso, questa è la versione 4.1.4.
+ Rilascio della patch della versione secondaria precedente. Nel nostro caso, questa è la versione 3.2.5.
+ Rilascio di patch dell'ultima versione 1.x. Nel nostro caso, questa è la versione 1.5.7.

Le correzioni di bug principali sono definite dal team di prodotti Amazon IVS. Esempi tipici sono gli aggiornamenti critici della sicurezza e alcune altre correzioni necessarie per i clienti.

**Nota:** negli esempi precedenti, le versioni rilasciate vengono incrementate senza saltare alcun numero (ad esempio, da 4.1.3 a 4.1.4). In realtà, uno o più numeri di patch possono rimanere interni e non essere rilasciati, quindi la versione rilasciata potrebbe aumentare da 4.1.3 a, ad esempio, 4.1.6.

# SDK IVS Player: guida per il web
<a name="player-web"></a>

L'SDK del lettore per il web di Servizio video interattivo Amazon (IVS) può essere integrato con i [framework del lettore](#web-framework-integrations) come Video.js oppure può essere utilizzato da solo su un elemento `<video>` HTML.

**Ultima versione del lettore Web:** 1.50.0 ([Note di rilascio](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar19-26-player-web-ll))

**Documentazione di riferimento:** per informazioni sui metodi più importanti disponibili nel lettore Amazon IVS per il Web, consultare la documentazione di riferimento all'indirizzo [https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).

## Integrazioni di framework
<a name="web-framework-integrations"></a>

L'SDK Amazon IVS Player per il web è progettato per poter essere integrato facilmente con il framework di preferenza. Offriamo un'integrazione ufficiale di Video.js ("tech", in gergo Video.js).

Quello che segue è un breve confronto dei vari lettori Web offerti:


| Tipo di lettore | Descrizione | Interfaccia utente | Plug-in | 
| --- | --- | --- | --- | 
| SDK Amazon IVS Player per il web | Un'opzione leggera e personalizzabile per gli sviluppatori che desiderano un maggiore controllo. | No | No | 
|  [Tecnologia del lettore Amazon IVS per Video.js](player-videojs.md)  | Un'opzione completa, che potrebbe essere appropriata se si utilizza già Video.js e si desidera una soluzione chiavi in mano. | Sì([Skin di Video.js](https://videojs.com/guides/skins/)) | Sì([Plug-in di Video.js](https://videojs.com/plugins/)) | 
|  [Provider del lettore Amazon IVS per JW Player](player-jwplayer.md)  | Un'opzione completa, che potrebbe essere appropriata se si utilizza già JW Player e si desidera una soluzione chiavi in mano. | Sì | N/D | 

# Guida introduttiva all'SDK IVS Player per il web
<a name="web-getting-started"></a>

Questo documento illustra i passaggi necessari per iniziare a utilizzare l'SDK Amazon IVS Player sul web.

Forniamo supporto attraverso un tag `script` così come attraverso un modulo npm. 

## Demo
<a name="web-demo"></a>

La seguente demo live mostra come utilizzare il lettore Web con un tag `script` dalla nostra rete di distribuzione di contenuti (CDN): [esempio di lettore Amazon IVS](https://codepen.io/amazon-ivs/pen/QWbzORP/c3b13a2df34b60ada7756f3a2af8d2f0). La demo include la configurazione di listener di eventi.

Vedi anche [https://github.com/aws-samples/amazon-ivs-player-web-sample](https://github.com/aws-samples/amazon-ivs-player-web-sample) per una selezione di demo aggiuntive del lettore per il web.

## Configurazione con tag di script
<a name="web-setup-script-tag"></a>

Per configurare il lettore Amazon IVS utilizzando il tag `script`:

1. Includere il seguente tag (per l'ultima versione del lettore).

   ```
   <script src="https://player.live-video.net/1.50.0/amazon-ivs-player.min.js"></script>
   ```

1. Una volta caricato `amazon-ivs-player.min.js`, questo aggiungerà una variabile `IVSPlayer` al contesto globale. Questa è la libreria che sarà utilizzata per creare un'istanza del lettore. Innanzitutto, controllare `isPlayerSupported` per determinare se il browser supporta il lettore IVS:

   ```
   if (IVSPlayer.isPlayerSupported) { ... }
   ```

   Quindi, per creare un'istanza del lettore, richiamare la funzione `create` sull'oggetto `IVSPlayer`.

   ```
   const player = IVSPlayer.create();
   ```

   L'SDK Amazon IVS Player per il web utilizza worker web per ottimizzare la riproduzione video.

1. Caricare e riprodurre un flusso utilizzando le funzioni `load` e `play` sull'istanza del lettore:

   ```
   player.load("PLAYBACK_URL");
   player.play();
   ```

   dove `PLAYBACK_URL` è l'URL restituito dall'API di Amazon IVS quando viene richiesta una chiave di flusso.

## Codice di esempio
<a name="web-sample-code"></a>

In questo esempio, sostituire `PLAYBACK_URL` con l'URL del flusso di origine che si desidera caricare. Nell'esempio viene utilizzata la versione più recente del lettore Amazon IVS.

```
<script src="https://player.live-video.net/1.50.0/amazon-ivs-player.min.js"></script>
<video id="video-player" playsinline></video>
<script>
  if (IVSPlayer.isPlayerSupported) {
    const player = IVSPlayer.create();
    player.attachHTMLVideoElement(document.getElementById('video-player'));
    player.load("PLAYBACK_URL");
    player.play();
  }
</script>
```

Nel tag `<video>`, `playsinline` è necessario per la riproduzione in linea su iOS Safari. Consultare [https://webkit.org/blog/6784/new-video-policies-for-ios/](https://webkit.org/blog/6784/new-video-policies-for-ios/).

## Configurazione con NPM
<a name="web-setup-npm"></a>

Per informazioni, incluso un esempio di file di configurazione Webpack, consultare il seguente repository: [https://github.com/aws-samples/amazon-ivs-player-web-sample](https://github.com/aws-samples/amazon-ivs-player-web-sample).

**Nota:** quando si esegue l'hosting delle risorse statiche del lettore dal proprio dominio, è necessario impostare l'intestazione di risposta "Content-Type" per il valore binario WebAssembly (`amazon-ivs-wasmworker.min.wasm`) su "application/wasm". È necessario, inoltre, comprimere in formato gzip le proprie risorse per ridurre i byte scaricati via cavo e migliorare il tempo di avvio della riproduzione del lettore.

## TypeScript
<a name="web-typescript"></a>

Se si usa TypeScript, il pacchetto npm include tipi che potrebbero essere importati e utilizzati. Per informazioni su questi tipi, consultare [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).

## Configurazione di un worker di servizi
<a name="web-service-worker"></a>

Per ridurre ulteriormente la latenza quando si riproduce tramite browser che supportano solo la riproduzione nativa (principalmente iOS Safari), è possibile impostare e configurare un worker di servizi. Per un contesto più approfondito, consulta [Riduzione della latenza nei lettori di terze parti](player.md#player-reducing-latency).

Per configurare il lettore Amazon IVS in modo che utilizzi un worker di servizi:

1. Crea un file per caricare il worker di servizi IVS dalla CDN. Ciò è necessario in quanto i worker di servizi devono essere ospitati sullo stesso dominio della pagina che li richiama.

   Crea un file denominato `amazon-ivs-service-worker-loader.js` o simile e aggiungi la seguente riga:

   ```
   importScripts('https://player.live-video.net/1.50.0/amazon-ivs-service-worker.min.js');
   ```

1. Quando crei un'istanza del lettore, inserisci la seguente configurazione `serviceWorker` che fa riferimento al file `amazon-ivs-service-worker-loader.js`:

   ```
   const player = IVSPlayerPackage.create({
      serviceWorker: {
         url: 'amazon-ivs-service-worker-loader.js'
      }
   });
   ```

1. Nell'elemento video, imposta l'attributo `crossOrigin` su `anonymous`. Ciò è necessario per consentire al worker di servizi di apportare modifiche al manifesto.

**Nota**: per testare il worker di servizi a livello locale, la pagina deve essere fornita da *localhost* o *https*.

Per una demo dal vivo, guarda l'esempio del worker di servizi nel seguente repository:

[https://github.com/aws-samples/amazon-ivs-player-web-sample](https://github.com/aws-samples/amazon-ivs-player-web-sample)

## Riproduzione solo audio
<a name="web-audio-only-playback"></a>

La qualità solo audio deve essere selezionata manualmente con il metodo `setQuality()`. Nota che il lettore non supporta un valore `true` per il secondo argomento, `adaptive`; pertanto, per impostazione predefinita, questo argomento è `false`.

Per impostare la qualità solo audio prima dell'inizio della riproduzione, chiama `setQuality()` all'interno dell'evento `READY`:

```
player.addEventListener(PlayerState.READY, () => {
   const qualities = player.getQualities();
   const audioOnly = qualities.find(q => q.name === 'audio_only');
   if (audioOnly) {
      player.setQuality(audioOnly);
   }
});
```

L'impostazione della qualità all'interno di `READY` funziona sia per la modalità di riproduzione automatica sia per quella non automatica.

## Ottimizzazione della riproduzione in background
<a name="web-optimize-background-playback"></a>

A partire dalla versione SDK 1.45.0, il client può essere configurato per ottimizzare l'utilizzo dei dati durante la riproduzione in una scheda in background. Quando questa funzione è abilitata, dopo la durata specificata il lettore seleziona la qualità video SD più alta, con un massimo di 480p. Il lettore seleziona sempre il video; audio\$1only non è selezionato. Ciò è valido sia per la modalità manuale sia per la modalità auto. Quando la scheda è in primo piano, il lettore torna automaticamente all'impostazione precedente.

Per abilitare questa caratteristica:

```
const player = IVSPlayer.create({
   optimizeBackgroundPlayback: {
      enabled: true,
      switchDelayMs: 60 * 1000,   // Optional, defaults to 60s
   }
});
```

# Utilizzo della policy di sicurezza dei contenuti
<a name="web-content-security-policy"></a>

L'SDK Amazon IVS Player è configurato per funzionare sulle pagine che utilizzano la policy di sicurezza dei contenuti (CSP). Per questa policy devono essere state definite alcune direttive chiave. Qui, descriviamo un insieme minimo di direttive che sono necessarie. A seconda della configurazione specifica, è possibile che siano necessarie ulteriori direttive e fonti.

Le seguenti direttive sono il minimo richiesto per il CSP: 

```
worker-src blob:;
media-src blob:;
connect-src *.live-video.net;
script-src 'wasm-unsafe-eval';
```

**Nota:** le versioni precedenti dei browser potrebbero non riconoscere una o più delle regole del CSP precedenti (ad esempio `wasm-unsafe-eval`) e potrebbero invece richiedere una politica CSP molto indulgente (`unsafe-eval`). Tuttavia, ciò va contro la funzione del CSP per limitare l'esecuzione di un JavaScript pericoloso su una pagina. Invece, come soluzione alternativa, consigliamo di rendere disponibili le risorse della libreria sulla stessa origine della pagina.

# Problemi noti e soluzioni alternative per l'SDK IVS Player per il web
<a name="web-issues"></a>

Questo documento elenca i problemi noti che potresti riscontrare durante l'utilizzo dell'SDK Amazon IVS Player per il web e suggerisce possibili soluzioni alternative.
+ Quando si riproducono contenuti registrati (conosciuti anche come VOD) su un browser per dispositivi mobili iOS (ad esempio, Safari o Chrome), la ricerca all'indietro silenzia l'audio del lettore.

  **Soluzione alternativa:** eseguire una chiamata a `player.setMuted(false)` dopo la ricerca.
+ Quando si riproducono contenuti registrati su un browser per dispositivi mobili iOS, la ricerca all'indietro funziona in modo intermittente quando si seleziona direttamente la posizione desiderata.

  **Soluzione alternativa:** trascinare la barra di ricerca nella posizione desiderata.
+ Quando si riproducono contenuti registrati su un browser per dispositivi mobili iOS, le chiamate `player.seekTo()` non funzionano in modo coerente.

  **Soluzione alternativa:** impostare `currentTime` sull'elemento HTML video dopo l'evento `loadeddata`. Ad esempio:

  ```
  videoEl.addEventListener('loadeddata', () => {
  	videoEl.currentTime = 30; // seek 30s from the beginning
  });
  ```
+ Quando si riproduce un live streaming o un contenuto registrato su un browser per dispositivi mobili iOS, i sottotitoli potrebbero non essere renderizzati in dimensioni diverse e potrebbero essere nuovamente renderizzati più volte.

  **Soluzione alternativa:** nessuna.
+ Quando si riproduce un live streaming o un contenuto registrato su un browser per dispositivi mobili iOS, le chiamate `player.getQualities()` non restituiscono l'elenco delle qualità disponibili.

  **Soluzione alternativa:** nessuna. Sui browser iOS il lettore supporta solo la modalità di qualità automatica.
+ Quando sono abilitati i controlli HTML5 nativi, le chiamate a `setQuality()` vengono ignorate.

  **Soluzione alternativa:** disabilitare i controlli HTML5 prima di effettuare una chiamata `player.setQuality()`.
+ Quando si riproduce un live streaming senza audio su un browser mobile iOS, può verificarsi l'instabilità del giocatore (ad esempio schermo nero o bloccato, buffering) quando si riprende una scheda del giocatore inattiva (ad esempio, cambio di scheda o blocco/sblocco del dispositivo).

  **Soluzione alternativa:** utilizza l'[API di visibilità della pagina JavaScript](https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API) per rilevare le modifiche alla visibilità della pagina e quindi agire di conseguenza sul giocatore. Esempio:

  ```
  //if client platform is iOS
  if (!!navigator.platform && /iPad|iPhone|iPod/.test(navigator.platform)) {
      document.addEventListener(“visibilitychange”, () => {
          if (document.visibilityState === “hidden” && player.isMuted()) {
              player.pause()
          if (document.visibilityState === “visible” &&
              player.getState() != PlayerState.PLAYING) {
              player.play()
          }
      })
  }
  ```
+ Quando si utilizza il Web Player SDK su Safari per iOS, l'autorizzazione alla riproduzione non funziona senza un service worker, a causa del supporto limitato di iOS per le Media Source Extensions (MSE).

  **Soluzione alternativa:** implementare un service worker con Player SDK. Vedi [Configurazione Service Worker](web-getting-started.md#web-service-worker) e questa [demo](https://github.com/aws-samples/amazon-ivs-player-web-sample/blob/master/samples/service-worker/service-worker.ts).

# SDK IVS Player: guida per Android
<a name="player-android"></a>

L'SDK del lettore per Android di Servizio video interattivo Amazon (IVS) fornisce le interfacce necessarie per utilizzare il lettore Amazon IVS su Android.

Garantiamo prestazioni di riproduzione solo per dispositivi mobili Android (telefoni e tablet). Non supportiamo dispositivi Android TV, Fire TV e IoT e simulatori.

Il pacchetto `com.amazonaws.ivs.player` implementa l'interfaccia descritta in questo documento. Sono supportate le seguenti operazioni: 
+ Impostare (inizializzare) un lettore. 
+ Gestire la riproduzione. 
+ Gestire la qualità. 
+ Ricevere eventi. 
+ Ricevere errori. 

**Ultima versione del lettore per Android:** 1.50.0 ([Note di rilascio](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar19-26-player-mobile-ll)) 

**Documentazione di riferimento:** per informazioni sui metodi più importanti disponibili nel lettore Amazon IVS per Android, consultare la documentazione di riferimento all'indirizzo [https://aws.github.io/amazon-ivs-player-docs/1.50.0/android/](https://aws.github.io/amazon-ivs-player-docs/1.50.0/android/).

**Codice di esempio:** vedere il repository di esempio Android su GitHub: [https://github.com/aws-samples/amazon-ivs-player-android-sample](https://github.com/aws-samples/amazon-ivs-player-android-sample).

**Requisiti della piattaforma:** Android 6.0\$1

È disponibile un **Wrapper React Native** per l'SDK Amazon IVS Player. Per il codice e la documentazione, consultare [https://github.com/aws/amazon-ivs-react-native-player](https://github.com/aws/amazon-ivs-react-native-player).

# Guida introduttiva all'SDK IVS Player per Android
<a name="android-getting-started"></a>

Questo documento illustra i passaggi necessari per iniziare a utilizzare l'SDK Amazon IVS Player su Android.

## Installare la libreria
<a name="android-install"></a>

Per aggiungere la libreria del lettore Amazon IVS per Android al proprio ambiente di sviluppo Android, aggiungere la libreria al file `build.gradle` del modulo come mostrato di seguito (per l'ultima versione dell'Amazon IVS Player).

```
repositories {
    mavenCentral()
}
 
dependencies {
     implementation 'com.amazonaws:ivs-player:1.50.0'
}
```

In alternativa, per installare manualmente l'SDK, scaricare la versione più recente da questo percorso:
+ [https://search.maven.org/artifact/com.amazonaws/ivs-player](https://search.maven.org/artifact/com.amazonaws/ivs-player)

## Utilizzo dell'SDK con i simboli di debug
<a name="player-android-using-debug-symbols-ll"></a>

Pubblichiamo anche una versione dell'SDK del lettore Android che include i simboli di debug. È possibile utilizzare questa versione per migliorare la qualità dei report di debug (tracce dello stack) in Firebase Crashlytics se si verificano arresti anomali nell'SDK del lettore IVS, ad esempio `libplayercore.so`. Quando segnali questi arresti anomali al team dell'SDK di IVS, le tracce dello stack di qualità superiore facilitano la risoluzione dei problemi.

Per utilizzare questa versione dell'SDK, nei tuoi file di build di Gradle, sostituisci questa riga:

```
implementation "com.amazonaws:ivs-player:$version@aar"
```

con questa:

```
implementation "com.amazonaws:ivs-player:$version:unstripped@aar"
```

### Caricamento dei simboli in Firebase Crashlytics
<a name="player-android-debug-symbols-ll-firebase-crashlytics"></a>

Assicurati che i tuoi file di build Gradle siano configurati per Firebase Crashlytics. Segui le istruzioni di Google qui:

[https://firebase.google.com/docs/crashlytics/ndk-reports](https://firebase.google.com/docs/crashlytics/ndk-reports)

Assicurati di includere `com.google.firebase:firebase-crashlytics-ndk` come dipendenza.

Quando crei l'app per il rilascio, il plug-in Firebase Crashlytics dovrebbe caricare i simboli automaticamente. Per caricare i simboli manualmente, esegui uno dei comandi seguenti:

```
gradle uploadCrashlyticsSymbolFileRelease
```

```
./gradlew uploadCrashlyticsSymbolFileRelease
```

Non è un problema se i simboli vengono caricati due volte, automaticamente e manualmente.

### Impedire che .apk Release diventi più grande
<a name="player-android-debug-symbols-ll-sizing-apk"></a>

Prima di impacchettare il file `.apk` di rilascio, il plug-in Android Gradle tenta automaticamente di rimuovere le informazioni di debug dalle librerie condivise (inclusa la libreria `libplayercore.so` dell'SDK del lettore IVS). Tuttavia, a volte ciò non accade. In questo caso, il file `.apk` potrebbe diventare più grande e si potrebbe ricevere un messaggio di avviso dal plug-in Android Gradle che indica che non è in grado di rimuovere i simboli di debug e sta impacchettando i file `.so` così come sono. In tal caso, segui questa procedura:
+ Installa un NDK per Android. Va bene qualsiasi versione recente.
+ Aggiungi `ndkVersion <your_installed_ndk_version_number>` al file `build.gradle` dell'applicazione. Fallo anche se l'applicazione non contiene codice nativo.

Per ulteriori informazioni, consulta questo [report sul problema](https://issuetracker.google.com/issues/353554169).

## Configurare il lettore e impostare il listener di eventi
<a name="android-create-player"></a>

L'interfaccia del lettore è `com.amazonaws.ivs.player.Player`. Inizializzare come illustrato di seguito:

```
// Create a player instance
// <this> refers to the current Android Activity
player = Player.Factory.create(this);

// Set up to receive playback events and errors 
player.addListener(this);
```

In alternativa, inizializzare utilizzando `PlayerView`:

```
// Create a player instance
// <this> refers to the current Android Activity
PlayerView playerView = new PlayerView(this);
Player player = playerView.getPlayer();
// Set up to receive playback events and errors 
player.addListener(this);
```

**Nota:** i metodi di callback del listener vengono eseguiti nel thread principale dell'applicazione Android.

## Impostare la visualizzazione della superficie per il video
<a name="android-set-surface-view"></a>

Se non si utilizza una `PlayerView` aggiungere una `SurfaceView` al layout dell'interfaccia utente Android per la visualizzazione di un video. Questa `Surface` deve essere disponibile prima di poter riprodurre qualsiasi flusso video. Esiste la possibilità di accedere alla superficie sottostante tramite l'interfaccia `SurfaceHolder`, che viene recuperata attraverso la chiamata `getHolder()`. (Consultare [SurfaceView](https://developer.android.com/reference/android/view/SurfaceView.html) nella documentazione di riferimento per sviluppatori Android). Utilizzare `SurfaceHolder.Callback` per ricevere eventi sulle modifiche di superficie (consultare [SurfaceHolder.callback](https://developer.android.com/reference/android/view/SurfaceHolder.Callback)).

```
surfaceView = (SurfaceView) findViewById(R.id.surfaceView);
surfaceView.getHolder().addCallback(this);

@Override
public void surfaceCreated(SurfaceHolder holder) {
   this.surface = holder.getSurface();
   if (player != null) {
       player.setSurface(this.surface);
   }
}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
   this.surface = null;
   if (player != null) {
       player.setSurface(null);
   }
}
```

## Riprodurre un flusso
<a name="android-play-stream"></a>

Poiché il flusso viene caricato in modo asincrono, il lettore deve trovarsi in uno stato `READY` prima che l'applicazione possa richiamare il metodo `play` per avviare la riproduzione. Utilizzare l'interfaccia `Player.Listener` per determinare quando il lettore è nello stato corretto.

Consultare il seguente codice di esempio:

```
player.load(Uri.parse(url));

@Override
public void onStateChanged(Player.State state) {
    switch (state) {
        case BUFFERING:
            // player is buffering
            break;
        case READY:
            player.play();
            break;
        case IDLE:
            break;
        case PLAYING:
            // playback started
            break;
     }
}
```

## Rilascio del lettore
<a name="android-release-player"></a>

Il metodo `player.release()` *deve* essere invocato quando il lettore non è più in uso, per liberare le risorse utilizzate dalla biblioteca. In genere ciò può essere fatto nel callback `onDestroy` dell'attività o frammento contenente il lettore.

```
@Override
protected void onDestroy() {
    super.onDestroy();
    player.removeListener(this);
    player.release();
}
```

Dopo il richiamo del metodo `player.release()`, il lettore non può più essere utilizzato.

## Autorizzazioni
<a name="android-permissions"></a>

L'SDK del lettore per Android richiede la seguente autorizzazione: 

```
<uses-permission android:name="android.permission.INTERNET" />
```

Inoltre, queste autorizzazioni facoltative possono migliorare l'esperienza di riproduzione: 

```
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
```

## Sicurezza del thread
<a name="android-thread-safety"></a>

L'API del lettore non è thread-safe. Tutte le chiamate effettuate a un'istanza del lettore devono provenire dallo stesso thread.

## Dimensione dell'SDK
<a name="android-sdk-size"></a>

Gli SDK Amazon IVS Player sono progettati per essere il più leggeri possibile. Per informazioni aggiornate sulle dimensioni dell'SDK, consultare [Note di rilascio](release-notes.md).

**Importante:** quando si valuta l'impatto delle dimensioni, la dimensione dell'AAB/APK prodotto da Android Studio non è rappresentativa della dimensione dell'app scaricata sul dispositivo di un utente. Google Play Store esegue ottimizzazioni per ridurre le dimensioni della propria app. Consigliamo di utilizzare [Bundle di app Android](https://developer.android.com/guide/app-bundle) per distribuire app ottimizzate per ogni configurazione del dispositivo.

# Problemi noti e soluzioni alternative per l'SDK IVS Player per Android
<a name="android-issues"></a>

Questo documento elenca i problemi noti che potresti riscontrare durante l'utilizzo dell'SDK Amazon IVS Player per Android e suggerisce possibili soluzioni alternative.
+ L'SDK del lettore per Android ha una dipendenza di runtime su OkHTTP versione 4.x. L'utilizzo di OkHttp versione 3.x può causare instabilità o arresti anomali a causa di una mancata corrispondenza della firma dell'API e di problemi di compatibilità con le versioni precedenti di OkHttp. Nello specifico, il lettore dipende da OkHttp versione 4.2.2, ma dovrebbe essere compatibile con qualsiasi versione 4.x.

  **Soluzione alternativa:** utilizzare una versione 4.x di OkHttp o rimuovere OkHttp dall'applicazione.
+ Quando si utilizza un emulatore Android 11 (API livello 30), è possibile che si verifichino problemi di layout video (in particolare, lo zoom dello stream).

  **Soluzione alternativa:** avviare la riproduzione sul dispositivo reale.

# SDK IVS Player: Guida per iOS
<a name="player-ios"></a>

Il lettore Amazon Interactive Video Service (IVS) per iOS fornisce le interfacce necessarie per poter utilizzare il lettore Amazon IVS su iOS.

**Ultima versione del lettore per iOS:** 1.50.0 ([Note di rilascio](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar19-26-player-mobile-ll))

**Documentazione di riferimento:** per informazioni sui metodi più importanti disponibili nel lettore Amazon IVS per iOS, consultare la documentazione di riferimento all'indirizzo [https://aws.github.io/amazon-ivs-player-docs/1.50.0/ios/](https://aws.github.io/amazon-ivs-player-docs/1.50.0/ios/).

**Codice di esempio:** consultare il repository di esempio iOS su GitHub: [https://github.com/aws-samples/amazon-ivs-player-ios-sample](https://github.com/aws-samples/amazon-ivs-player-ios-sample).

**Requisiti della piattaforma:** iOS 14\$1

È disponibile un **Wrapper React Native** per l'SDK Amazon IVS Player. Per il codice e la documentazione, consultare [https://github.com/aws/amazon-ivs-react-native-player](https://github.com/aws/amazon-ivs-react-native-player).

# Guida introduttiva all'SDK IVS Player per iOS
<a name="ios-getting-started"></a>

Questo documento illustra i passaggi necessari per iniziare a utilizzare l'SDK Amazon IVS Player su iOS.

Si consiglia di integrare l'SDK del lettore tramite Swift Package Manager. (In alternativa, si può aggiungere il framework al progetto manualmente.)

## Consigliato: Integrare l'SDK del lettore (Swift Package Manager)
<a name="ios-integrate-sdk-swift"></a>

1. Scaricare il file Package.swift da [https://player.live-video.net/1.50.0/Package.swift](https://player.live-video.net/1.50.0/Package.swift).

1. Nel tuo progetto, creare una nuova directory denominata AmazonIVSPlayer e aggiungila al controllo delle versioni.

1. Inserire il file Package.swift file nella nuova directory.

1. In Xcode, vai su **File > Aggiungi dipendenze del pacchetto** e seleziona **Aggiungi locale…**

1. Passare alla directory AmazonIVSPlayer creata e selezionare **Aggiungi pacchetto**.

1. Quando viene richiesto di **scegliere i prodotti del pacchetto per AmazonIVSPlayer**, selezionare **AmazonIVSPlayer** come **prodotto del pacchetto** impostando la destinazione dell'applicazione nella sezione **Aggiungi alla destinazione**.

1. Seleziona **Aggiungi pacchetto**.

## Approccio alternativo: installare manualmente il framework
<a name="ios-install-framework-manually"></a>

1. Scaricare l'ultima versione da [https://player.live-video.net/1.50.0/AmazonIVSPlayer.xcframework.zip](https://player.live-video.net/1.50.0/AmazonIVSPlayer.xcframework.zip).

1. Estrai i contenuti dell'archivio. `AmazonIVSPlayer.xcframework` contiene l'SDK sia per il dispositivo sia per il simulatore.

1. Incorporare `AmazonIVSPlayer.xcframework` trascinandolo nella sezione **Framework, librerie e contenuto incorporato** della scheda **Generali** per il target dell'applicazione:  
![\[La sezione Framework, librerie e contenuto incorporato della scheda Generali per il target dell'applicazione.\]](http://docs.aws.amazon.com/it_it/ivs/latest/LowLatencyUserGuide/images/iOS_Player_SDK_Guide_xcframework.png)

## Creare lettore
<a name="ios-create-player"></a>

L'oggetto lettore è `IVSPlayer`. Può essere inizializzato come illustrato di seguito:

------
#### [ Swift ]

```
import AmazonIVSPlayer

let player = IVSPlayer()
```

------
#### [ Objective-C ]

```
#import <AmazonIVSPlayer/AmazonIVSPlayer.h>

IVSPlayer *player = [[IVSPlayer alloc] init];
```

------

## Configurazione di delegati
<a name="ios-setup-delegate"></a>

I callback delegati forniscono informazioni sullo stato di riproduzione, eventi ed errori. Tutti i callback vengono richiamati nella coda principale.

------
#### [ Swift ]

```
// Self must conform to IVSPlayer.Delegate
player.delegate = self
```

------
#### [ Objective-C ]

```
// Self must conform to IVSPlayer.Delegate
player.delegate = self
```

------

## Visualizzare video
<a name="ios-display-video"></a>

Il lettore visualizza il video in un livello personalizzato, `IVSPlayerLayer`. L'SDK fornisce inoltre `IVSPlayerView`, una sottoclasse `UIView` supportata da questo livello. È possibile usare il più conveniente per l'interfaccia utente dell'applicazione.

In entrambi i casi, visualizzare il video da un'istanza del lettore utilizzando la proprietà `player`.

------
#### [ Swift ]

```
// When using IVSPlayerView:
playerView.player = player

// When using IVSPlayerLayer:
playerLayer.player = player
```

------
#### [ Objective-C ]

```
// When using IVSPlayerView:
playerView.player = player;

// When using IVSPlayerLayer:
playerLayer.player = player;
```

------

## Caricare un flusso
<a name="ios-load-stream"></a>

Il lettore carica il flusso in modo asincrono. Il suo stato indica quando è pronto per la riproduzione.

------
#### [ Swift ]

```
player.load(url)
```

------
#### [ Objective-C ]

```
[player load:url];
```

------

## Riprodurre un flusso
<a name="ios-play-stream"></a>

Quando il lettore è pronto, usare `play` per iniziare la riproduzione. Utilizzare l'interfaccia delegato o l'osservazione di chiavi-valori sulla proprietà `state` per osservare il cambiamento di stato. Di seguito viene riportato un esempio dell'approccio basato su delegati:

------
#### [ Swift ]

```
func player(_ player: IVSPlayer, didChangeState state: IVSPlayer.State) {
    if state == .ready {
        player.play()
    }
}
```

------
#### [ Objective-C ]

```
- (void)player:(IVSPlayer *)player didChangeState:(IVSPlayerState)state {
    if (state == IVSPlayerStateReady) {
        [player play];
    }
}
```

------

## Mettere in pausa quando l'app è in background
<a name="ios-pause-on-app-backgrounding"></a>

Il lettore non supporta la riproduzione mentre l'app è in background, ma non è necessario che venga chiuso del tutto. È sufficiente mettere in pausa; vedere gli esempi di seguito.

------
#### [ Swift ]

```
override func viewDidLoad() {
    super.viewDidLoad()

    NotificationCenter.default.addObserver(self,
        selector: #selector(applicationDidEnterBackground(_:)),
        name: UIApplication.didEnterBackgroundNotification,
        object: nil)
}

@objc func applicationDidEnterBackground(_ notification: NSNotification) {
    playerView?.player?.pause()
}
```

------
#### [ Objective-C ]

```
- (void)viewDidLoad {
    [super viewDidLoad];

    NSNotificationCenter *defaultCenter = NSNotificationCenter.defaultCenter;
    [defaultCenter addObserver:self
                      selector:@selector(applicationDidEnterBackground:)
                          name:UIApplicationDidEnterBackgroundNotification
                        object:nil];
}

- (void)applicationDidEnterBackground:(NSNotification *)notification {
    [playerView.player pause];
}
```

------

## Sicurezza del thread
<a name="ios-thread-safety"></a>

L'API del lettore non è thread-safe. È necessario creare e utilizzare un'istanza del lettore dal thread principale dell'applicazione.

## Dimensione dell'SDK
<a name="ios-sdk-size"></a>

Gli SDK Amazon IVS Player sono progettati per essere il più leggeri possibile. Per informazioni aggiornate sulle dimensioni dell'SDK, consultare [Note di rilascio](release-notes.md).

**Importante:** quando si valuta l'impatto delle dimensioni, la dimensione dell'IPA prodotta da Xcode non è rappresentativa della dimensione dell'app scaricata sul dispositivo di un utente. L'App Store esegue ottimizzazioni per ridurre le dimensioni dell'app.

## Mettere tutto insieme
<a name="ios-putting-together"></a>

Il seguente frammento semplice di controller di visualizzazione carica e riproduce un URL in una visualizzazione del lettore. Tenere presente che la proprietà `playerView` viene inizializzata da un XIB/Storyboard e che la sua classe è impostata su `IVSPlayerView` nell'Interface Builder [utilizzando la sezione Classe personalizzata dell'Inspector dell'identità.](https://developer.apple.com/tutorials/SwiftUI)

------
#### [ Swift ]

```
import AmazonIVSPlayer

class MyViewController: UIViewController {
...
    // Connected in Interface Builder
    @IBOutlet var playerView: IVSPlayerView!

    override func viewDidLoad() {
        super.viewDidLoad()

        NotificationCenter.default.addObserver(self,
            selector: #selector(applicationDidEnterBackground(_:)),
            name: UIApplication.didEnterBackgroundNotification,
            object: nil)
    }

    @objc func applicationDidEnterBackground(_ notification: NSNotification) {
        playerView?.player?.pause()
    }
...
    // Assumes this view controller is already loaded.
    // For example, this could be called by a button tap.
    func playVideo(url videoURL: URL) {
        let player = IVSPlayer()
        player.delegate = self
        playerView.player = player
        player.load(videoURL)
    }
}

extension MyViewController: IVSPlayer.Delegate {
    func player(_ player: IVSPlayer, didChangeState state: IVSPlayer.State) {
        if state == .ready {
            player.play()
        }
    }
}
```

------
#### [ Objective-C ]

```
// MyViewController.h

@class IVSPlayerView;

@interface MyViewController: UIViewController
...
// Connected in Interface Builder
@property (nonatomic) IBOutlet IVSPlayerView *playerView;
...
@end


// MyViewController.m

#import <AmazonIVSPlayer/AmazonIVSPlayer.h>

@implementation MyViewController <IVSPlayerDelegate>
...

- (void)viewDidLoad {
    [super viewDidLoad];

    NSNotificationCenter *defaultCenter = NSNotificationCenter.defaultCenter;
    [defaultCenter addObserver:self
                      selector:@selector(applicationDidEnterBackground:)
                          name:UIApplicationDidEnterBackgroundNotification
                        object:nil];
}

- (void)applicationDidEnterBackground:(NSNotification *)notification {
    [playerView.player pause];
}

// Assumes this view controller is already loaded.
// For example, this could be called by a button tap.
- (void)playVideoWithURL:(NSURL *)videoURL {
    IVSPlayer *player = [[IVSPlayer alloc] init];
    player.delegate = self;
    playerView.player = player;
    [player load:videoURL];
}

- (void)player:(IVSPlayer *)player didChangeState:(IVSPlayerState)state {
    if (state == IVSPlayerStateReady) {
        [player play];
    }
}

...
@end
```

------

# Problemi noti e soluzioni alternative per l'SDK IVS Player per iOS
<a name="ios-issues"></a>

Questo documento elenca i problemi noti che potresti riscontrare durante l'utilizzo dell'SDK Amazon IVS Player per iOS e suggerisce possibili soluzioni alternative.
+ Il lettore potrebbe bloccarsi durante il test con l'architettura arm64e. Ciò si verifica solo quando si definisce il target specifico di arm64e e non si applica alle build dell'App Store.

  **Soluzione alternativa:** non usare arm64e.

# SDK IVS Player: integrazione di Video.js
<a name="player-videojs"></a>

In questo documento sono descritte le funzioni più importanti disponibili nel lettore Video.js di Amazon Interactive Video Service (IVS).

**Ultima versione dell'integrazione del lettore Video.js:** 1.50.0 ([Note di rilascio](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar19-26-player-web-ll))

## Nozioni di base
<a name="videojs-getting-started"></a>

Il supporto Amazon IVS per Video.js viene implementato tramite la [tecnologia](https://videojs.com/guides/tech/) di Video.js. Forniamo supporto attraverso tag di script e attraverso un modulo npm. Amazon IVS supporta le versioni Video.js 7.6.6 e 7\$1 e 8\$1 successive.

Tenere presente che quando si crea un'istanza del lettore, [l'opzione sources](https://videojs.com/guides/options/#sources) di Video.js non è supportata. Invece, è possibile creare un'istanza del lettore normalmente e chiamare la funzione `src()` di Video.js. Se la riproduzione automatica è abilitata, il flusso inizierà la riproduzione; in caso contrario, utilizzare `play()` per avviare la riproduzione.

### Demo
<a name="videojs-demo"></a>

La seguente demo live mostra come utilizzare l'integrazione di Video.js con i tag script dalla nostra rete di distribuzione di contenuti (CDN): [Integrazione del lettore Video.js per Amazon IVS](https://codepen.io/amazon-ivs/pen/NWqewZo/bdc01e977102051eae5fb85482f88276).

### Configurazione con tag di script
<a name="videojs-script-tag-setup"></a>

Per configurare la tecnologia Amazon IVS utilizzando il tag `script`:

1. Includere il seguente tag (per l'ultima versione dell'integrazione del lettore).

   ```
   <script src="https://player.live-video.net/1.50.0/amazon-ivs-videojs-tech.min.js"></script>
   ```

1. Registrare la tecnologia utilizzando la funzione `registerIVSTech`:

   ```
   registerIVSTech(videojs);
   ```

   dove `videojs` è l'oggetto fornito da Video.js.

1. Quando si crea un'istanza del lettore, aggiungere `AmazonIVS`come prima tecnologia nell'opzione `techOrder`.

Quando si crea un'istanza del lettore, [l'opzione sources](https://videojs.com/guides/options/#sources) di Video.js non è supportata. Invece, per impostare l'origine si può creare normalmente un'istanza del lettore e poi richiamare la funzione `src()` di Video.js su di essa. Se la riproduzione automatica è abilitata, il flusso inizierà la riproduzione; in caso contrario, utilizza `play()` per avviare la riproduzione.

### Codice di esempio
<a name="videojs-sample-code"></a>

In questo esempio, `PLAYBACK_URL` è il flusso di origine che si desidera caricare. Nell'esempio viene utilizzata la versione più recente del lettore Amazon IVS.

```
<!doctype html>
<html lang="en">
<head>
    <link href="https://cdnjs.cloudflare.com/ajax/libs/video.js/7.14.3/video-js.css" rel="stylesheet">
    <script src="https://cdnjs.cloudflare.com/ajax/libs/video.js/7.14.3/video.min.js"></script>
    <script src="https://player.live-video.net/1.50.0/amazon-ivs-videojs-tech.min.js"></script>
</head>

<body>
    <div class="video-container">
        <video id="amazon-ivs-videojs" class="video-js vjs-4-3 vjs-big-play-centered" controls autoplay playsinline></video>
    </div>
    <style>
        body {
            margin: 0;
        }

        .video-container {
            width: 640px;
            height: 480px;
            margin: 15px;
        }
    </style>
    <script>
        (function play() {
            // Get playback URL from Amazon IVS API
            var PLAYBACK_URL = '';
            
            // Register Amazon IVS as playback technology for Video.js
            registerIVSTech(videojs);

            // Initialize player
            var player = videojs('amazon-ivs-videojs', {
               techOrder: ["AmazonIVS"]
            }, () => {
               console.log('Player is ready to use!');
               // Play stream
               player.src(PLAYBACK_URL);
            });
        })();
    </script>
</body>
</html>
```

### Configurazione con NPM
<a name="videojs-npm-setup"></a>

Per utilizzare il lettore Amazon IVS tramite npm: 

1. Installare il pacchetto npm [video.js](https://www.npmjs.com/package/video.js/v/7.6.6) o assicurarsi che il progetto abbia qualche altro accesso alla libreria Video.js.

1.  Installare il pacchetto npm `amazon-ivs-player`:

   ```
   npm install amazon-ivs-player
   ```

1. Una volta pronti a registrare la tecnologia Amazon IVS, importare la funzione `registerIVSTech`:

   ```
   import { registerIVSTech } from 'amazon-ivs-player';
   ```

1. Registra la tecnologia utilizzando la funzione `registerIVSTech`:

   ```
   registerIVSTech(videojs, options);
   ```

   dove:
   + `videojs` è l'oggetto fornito da Video.js.
   + `options` sono le opzioni per il livello tecnico di Amazon IVS. Le opzioni supportate sono:
     + `wasmWorker`: l'URL in cui è ospitato il file `amazon-ivs-wasmworker.min.js`.
     + `wasmBinary`: l'URL in cui è ospitato il file `amazon-ivs-wasmworker.min.wasm`.

     I file worker si trovano nella cartella `node_modules/` in `amazon-ivs-player/dist/`. Per utilizzare il lettore IVS, questi file dovranno essere disponibili.

1. Quando si crea un'istanza del lettore, aggiungere `AmazonIVS` come prima tecnologia nell'opzione `techOrder`:

   ```
   const player = videojs('videojs-player', {
       techOrder: ["AmazonIVS"]
   });
   ```

### TypeScript
<a name="videojs-typescript"></a>

Se si sta usando TypeScript, il nostro pacchetto npm include i seguenti tipi da poter importare e utilizzare.
+ `VideoJSEvents`, che descrive la struttura restituita da `getIVSEvents()`.
+ `VideoJSIVSTech`, che descrive l'interfaccia di un'istanza del lettore che utilizza la tecnologia `AmazonIVS`. Ciò può [aggiungersi](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types) al tipo `VideoJsPlayer` utilizzato dal pacchetto npm [@types/video.js](https://www.npmjs.com/package/@types/video.js).
+ `TechOptions`, che descrive l'interfaccia che definisce le opzioni di configurazione che è possibile inviare a `registerIVSTech()`.

Per ulteriori informazioni su questi tipi, consultare [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).

## Eventi
<a name="videojs-events"></a>

Per ascoltare gli eventi Video.js standard, utilizzare la funzione [on](https://docs.videojs.com/docs/api/player.html#Methodson) del lettore Video.js.

Per ascoltare gli eventi specifici di Amazon IVS, aggiungere e rimuovere i listener di eventi sul lettore Web Amazon IVS:

```
player.getIVSPlayer().addEventListener(event, callback);
player.getIVSPlayer().removeEventListener(event, callback);
```

dove `callback` è un callback definito e `event` è una delle seguenti opzioni: `PlayerEventType` o `PlayerState`. Per ulteriori informazioni sugli eventi, consultare [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).

## Errori
<a name="videojs-errors"></a>

Per errori generali Video.js, ascoltare l'evento `error` generico sul lettore:

```
player.on("error", callback);
```

Per gli errori specifici di Amazon IVS, ascoltare il lettore Amazon IVS per i propri errori:

```
let playerEvent = player.getIVSEvents().PlayerEventType;
player.getIVSPlayer().addEventListener(playerEvent.ERROR, callback);
```

Il callback riceverà un oggetto con i seguenti campi:


| Campo | Descrizione | 
| --- | --- | 
| `type` |  Il tipo di errore. Corrisponde agli eventi `ErrorType`. Per ulteriori informazioni, consultare [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).  | 
| `code` | Il codice di errore. | 
| `source` | L'origine dell'errore. | 
| `message` | Un messaggio di errore leggibile dall'utente. | 

## Plug-in
<a name="videojs-plugins"></a>

Forniamo un plugin che crea un interruttore dell'interfaccia utente per le qualità disponibili. Per poter essere utilizzato, questo plugin deve essere caricato includendo il file `amazon-ivs-quality-plugin.min.js` se si sta usando la nostra tecnologia tramite il seguente tag `script` (per l'ultima versione di lettore IVS): 

```
<script src="https://player.live-video.net/1.50.0/amazon-ivs-quality-plugin.min.js"></script>
```

Se si utilizza npm, importare il `registerIVSQualityPlugin` dal modulo `amazon-ivs-player`:

```
import { registerIVSQualityPlugin } from 'amazon-ivs-player';
```

Quindi, una volta creata un'istanza del lettore Video.js, per registrarlo e abilitarlo saranno necessarie le seguenti chiamate:

```
registerIVSQualityPlugin(videojs); // where videojs is the video.js variable
player.enableIVSQualityPlugin(); // where player is the instance of the videojs player
```

Questa operazione creerà un pulsante di menu dell'interfaccia utente che consente di selezionare una qualità per il flusso.

### Plugin e TypeScript
<a name="videojs-plugins-typescript"></a>

Se si sta usando TypeScript, il nostro pacchetto npm include il tipo `VideoJSQualityPlugin` da poter importare e utilizzare con il nostro plugin. I plugin sono essenzialmente misti, quindi l'interfaccia di questo tipo deve essere utilizzata come [tipo di intersezione](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types) con l'interfaccia TypeScript `VideoJSIVSTech`.

## Policy di sicurezza dei contenuti
<a name="videojs-content-security-policy"></a>

L'API Video.js di Amazon IVS è configurata per funzionare sulle pagine che utilizzano le policy di sicurezza dei contenuti (CSP). Consultare la sezione "Utilizzo della policy di sicurezza dei contenuti" nella [SDK IVS Player: guida per il web](web-content-security-policy.md).

## Funzioni
<a name="videojs-functions"></a>

### Riproduzione
<a name="videojs-functions-playback"></a>

L'API Video.js di Amazon IVS supporta le interfacce necessarie per l'uso interno da parte del framework Video.js. È probabile che l'applicazione client non necessiti di utilizzare direttamente questi metodi, poiché Video.js esegue l'integrazione necessaria e presenta un'interfaccia standard. Tuttavia, se necessario, un modo per accedere ai metodi interni di Video.js e del lettore Amazon IVS consiste nell'utilizzare l'oggetto del lettore Video.js in modo da ottenere l'handle dell'oggetto necessario alla tecnologia.

Per accedere all'API, recuperare l'istanza del lettore Video.js come si farebbe normalmente:

```
let player = videojs("videoTagId"); //replace videoTagId with your <video> tag’s id
```

Quindi richiamare le funzioni su quell'istanza.

Di seguito è riportata la serie di funzioni di Video.js che il livello tecnico di Amazon IVS sovrascrive. Per l'elenco completo delle funzioni di Video.js, consultare la [documentazione dell'API Video.js](https://docs.videojs.com/player).


| Funzione | Descrizione e informazioni specifiche su Amazon IVS | 
| --- | --- | 
| `currentTime` |  Ottiene o imposta l'ora, espressa in secondi dall'inizio. Amazon IVS: si consiglia di non impostare l'ora corrente per i live streaming.  | 
| `elimina` | Elimina l'istanza del lettore Amazon IVS: elimina anche il backend tecnologico di Amazon IVS.  | 
| `duration` | Restituisce la durata del video, in secondi. Amazon IVS: per i live streaming, restituisce `Infinity`.  | 
| `caricare` | Inizia a caricare i dati `src()`. Amazon IVS: questa istruzione non genera alcuna operazione.  | 
| `giocare` | Riproduce il flusso che è stato impostato tramite la chiamata `src`. Amazon IVS: se un live streaming è stato messo in pausa, riproduce il live streaming dai fotogrammi più recenti invece di continuare dal punto in cui è stato messo in pausa.   | 
| `playbackRate` | Ottiene o imposta la velocità di riproduzione video. 1.0 significa velocità normale; 0,5 metà velocità normale; 2.0 due volte la velocità normale e così via. Amazon IVS: su un live streaming, un get restituisce 1 e un set viene ignorato.  | 
| `ricercabile` | Restituisce il `TimeRanges` dei supporti in cui può essere effettuata la ricerca. Amazon IVS: per i live streaming, l'invocazione di `end(0)` sul valore restituito (`TimeRange`) restituisce Infinity.  | 

### Specifico per Amazon IVS
<a name="videojs-functions-ivs"></a>

La tecnologia Video.js di Amazon IVS dispone di funzioni aggiuntive per accedere a comportamenti specifici per le funzioni di Amazon IVS:


| Funzione | Descrizione | 
| --- | --- | 
| `getIVSPlayer` |  Restituisce l'istanza del lettore Amazon IVS sottostante. L'API Web completa del lettore Amazon IVS è disponibile tramite questa istanza. Consigliamo di utilizzare il più possibile l'API di riproduzione Video.js di base e di utilizzare questa funzione solo per accedere alle funzionalità specifiche di Amazon IVS. Le funzioni più comuni a cui è probabile che sia necessario accedere sull'istanza del lettore Amazon IVS sono `setQuality()` e `addEventListener()` / `removeEventListener()` .  | 
| `getIVSEvents` | Restituisce un oggetto che contiene enumerazioni specifiche di Amazon IVS. Viene utilizzato per l'ascolto di errori specifici di Amazon IVS. Per ulteriori informazioni, consultare [Eventi](#videojs-events) e [Errori](#videojs-errors).  | 

## currentTime
<a name="videojs-currenttime"></a>

Ottiene o imposta l'ora, espressa in secondi dall'inizio.

Amazon IVS: si consiglia di non impostare l'ora corrente per i live streaming.

### Signatures (Firme)
<a name="videojs-currenttime-signatures"></a>

```
currentTime
currentTime(time)
```

### Parametro
<a name="videojs-currenttime-parameter"></a>


| Parametro | Tipo | Descrizione | 
| --- | --- | --- | 
| `time` | numero |  Se `time` è assente, si ottiene l'ora corrente. Se `time` è presente, imposta la riproduzione video a quell'ora.  | 

### Valore restituito
<a name="videojs-currenttime-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| numero |  L'ora corrente, espressa in secondi dall'inizio.  | 

## elimina
<a name="videojs-dispose"></a>

Elimina l'istanza del lettore.

Amazon IVS: elimina anche il backend tecnologico di Amazon IVS.

### Firma
<a name="videojs-dispose-signatures"></a>

```
dispose()
```

### Parameters
<a name="videojs-dispose-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-dispose-return"></a>

Nessuno

## duration
<a name="videojs-duration"></a>

Restituisce la durata del video, in secondi.

Amazon IVS: per i live streaming, restituisce `Infinity`.

### Firma
<a name="videojs-duration-signatures"></a>

```
duration()
```

### Parameters
<a name="videojs-duration-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-duration-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| numero |  La durata del flusso, in secondi. Per i live streaming, questo valore è `Infinity`.  | 

## getIVSEvents
<a name="videojs-getivsevents"></a>

Restituisce un oggetto che contiene enumerazioni specifiche di Amazon IVS. Viene utilizzato per l'ascolto di errori ed eventi specifici di Amazon IVS. Per ulteriori informazioni, consultare:
+ [Eventi](#videojs-events) e [Errori](#videojs-errors) in questo documento.
+ [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/) per ulteriori informazioni su eventi, tipi di errore e origini di errore.

### Firma
<a name="videojs-getivsevents-signatures"></a>

```
getIVSEvents()
```

### Parameters
<a name="videojs-getivsevents-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-getgetivsevents-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| `object` |  Oggetto con le chiavi `PlayerEventType`, `PlayerState` e `ErrorType` mappate alle loro enumerazioni associate.  | 

## getIVSPlayer
<a name="videojs-getivsplayer"></a>

Restituisce l'istanza del lettore Amazon IVS sottostante. L'API Web completa del lettore Amazon IVS è disponibile tramite questa istanza. Consigliamo di utilizzare il più possibile l'API di riproduzione Video.js di base e di utilizzare questa funzione solo per accedere alle funzionalità specifiche di Amazon IVS. Le funzioni più comuni a cui è probabile che sia necessario accedere sull'istanza del lettore Amazon IVS sono `setQuality()` e `addEventListener()` / `removeEventListener()`.

### Firma
<a name="videojs-getivsplayer-signatures"></a>

```
getIVSPlayer()
```

### Parameters
<a name="videojs-getivsplayer-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-getivsplayer-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| `MediaPlayer` |  L'istanza creata del lettore.  | 

## caricare
<a name="videojs-load"></a>

Inizia a caricare i dati `src()`.

Amazon IVS: questa istruzione non genera alcuna operazione.

### Firma
<a name="videojs-load-signatures"></a>

```
load()
```

### Parameters
<a name="videojs-load-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-load-return"></a>

Nessuno

## giocare
<a name="videojs-play"></a>

Riproduce il flusso che è stato impostato tramite la chiamata `src`.

Amazon IVS: se un live streaming è stato messo in pausa, riproduce il live streaming dai fotogrammi più recenti invece di continuare dal punto in cui è stato messo in pausa.

### Firma
<a name="videojs-play-signatures"></a>

```
play()
```

### Parameters
<a name="videojs-play-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-play-return"></a>

Nessuno

## playbackRate
<a name="videojs-playbackrate"></a>

Ottiene o imposta la velocità di riproduzione video. 1.0 significa velocità normale; 0,5 metà velocità normale; 2.0 due volte la velocità normale e così via.

Amazon IVS: su un live streaming, un get restituisce 1 e un set viene ignorato.

### Signatures (Firme)
<a name="videojs-playbackrate-signatures"></a>

```
playbackRate
playbackRate(rate)
```

### Parametro
<a name="videojs-playbackrate-parameter"></a>


| Parametro | Tipo | Descrizione | 
| --- | --- | --- | 
| `rate` | numero |  La velocità di riproduzione. Valori validi: valori nell'intervallo [0.25, 2.0].  | 

### Valore restituito
<a name="videojs-playbackrate-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| numero |  La velocità di riproduzione.  | 

## ricercabile
<a name="videojs-seekable"></a>

Restituisce il `TimeRanges` dei supporti in cui può essere effettuata la ricerca.

Amazon IVS: per i live streaming, l'invocazione di `end(0)` sul valore restituito (`TimeRange`) restituisce Infinity.

### Firma
<a name="videojs-seekable-signatures"></a>

```
seekable()
```

### Parametro
<a name="videojs-seekable-parameter"></a>

Nessuno

### Valore restituito
<a name="videojs-seekable-return"></a>


| Tipo | Descrizione | 
| --- | --- | 
| `TimeRange` |  TimeRange del supporto che è disponibile per la ricerca.  | 

# SDK IVS Player: integrazione di JW Player
<a name="player-jwplayer"></a>

In questo documento sono descritte le funzioni più importanti disponibili nell'integrazione di Amazon Interactive Video Service (IVS) JW Player.

**Ultima versione dell'integrazione di JW Player:** 1.50.0 ([Note di rilascio](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar19-26-player-web-ll))

## Nozioni di base
<a name="jwplayer-getting-started"></a>

Il supporto Amazon IVS per JW Player viene implementato tramite un provider. Il provider di Amazon IVS è supportato solo sul lettore Web di JW Player. Tale provider viene caricato tramite un tag script e tutti i flussi che richiedono la riproduzione del provider Amazon IVS devono essere contrassegnati con `type: 'ivs'` nella playlist. Amazon IVS supporta JW Player versione 8.18.4 e successive.

### Configurazione
<a name="jwplayer-getting-started-setup"></a>

In queste istruzioni, `JW_PLAYER_DIV` è il nome del `<div>` dell'istanza di JW Player e `IVS_STREAM` è l'URL di riproduzione IVS. Per configurare il provider Amazon IVS e consentire la riproduzione:

1. Includi il seguente tag `script` (per l'ultima versione dell'integrazione del lettore, in questo caso 1.50.0):

   ```
   <script src="https://player.live-video.net/1.50.0/amazon-ivs-jw-provider.min.js"></script>
   ```

1. Utilizzare il tipo `ivs` per contrassegnare gli elementi della playlist IVS. Impostare il valore `cast` nel `setup()` su `null` (poiché Chromecast non è supportato).

   ```
   jwplayer(JW_PLAYER_DIV).setup({
      playlist: [{
         file:IVS_STREAM,
         type: 'ivs',
      }]
   });
   ```

1. Se si desidera un riferimento al lettore Amazon IVS sottostante per effettuare chiamate all'API del lettore Amazon IVS o se si desiderano riferimenti alle enumerazioni specifiche di Amazon IVS per la gestione dei callback, aggiungere un listener all'evento `'providerPlayer'`:

   ```
   jwplayer(JW_PLAYER_DIV).on('providerPlayer', function (player) {
      // player object has 'ivsPlayer' and 'ivsEvents' properties
      // ...callback code...
   });
   ```

### Codice di esempio
<a name="jwplayer-getting-started-code"></a>

In questo esempio, `JW_PLAYER_LIB` è l'URL dello script della libreria di JW Player e `IVS_STREAM` è l'URL di riproduzione IVS.

```
<!DOCTYPE html>
<html lang="en">
<head>
   <script src=JW_PLAYER_LIB></script>
   <script src="https://player.live-video.net/1.50.0/amazon-ivs-jw-provider.min.js"></script>
</head>
<body>
   <div id='player'></div>
   <script>
      // set default values for ivsPlayer and ivsEvents
      var ivsPlayer = {};
      var ivsEvents = {};

      // define our player setup
      const ivsConfig = {
         playlist: [{
            file: IVS_STREAM,
            type: 'ivs',
         }]
      };

      jwplayer('player')
         .setup(ivsConfig)
         .on('providerPlayer', function (player) {
            console.log('Amazon IVS Player: ', player.ivsPlayer);
            console.log('Amazon IVS Player Events: ', player.ivsEvents);

            // store the reference to the Amazon IVS Player
            ivsPlayer = player.ivsPlayer;
            // store the reference to the Amazon IVS Player Events
            ivsEvents = player.ivsEvents;
         });
   </script>
</body>
</html>
```

## Eventi
<a name="jwplayer-events"></a>

Per ascoltare gli eventi standard di JW Player, utilizzare la funzione [on](https://docs.jwplayer.com/players/docs/jw8-reference#event-listening-with-the-jwp-api) di JW Player.

Per ascoltare gli eventi specifici di Amazon IVS o per aggiungere e rimuovere i listener di eventi sul lettore Web Amazon IVS, è necessario ascoltare l'evento `'providerPlayer'` in modo da ottenere un riferimento al lettore Amazon IVS e aggiungere quindi l'ascolto dell'evento su di esso. Ad esempio:

```
// store a default value for ivsPlayer
var ivsPlayer = {};

// store references to the Amazon IVS Player and Amazon IVS Events:
jwplayer(JW_PLAYER_DIV).on('providerPlayer', function (player) {
   ivsPlayer = player.ivsPlayer;
});

// set up event listening
ivsPlayer.addEventListener(event, callback);
ivsPlayer.removeEventListener(event, callback);
```

dove `callback` è un callback definito e `event` è una delle seguenti opzioni: `PlayerEventType`, `PlayerState` o `ErrorType`. Per ulteriori informazioni sugli eventi, consultare [SDK del lettore Amazon IVS: documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).

L'evento `'providerPlayer'` viene emesso da JW Player e il callback che si registra con esso riceverà un oggetto con i seguenti campi:


| Campo | Descrizione | 
| --- | --- | 
|  `ivsPlayer`  |  Restituisce l'istanza del lettore Amazon IVS sottostante. L'API Web completa del lettore Amazon IVS è disponibile tramite questa istanza. Consigliamo di utilizzare il più possibile l'API di riproduzione di base di JW Player e di utilizzare questa funzione solo per accedere alle funzioni specifiche di Amazon IVS. Le funzioni più comuni a cui è probabile che sia necessario accedere sull'istanza del lettore Amazon IVS sono `addEventListener()` e `removeEventListener()`.  | 
|  `ivsEvents`  |  Restituisce un oggetto con i campi `PlayerEventType`, `PlayerState` e `ErrorType`, mappati alle enumerazioni specifiche di Amazon IVS associate. Per ulteriori informazioni, consultare [SDK del lettore Amazon IVS: documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).  | 

## Errori
<a name="jwplayer-errors"></a>

Per gli errori generali di JW Player, utilizzare la funzione [on](https://docs.jwplayer.com/players/docs/jw8-reference#event-listening-with-the-jwp-api) di JW Player per ascoltare gli eventi di errore.

Per gli errori specifici di Amazon IVS, ascoltare il lettore Amazon IVS per i propri errori:

```
// set default values for ivsPlayer and ivsEvents
var ivsPlayer = {};
var ivsEvents = {};

// store references to the Amazon IVS Player and Amazon IVS Events
jwplayer(JW_PLAYER_DIV).on('providerPlayer', function (player) {
   ivsPlayer = player.ivsPlayer;
   ivsEvents = player.ivsEvents;
});

// set up event listening:
let playerEvent = ivsEvents.PlayerEventType;
ivsPlayer.addEventListener(playerEvent.ERROR, callback);
```

Il callback riceverà un oggetto con i seguenti campi:


| Campo | Descrizione | 
| --- | --- | 
|  `type`  |  Il tipo di errore. Corrisponde agli eventi `ErrorType`. Per ulteriori informazioni, consultare [SDK Amazon IVS Player: Documentazione di riferimento per il Web](https://aws.github.io/amazon-ivs-player-docs/1.50.0/web/).  | 
|  `code`  |  Il codice di errore.  | 
|  `source`  |  L'origine dell'errore.  | 
|  `message`  |  Un messaggio di errore leggibile dall'utente.  | 

## Policy di sicurezza dei contenuti
<a name="jwplayer-content-security-policy"></a>

L'API del provider Amazon IVS è configurata per funzionare sulle pagine che utilizzano le policy di sicurezza dei contenuti (CSP). Consultare la sezione "Utilizzo della policy di sicurezza dei contenuti" nella [SDK IVS Player: guida per il web](web-content-security-policy.md).

## Limitazioni
<a name="jwplayer-limitations"></a>

Il provider non supporta il casting. Se il casting nel dashboard di JW Player è stato abilitato, è possibile disabilitarlo impostando `cast` su `null` quando richiami `setup()`. Questa operazione nasconde il pulsante del casting.