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à.
# Servizio di backend e client web Amazon GameLift Streams
Amazon GameLift Streams ti consente di eseguire lo streaming di applicazioni tramite un browser Web. Con Amazon GameLift Streams Web SDK, puoi configurare un servizio di streaming di backend. Quindi, gli utenti finali si connettono a uno stream tramite un client Web. Possono giocare al tuo gioco o interagire con la tua applicazione attraverso il cloud.
L'Amazon GameLift Streams Web SDK include un server di backend di esempio e un client Web di esempio, che puoi utilizzare per iniziare a creare un servizio di backend. Puoi anche utilizzare questi esempi per testare lo streaming di Amazon GameLift Streams, senza ulteriore sviluppo. Per iniziare, consulta. [Configurazione di un server Web e di un client con Amazon GameLift Streams](setting-up-web-sdk.md)
**Topics**
+ [Browser e input supportati](sdk-browsers-input.md)
+ [Porte richieste](required-ports.md)
+ [Configurazione di un server Web e di un client con Amazon GameLift Streams](setting-up-web-sdk.md)
+ [Personalizza l'aspetto dello stream](sdk-stream-appearance.md)
+ [Preferenza locale](sdk-locale-support.md)
+ [Gestione dei movimenti del mouse](sdk-mouse-movement.md)
+ [Comunicazione tramite canale dati tra un'applicazione e un client Web](data-channels.md)
# Browser e input supportati
Di seguito sono elencate le piattaforme e i browser supportati per la visualizzazione degli GameLift stream Amazon Streams e delle relative periferiche di input compatibili. I browser devono inoltre essere compatibili con la codifica video avanzata (AVC), nota anche come H.264.
Nel complesso, consigliamo Google Chrome, Microsoft Edge o un'applicazione desktop personalizzata basata su Chromium per la migliore esperienza utente finale e la massima compatibilità, in particolare con i controller di gioco.
[Per ulteriori informazioni sui controller compatibili con i diversi browser, consulta l'API Web Gamepad.](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API) Sebbene alcune indicazioni potrebbero non essere applicabili ad Amazon GameLift Streams, prevediamo che la maggior parte dei controller di gioco si connetta correttamente tramite Bluetooth.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/gameliftstreams/latest/developerguide/sdk-browsers-input.html)
## Problemi noti
Di seguito sono riportati i problemi noti relativi ai browser e all'input:
+ Safari uscirà immediatamente dalla modalità a schermo intero ogni volta che `Esc` viene premuto. Questo non può essere ignorato.
+ Le visualizzazioni del browser «integrate» o «in-app» come quelle all'interno di app per dispositivi mobili come LinkedIn Yelp, Instagram e altre non sono supportate su iOS. Questi tendono a disabilitare il supporto WebRTC del browser necessario per lo streaming interattivo in tempo reale. Ti consigliamo di rilevare stringhe del browser non standard e di richiedere all'utente di aprirle in Safari.
+ Se la risoluzione dello schermo dell'applicazione non è impostata su 1080p, il tracciamento del mouse potrebbe risentirne. Ti consigliamo di disabilitare la selezione di qualsiasi altra risoluzione, se possibile. Ti consigliamo inoltre di disabilitare la modalità finestra e di eseguirla solo a schermo intero.
+ Per supportare il plug and play dei controller di gioco su Proton, nonostante la mancanza di supporto nelle applicazioni Linux native, i giochi in esecuzione in ambienti di runtime Proton *mostreranno* sempre un controller di gioco connesso, anche se nessuno è collegato al client. Questo potrebbe essere un problema per i giochi che richiedono l'input del controller anche quando il controller è inattivo e inutilizzato. Consigliamo che i giochi mostrino l'interfaccia utente di input in base all'ultimo metodo di input.
## Limitazioni
+ La maggior parte degli ambienti di runtime supporta i controller di gioco, ad eccezione di Ubuntu 22.04 LTS. Se hai bisogno del supporto per i controller di gioco, valuta la possibilità di creare il gioco utilizzando un altro ambiente di runtime. Per un elenco di altri ambienti di runtime, consulta[Ambienti di runtime](configuration-options.md#configuration-options-runtime).
+ I controller di gioco PlayStation 5 e Luna non sono supportati in Firefox.
+ Supporto per il feedback tattile:
+ Il feedback tattile sui S/X controller PlayStation 4 e Xbox Series è supportato in Chrome, Edge e Safari.
+ La tecnologia aptica sul DualSense controller PlayStation 5 è supportata solo nel browser Safari.
+ Firefox non supporta il feedback tattile su nessun controller.
+ I dispositivi Android e iOS non supportano il feedback tattile su nessun controller.
+ La funzione **Test stream** nella console Amazon GameLift Streams non supporta i microfoni.
## IPv6 supporto
Lo streaming su IPv6 solo client è supportato solo con le applicazioni di runtime Windows.
| Runtime | Streaming su IPv4 | Streaming terminato IPv6 |
| --- | --- | --- |
| Microsoft Windows Server 2022 Base | Sì | Sì |
| Ubuntu 22.04 LTS | Sì | No |
| Runtime protoniche | Sì | No |
# Porte richieste
Per integrare Amazon GameLift Streams, assicurati che la tua infrastruttura di rete abbia le porte necessarie aperte e accessibili. Di seguito è riportato un elenco delle porte che dovresti avere aperte sulla tua rete per comunicare con Amazon GameLift Streams.
| Porta | Protocollo | Scopo |
| --- | --- | --- |
| 443 | (HTTPS) TCP | AWS APIs, incluso Amazon GameLift Streams |
| 33435-33465 | UDP | Web RTC |
# Configurazione di un server Web e di un client con Amazon GameLift Streams
In questo tutorial, configurerai un'applicazione client Web che integra il servizio di streaming di Amazon GameLift Streams. Quindi, utilizzerai l'Amazon GameLift Streams Web SDK, una JavaScript libreria e un codice di esempio con cui iniziare. Il codice di esempio include un semplice server Web di backend Amazon GameLift Streams e un semplice client Web. Alla fine di questo tutorial, puoi avviare uno streaming utilizzando il codice di esempio.
Se è la prima volta che usi Amazon GameLift Streams, ti consigliamo vivamente di iniziare con il [Avvio del primo streaming in Amazon GameLift Streams](streaming-process.md) tutorial, che ti spiega come caricare un gioco su Amazon S3 e testare lo streaming dalla console GameLift Amazon Streams nel tuo browser.
## Prerequisiti
+ Un account AWS con credenziali adeguate per l'accesso programmatico. Per ulteriori informazioni, consulta [Configurazione di Amazon GameLift Streams come sviluppatore](setting-up.md).
+ L'SDK AWS.
+ Un browser Web GameLift supportato da Amazon Streams: vedi. [Browser e input supportati](sdk-browsers-input.md)
+ Node.js: consulta la pagina dei [download di Node.js](https://nodejs.org/en/download).
## Scarica il Web SDK
Per questo tutorial, dovrai scaricare i seguenti materiali dalla sezione Risorse della [pagina del prodotto Guida introduttiva](https://aws.amazon.com/gamelift/streams/getting-started/):
+ **Pacchetto Amazon GameLift Streams Web SDK**: include codice di esempio per un semplice servizio di backend e un client Web.
+ Riferimento all'API **Amazon GameLift Streams Web SDK: questo riferimento API** documenta i wrapper API Amazon GameLift Streams per. JavaScript
## Configura le tue risorse di streaming
È necessario disporre di risorse di streaming, un'applicazione e un gruppo di flussi, per avviare uno streaming. In particolare, è necessario disporre di:
+ Un'applicazione con stato **Pronto**.
+ Un gruppo di stream in stato **Attivo** con capacità di streaming disponibile.
+ Per lo streaming in posizioni diverse dalla posizione principale, l'applicazione deve aver terminato la replica in quella posizione.
Per configurare un'applicazione e un gruppo di stream utilizzando la console Amazon GameLift Streams o la GameLift CLI di Amazon Streams, consulta rispettivamente e. [Preparare un'applicazione in Amazon GameLift Streams](applications.md) [Gestisci lo streaming con un gruppo di stream Amazon GameLift Streams](stream-groups.md) In alternativa, per una end-to-end procedura dettagliata nella console Amazon GameLift Streams, consulta. [Avvio del primo streaming in Amazon GameLift Streams](streaming-process.md)
## Configura un server di backend
Il server di backend è responsabile della gestione di attività come l'autenticazione degli utenti, la configurazione dei parametri dello stream e l'esecuzione di chiamate API del servizio Amazon GameLift Streams per conto degli utenti finali. Consulta il codice di esempio e il riferimento all'API Amazon GameLift Streams Web SDK per ulteriori informazioni sulla configurazione. In particolare, consulta il file server.js nel pacchetto Amazon GameLift Streams Web SDK.
**Importante**
Questo codice è un esempio di codice solo a scopo di test e valutazione e non deve essere utilizzato in ambito di produzione.
**Per eseguire il servizio di backend di esempio**
1. Apri un terminale o un prompt dei comandi e accedi alla cartella. `AmazonGameLiftStreamsWebSDK\GameLiftStreamsSampleGamePublisherService\`
1. Esegui i comandi seguenti:
```
npm install
node server.js
```
Con il servizio di backend di esempio in esecuzione, gli utenti finali possono connettersi a uno stream tramite il client web. Prova il client web nel passaggio successivo.
## Avvia un client web
L'applicazione client Web è responsabile della ricezione e della decodifica degli GameLift stream Amazon Streams, dello streaming agli utenti finali e della fornitura dell'interfaccia utente del browser Web per consentire agli utenti finali di interagire con l'applicazione. Consulta il codice di esempio e il riferimento all'API Amazon GameLift Streams Web SDK per ulteriori informazioni su come integrare l' JavaScript Amazon GameLift Streams Web SDK nella tua applicazione client Web. In particolare, vedi `public/index.html` nel pacchetto Amazon GameLift Streams Web SDK. Puoi anche consultare il codice sorgente della pagina Web quando avvii un client Web nel tuo browser.
**Nota**
Il runtime di Windows in Amazon GameLift Streams supporta sessioni di streaming su IPv4 o IPv6. Tuttavia, gli ambienti di runtime Linux e Proton supportano solo lo streaming via. IPv4
**Per avviare un'applicazione client Web**
1. Apri un browser Web e accedi a`http://localhost:port/`. Il numero di porta è impostato dal server di backend; per impostazione predefinita, si tratta della porta HTTP 8000.
1. Gioca o usa il software.
1. Per allegare un input, ad esempio il mouse, scegli **Allega input**.
1. Per uscire dal gioco, scegli il tasto **Esc**.
1. Per interrompere il processo del server, scegli il **tasto Ctrl\$1C**.
## Pulisci le risorse di streaming
**avvertimento**
Un gruppo di stream sostiene dei costi quando ha allocato la capacità di streaming, anche se tale capacità non è utilizzata. Per evitare costi inutili, ridimensiona i gruppi di stream alla dimensione richiesta. Durante lo sviluppo, suggeriamo di ridimensionare a zero la capacità always-on e la capacità target-idle nei gruppi di stream quando non sono in uso. Per ulteriori informazioni, vedi [Ridimensiona i gruppi di stream a capacità zero](pricing.md#pricing-pause-stream-groups).
Dopo aver completato il tutorial e non aver più bisogno di eseguire lo streaming dell'applicazione, segui questi passaggi per ripulire le tue risorse Amazon GameLift Streams.
**Eliminazione di un gruppo di stream**
Quando elimini un gruppo di stream, Amazon GameLift Streams si adopera per liberare tutta la capacità di streaming.
**Per eliminare un gruppo di stream utilizzando la console Amazon GameLift Streams**
1. Accedi Console di gestione AWS e apri la [console Amazon GameLift Streams](https://console.aws.amazon.com/gameliftstreams/).
1. Per visualizzare un elenco dei gruppi di stream esistenti, nel riquadro di navigazione, scegli **Gruppi di stream**.
1. Scegli il nome del gruppo di stream che desideri eliminare.
1. Nella pagina dei dettagli del gruppo di stream, scegli **Elimina**.
1. Nella finestra di dialogo **Elimina**, conferma l'azione di eliminazione.
Amazon GameLift Streams inizia a rilasciare risorse di calcolo e a eliminare il gruppo di stream. **Durante questo periodo, il gruppo di stream è in stato di Eliminazione.** Dopo che Amazon GameLift Streams ha eliminato il gruppo di stream, non puoi più recuperarlo.
**Eliminazione di un'applicazione**
È possibile eliminare solo un’applicazione che soddisfa le seguenti condizioni:
+ L’applicazione deve essere nello stato **Pronto** o **Errore**.
+ Non è in corso lo streaming di nessuna applicazione in nessuna sessione di streaming. Devi attendere che il client termini la sessione di streaming o chiamare [TerminateStreamSession](https://docs.aws.amazon.com/gameliftstreams/latest/apireference/API_TerminateStreamSession.html)l'API Amazon GameLift Streams per terminare lo streaming.
Se l’applicazione è collegata a gruppi di flussi, è necessario scollegarla da tutti i gruppi di flussi associati prima di poterla eliminare. Nella console, una finestra di dialogo suggerisce la procedura.
**Per eliminare un'applicazione utilizzando la console Amazon GameLift Streams**
1. Accedi Console di gestione AWS e apri la [console Amazon GameLift Streams](https://console.aws.amazon.com/gameliftstreams/).
1. Nella barra di navigazione, scegli **Applicazioni** per visualizzare un elenco delle applicazioni esistenti. Scegli l'applicazione che desideri eliminare.
1. Nella pagina dei dettagli dell'applicazione, scegli **Elimina**.
1. Nella finestra di dialogo **Elimina**, confermate l'azione di eliminazione.
Amazon GameLift Streams inizia a eliminare l'applicazione. Durante questo periodo, l'applicazione è in `Deleting` stato. Dopo che Amazon GameLift Streams ha eliminato l'applicazione, non puoi più recuperarla.
# Personalizza l'aspetto dello stream
## Schermata di caricamento
Quando un cliente apre un browser Web per visualizzare uno streaming, il client Web inizia a stabilire una connessione alla sessione di streaming di Amazon GameLift Streams. Durante il caricamento della sessione di streaming, puoi visualizzare uno sfondo e un logo personalizzati sullo schermo del cliente.
Il client di esempio Amazon GameLift Streams Web SDK, nel `GameLiftStreamsSampleGamePublisherService/public/LoadingScreen/loadingscreen.js` file, dimostra come implementare un logo animato nel tuo client Web front-end. La schermata di caricamento predefinita è composta da 2 immagini: sfondo e primo piano. L'immagine in primo piano è posizionata al centro e presenta un'animazione a impulsi. L'animazione viene riprodotta solo durante la connessione della sessione di streaming.
**Per abilitare una schermata di caricamento**
1. Nel client di esempio Amazon GameLift Streams Web SDK, accedi alla `GameLiftStreamsSampleGamePublisherService/public/LoadingScreen/` cartella.
1. Aggiungi le immagini di sfondo e in primo piano utilizzando i nomi predefiniti e. `Background.png` `LoadingLogo.png` Se desideri rinominarle o utilizzare un formato di immagine diverso, devi aggiornare il codice in. `GameLiftStreamsSampleGamePublisherService/public/loadingscreen.js`
1. (Facoltativo) In`GameLiftStreamsSampleGamePublisherService/public/loadingscreen.js`, aggiorna il JavaScript codice per implementare diverse animazioni.
# Preferenza locale
In Amazon GameLift Streams, puoi impostare la preferenza locale per stream. Ciò è utile se l'applicazione recupera informazioni specifiche sulla posizione dal sistema operativo dell'utente finale, come ora o valuta.
Amazon GameLift Streams supporta le seguenti lingue:
| Valore | Description |
| --- | --- |
| `en_US` | Inglese americano (impostazione predefinita) |
| `ja_jp.UTF-8` | Giapponese |
**Per modificare l'impostazione locale**
Quando chiami [StartStreamSession](https://docs.aws.amazon.com/gameliftstreams/latest/apireference/API_StartStreamSession.html)utilizzando l'API Amazon GameLift Streams, aggiungi `LANG=` alla tua`AdditionalEnvironmentVariables`. Poiché la preferenza locale è unica per utente, la imposti a livello di sessione di streaming. Se non lo imposti, per impostazione predefinita lo stream utilizza l'inglese americano.
**Example Esempio**
```
aws gameliftstreams start-stream-session \
--identifier arn:aws:gameliftstreams:us-west-2:123456789012:streamgroup/1AB2C3De4 \
--protocol WebRTC \
--signal-request "[webrtc-ice-offer json string]" \
--user-id xnshijwh \
--additional-environment-variables '{"LANG": "ja_JP.UTF-8"}'
```
# Gestione dei movimenti del mouse
La gestione dei movimenti del mouse è fondamentale per offrire esperienze utente reattive e intuitive nelle applicazioni in streaming. Amazon GameLift Streams ottimizza automaticamente la trasmissione degli input del mouse in base al comportamento del cursore dell'applicazione, assicurando che i movimenti del mouse risultino naturali indipendentemente dal fatto che il cursore sia nascosto o visibile. Comprendere come Amazon GameLift Streams elabora gli eventi del mouse ti aiuta a progettare applicazioni che funzionano perfettamente con il servizio di streaming e offrono la migliore esperienza utente possibile.
## Modalità di immissione del mouse
Amazon GameLift Streams utilizza due modalità distinte per trasmettere gli eventi del mouse all'applicazione, selezionando automaticamente la modalità appropriata in base alla visibilità del cursore:
Modalità relativa
In modalità relativa, gli aggiornamenti del mouse vengono trasmessi come piccole differenze incrementali rispetto alla posizione precedente. Questa modalità è ideale per applicazioni che richiedono un tracciamento preciso e continuo dei movimenti del mouse, come giochi sparatutto in prima persona (FPS) o interfacce che utilizzano l'orientamento 3D. Amazon GameLift Streams utilizza la modalità relativa quando il cursore del sistema operativo è nascosto o completamente trasparente.
Modalità assoluta
In modalità assoluta, la posizione del cursore del mouse viene trasmessa come coordinata esatta dello schermo. Questa modalità è ideale per le applicazioni che si basano sul posizionamento preciso del cursore, come point-and-click giochi o qualsiasi interfaccia utente con elementi cliccabili. Amazon GameLift Streams utilizza la modalità assoluta quando il cursore del sistema operativo è visibile, anche se l'applicazione visualizza un'immagine del cursore personalizzata.
Questa selezione automatica garantisce prestazioni ottimali per diversi tipi di applicazioni senza richiedere la configurazione manuale.
## Blocco a puntatore
Il blocco del puntatore è una funzionalità dell'API Web che cattura il cursore del mouse all'interno di un elemento specifico, nascondendolo e impedendogli di uscire dall'area designata. Questa funzionalità è particolarmente utile per i giochi che richiedono movimenti illimitati del mouse per controllare la fotocamera o mirare, senza la distrazione di un cursore visibile o la limitazione di raggiungere i bordi della finestra.
Amazon GameLift Streams fornisce funzionalità di blocco automatico del puntatore tramite la `autoPointerLock` proprietà nell'interfaccia dell'SDK Web. `InputConfiguration` Questa funzionalità si integra con l'[requestPointerLock API per fornire un'acquisizione del mouse](https://developer.mozilla.org/en-US/docs/Web/API/Element/requestPointerLock) intuitiva e sensibile al contesto.
### Comportamento automatico del blocco del puntatore
Amazon GameLift Streams abilita automaticamente il blocco del puntatore quando l'applicazione è a schermo intero e il cursore remoto è invisibile sull'host di streaming. Questo comportamento si allinea bene ai modelli di sviluppo dei giochi più comuni:
+ **Giochi FPS/TPS e controllo dell'orientamento 3D**: il puntatore si blocca automaticamente e il cursore viene nascosto, garantendo un controllo illimitato della telecamera, essenziale per il gioco FPS.
+ **Point-and-click giochi e controllo dell'interfaccia utente**: quando i giochi rendono visibile il cursore per le interazioni con i menu o il gameplay strategico, il puntatore rimane visibile e sbloccato, preservando l'esperienza utente desiderata.
### Opzioni di configurazione
La `autoPointerLock` proprietà accetta i seguenti valori:
`true`
Il mouse viene sempre catturato quando il cursore remoto è invisibile.
`false`
Il mouse non viene mai catturato, indipendentemente dalla visibilità del cursore.
`'fullscreen'` (predefinito)
Il mouse viene catturato solo quando l'elemento video è in modalità a schermo intero e il cursore remoto è invisibile.
**Importante**
`autoPointerLock`non ha alcun effetto nel browser Safari o sulle piattaforme iOS a causa delle limitazioni della piattaforma.
## Best practice
Per garantire una gestione ottimale del mouse nelle applicazioni in streaming:
+ **Trasmetti sempre in streaming a schermo intero**: l'applicazione dovrebbe già essere in esecuzione in modalità a schermo intero per funzionare correttamente sul nostro servizio. Inoltre, consigliamo di utilizzare il supporto del browser per rendere lo streaming un elemento a tutto schermo per la migliore esperienza dell'utente finale. Ciò contribuirà a evitare problemi come problemi di allineamento tra il cursore di sistema e il cursore del software.
+ **Nascondi il cursore per rilevare un movimento relativo**: se l'applicazione prevede un movimento relativo del mouse (ad esempio controlli della fotocamera in stile FPS o interazioni basate sul trascinamento), nascondi il cursore del sistema operativo durante tali interazioni. In alcuni scenari, potrebbe essere necessario nascondere il cursore con il mouse rivolto verso il basso e mostrarlo nuovamente con il mouse rivolto verso l'alto.
+ **Mostra il cursore per il posizionamento assoluto: quando l'applicazione richiede un posizionamento** preciso del cursore per le interazioni con l'interfaccia utente, assicurati che il cursore del sistema operativo rimanga visibile per abilitare la modalità di coordinate assolute.
+ **Prova diversi scenari di input**: verifica che la tua applicazione gestisca correttamente sia la modalità mouse relativa che quella assoluta, poiché Amazon GameLift Streams può passare da una modalità all'altra in base alle modifiche della visibilità del cursore.
+ **Prova diverse modalità di visualizzazione delle finestre**: verifica la gestione del mouse dell'applicazione sia in modalità finestra che a schermo intero, se applicabile. Determinate quale `autoPointerLock` impostazione è la migliore per la vostra configurazione di input.
# Comunicazione tramite canale dati tra un'applicazione e un client Web
I canali dati consentono di comunicare in modo sicuro messaggi arbitrari tra l'applicazione Amazon GameLift Streams e il client Web (il JavaScript codice in esecuzione nel browser Web dell'utente finale). Ciò consente agli utenti finali di interagire con l'applicazione trasmessa in streaming da Amazon GameLift Streams, tramite il browser Web in cui visualizzano lo streaming.
Ecco alcuni esempi di casi d'uso dei canali dati in Amazon GameLift Streams:
+ Gli utenti possono aprire URLs l'applicazione nel proprio browser locale.
+ Gli utenti possono passare il contenuto degli appunti avanti e indietro all'applicazione.
+ Gli utenti possono caricare contenuti dal proprio computer locale all'applicazione.
+ Gli sviluppatori possono implementare l'interfaccia utente nel browser che invia i comandi all'applicazione.
+ Gli utenti possono passare schemi per controllare la visualizzazione dei livelli di visualizzazione.
## Caratteristiche
**Limiti di dimensione dei messaggi**
Amazon GameLift Streams Web SDK impone un limite di dimensione massima di 64 KB (65536 byte) per messaggio. Ciò garantisce che i limiti di dimensione dei messaggi siano compatibili con la maggior parte dei browser e che la comunicazione abbia un impatto ridotto sulla larghezza di banda totale dello stream.
**Parametri**
Le metriche sull'utilizzo del canale dati vengono inviate al tuo account AWS al termine di una sessione di streaming. Per ulteriori informazioni, consulta la [Canali di dati](monitoring-cloudwatch.md#monitoring-data-channels) sezione *Monitoraggio di Amazon GameLift Streams*.
## Utilizzo dei canali di dati
L'Amazon GameLift Streams Web SDK fornisce la `sendApplicationMessage` funzione che invia un messaggio come array di byte all'applicazione. Il messaggio viene elaborato da una funzione di callback definita dall'utente. `clientConnection.applicationMessage`
Se il client invia messaggi prima che l'applicazione si connetta alla porta del canale dati, i messaggi vengono messi in coda. Quindi, quando l'applicazione si connette, riceve i messaggi. Tuttavia, se l'applicazione invia messaggi prima che il client si connetta alla porta del canale dati, i messaggi vengono persi. L'applicazione deve verificare lo stato della connessione dei client prima di inviare un messaggio.
## Sul lato client
Scrivi il codice seguente nella tua applicazione client web.
1. Definite la funzione di callback per ricevere i messaggi in arrivo dall'applicazione.
```
function streamApplicationMessageCallback(message) {
console.log('Received ' + message.length + ' bytes of message from
Application');
}
```
1. Imposta `clientConnection.applicationMessage` la tua funzione di callback.
```
clientConnection: {
connectionState: streamConnectionStateCallback,
channelError: streamChannelErrorCallback,
serverDisconnect: streamServerDisconnectCallback,
applicationMessage: streamApplicationMessageCallback,
}
```
1. Richiama la `GameLiftStreams.sendApplicationMessage` funzione per inviare messaggi all'applicazione. Puoi chiamarlo in qualsiasi momento, purché la sessione di streaming sia attiva e l'input sia collegato.
Ad esempio, fai riferimento al client di esempio Amazon GameLift Streams Web SDK, che dimostra come configurare un canale dati semplice sul lato client.
## Sul lato dell'applicazione
Scrivi la seguente logica nella tua applicazione.
### Fase 1: Connect alla porta del canale dati
All'avvio dell'applicazione, connettiti alla porta `40712` attiva`localhost`. L'applicazione deve mantenere questa connessione per l'intera durata dell'esecuzione. Se l'applicazione chiude la connessione, non può essere riaperta.
### Fase 2: Ascolta gli eventi
Un evento inizia con un'intestazione a dimensione fissa, seguita da dati associati a lunghezza variabile. Quando l'applicazione riceve un evento, analizza l'evento per recuperare le informazioni.
**Formato degli eventi**
+ **Intestazione: un'intestazione** a 4 byte nel modulo `abcc`
+ `a`: byte identificativo del client. Identifica una connessione client specifica, nel caso di connessioni multiple (dovute alla disconnessione e alla riconnessione).
+ `b`: tipo di evento, byte. `0`- il client è connesso, `1` - il client si è disconnesso, `2` - viene inviato un messaggio dal client. Altri tipi di eventi potrebbero essere ricevuti con i futuri aggiornamenti del servizio Amazon GameLift Streams e dovrebbero essere ignorati.
+ `cc`: lunghezza dei dati relativi agli eventi associati. Viene rappresentata come 2 byte con ordinamento big-endian (il primo byte è il più importante). Se il tipo di evento è 2, i dati dell'evento rappresentano il contenuto del messaggio inviato dal client.
+ **Dati: i** byte rimanenti contengono i dati dell'evento, ad esempio un messaggio client. La lunghezza dei dati è indicata da `cc` nell'intestazione.
**Per ascoltare gli eventi**
1. Leggi i quattro byte di intestazione per recuperare l'ID del client, il tipo di evento e la lunghezza dei dati dell'evento.
1. Leggi i dati degli eventi a lunghezza variabile, indipendentemente dall'ID client e dal tipo di evento, in base alla lunghezza descritta nell'intestazione. È importante leggere i dati incondizionatamente in modo che i dati degli eventi non vengano mai lasciati nel buffer, dove potrebbero essere confusi con l'intestazione dell'evento successivo. Non fate ipotesi sulla lunghezza dei dati in base ai tipi di eventi.
1. Intraprendi le azioni appropriate in base al tipo di evento, se riconosciuto dall'applicazione. Questa azione potrebbe includere la registrazione di una connessione o disconnessione in entrata o l'analisi del messaggio del client e l'attivazione della logica dell'applicazione.
### Fase 3. Trasmetti messaggi al client
L'applicazione deve trasmettere messaggi con lo stesso formato di intestazione a quattro byte utilizzato dagli eventi in entrata.
**Per trasmettere un messaggio al client**
1. Scrivi l'intestazione con le seguenti proprietà:
1. `a`: byte di identificazione del client. Se il messaggio è in risposta a un messaggio del client, dovrebbe riutilizzare lo stesso ID client del messaggio client in entrata, per evitare condizioni estreme, come la trasmissione di una risposta da una vecchia connessione client a un client appena ricollegato. Se l'applicazione sta inviando un messaggio non richiesto al client, deve impostare l'id del client in modo che corrisponda all'evento di «connessione client» più recente (tipo di evento 0).
1. `b`: Il tipo di evento dei messaggi in uscita deve essere sempre 2. Il client ignora i messaggi con altri tipi di eventi.
1. `cc`: lunghezza del messaggio, in byte.
1. Scrivi i byte del messaggio.
Il messaggio viene recapitato al client specificato, a meno che il client non si disconnetta. Quando un client disconnesso si riconnette, viene assegnato un nuovo ID client tramite un evento connesso al client. Tutti i messaggi non recapitati relativi al vecchio ID client vengono eliminati.
**Example**
Il seguente pseudo-codice illustra la logica di comunicazione dei messaggi sul lato dell'applicazione. Per un esempio completo di utilizzo di Winsock, fare riferimento a Complete Winsock Client Code nella documentazione di [Windows Sockets](https://learn.microsoft.com/en-us/windows/win32/winsock/complete-client-code) 2.
```
connection = connect_to_tcp_socket("localhost:40712")
loop:
while has_pending_bytes(connection):
client_id = read_unsigned_byte(connection)
event_type = read_unsigned_byte(connection)
event_length = 256 * read_unsigned_byte(connection)
event_length = event_length + read_unsigned_byte(connection)
event_data = read_raw_bytes(connection, event_length)
if message_type == 0:
app_process_client_connected(client_id)
else if message_type == 1:
app_process_client_disconnected(client_id)
else if message_type == 2:
app_process_client_message(client_id, event_data)
else:
log("ignoring unrecognized event type")
while app_has_outgoing_messages():
target_client_id, message_bytes = app_next_outgoing_message()
message_length = length(message_bytes)
write_unsigned_byte(connection, target_client_id)
write_unsigned_byte(connection, 2)
write_unsigned_byte(connection, message_length / 256)
write_unsigned_byte(connection, message_length mod 256)
write_raw_bytes(connection, message_bytes)
```