Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Service principal et client Web Amazon GameLift Streams
Amazon GameLift Streams vous permet de diffuser des applications via un navigateur Web. Avec le SDK Web Amazon GameLift Streams, vous pouvez configurer un service de streaming principal. Les utilisateurs finaux se connectent ensuite à un flux via un client Web. Ils peuvent jouer à votre jeu ou interagir avec votre application via le cloud.
Le SDK Web Amazon GameLift Streams inclut un exemple de serveur principal et un exemple de client Web, que vous pouvez utiliser pour commencer à créer un service principal. Vous pouvez également utiliser ces exemples pour tester le mode de diffusion d'Amazon GameLift Streams, sans développement supplémentaire. Pour commencer, reportez-vous à[Configuration d'un serveur Web et d'un client avec Amazon GameLift Streams](setting-up-web-sdk.md).
**Topics**
+ [Navigateurs et saisie pris en charge](sdk-browsers-input.md)
+ [Ports requis](required-ports.md)
+ [Configuration d'un serveur Web et d'un client avec Amazon GameLift Streams](setting-up-web-sdk.md)
+ [Personnaliser l'apparence du stream](sdk-stream-appearance.md)
+ [Préférence locale](sdk-locale-support.md)
+ [Gestion des mouvements de la souris](sdk-mouse-movement.md)
+ [Communication par canal de données entre une application et un client Web](data-channels.md)
# Navigateurs et saisie pris en charge
Vous trouverez ci-dessous la liste des plateformes et navigateurs pris en charge pour l'affichage GameLift des flux Amazon Streams et de leurs périphériques d'entrée compatibles. Les navigateurs doivent également être compatibles avec le codage vidéo avancé (AVC), également connu sous le nom de H.264.
Dans l'ensemble, nous recommandons Google Chrome, Microsoft Edge ou une application de bureau personnalisée basée sur Chromium pour une expérience utilisateur optimale et une compatibilité maximale, en particulier avec les manettes de jeu.
Pour en savoir plus sur les manettes compatibles avec les différents navigateurs, consultez l'API [Web Gamepad.](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API) Bien que certaines instructions ne s'appliquent pas à Amazon GameLift Streams, nous pensons que la plupart des manettes de jeu se connectent correctement via Bluetooth.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/gameliftstreams/latest/developerguide/sdk-browsers-input.html)
## Problèmes connus
Les problèmes connus liés aux navigateurs et à la saisie sont les suivants :
+ Safari quittera immédiatement le mode plein écran chaque fois que vous `Esc` appuyez dessus. Cela ne peut pas être annulé.
+ Les vues de navigateur « intégrées » ou « intégrées à l'application », telles que celles des applications mobiles telles que Yelp LinkedIn, Instagram et autres, ne sont pas prises en charge sur iOS. Ils ont tendance à désactiver le support WebRTC du navigateur nécessaire au streaming interactif en temps réel. Nous recommandons de détecter les chaînes de navigateur non standard et d'inviter l'utilisateur à les ouvrir dans Safari.
+ Si la résolution d'écran de votre application n'est pas définie sur 1080p, le suivi de la souris peut être affecté. Nous vous recommandons de désactiver la sélection de toute autre résolution, si possible. Nous recommandons également de désactiver le mode fenêtré et de ne l'exécuter qu'en plein écran.
+ Pour prendre en charge le plug and play des manettes de jeu sur Proton, malgré l'absence de support dans les applications Linux natives, les jeux exécutés dans les environnements d'exécution Proton afficheront *toujours* une manette de jeu connectée, même si aucune n'est branchée sur le client. Cela peut poser problème pour les jeux qui demandent la saisie de la manette même lorsque celle-ci est inactive et inutilisée. Nous recommandons que les jeux affichent l'interface utilisateur en fonction de la dernière méthode de saisie.
## Limitations
+ La plupart des environnements d'exécution sont compatibles avec les manettes de jeu, à l'exception d'Ubuntu 22.04 LTS. Si vous avez besoin de l'assistance d'une manette de jeu, pensez à créer le jeu dans un autre environnement d'exécution. Pour obtenir la liste des autres environnements d'exécution, reportez-vous à[Environnements d'exécution](configuration-options.md#configuration-options-runtime).
+ Les manettes de jeu PlayStation 5 et Luna ne sont pas compatibles avec Firefox.
+ Support du feedback haptique :
+ Le feedback haptique sur les S/X manettes PlayStation 4 et Xbox Series est pris en charge dans Chrome, Edge et Safari.
+ Les touches haptiques de la DualSense manette PlayStation 5 ne sont prises en charge que dans le navigateur Safari.
+ Firefox ne prend en charge le feedback haptique sur aucune manette.
+ Les appareils Android et iOS ne prennent en charge le retour haptique sur aucune manette.
+ La fonctionnalité **Test stream** de la console Amazon GameLift Streams ne prend pas en charge les microphones.
## IPv6 soutien
Le streaming vers des clients IPv6 uniquement n'est pris en charge qu'avec les applications d'exécution Windows.
| Environnement d’exécution | Diffusion en continu IPv4 | Diffusion en continu IPv6 |
| --- | --- | --- |
| Microsoft Windows Server 2022 Base | Oui | Oui |
| Ubuntu 22.04 LTS | Oui | Non |
| Temps d'exécution de Proton | Oui | Non |
# Ports requis
Pour intégrer Amazon GameLift Streams, assurez-vous que les ports nécessaires sont ouverts et accessibles dans votre infrastructure réseau. Voici une liste des ports que vous devriez prévoir d'ouvrir sur votre réseau pour communiquer avec Amazon GameLift Streams.
| Port | Protocole | Objectif |
| --- | --- | --- |
| 443 | (HTTPS) TCP | AWS APIs, y compris Amazon GameLift Streams |
| 33435-33465 | UDP | Internet RTC |
# Configuration d'un serveur Web et d'un client avec Amazon GameLift Streams
Dans ce didacticiel, vous allez configurer une application client Web qui intègre le service de streaming d'Amazon GameLift Streams. Ensuite, vous utiliserez le SDK Web Amazon GameLift Streams, une JavaScript bibliothèque et un exemple de code avec lesquels vous pourrez commencer. L'exemple de code inclut un simple serveur Web principal Amazon GameLift Streams et un simple client Web. À la fin de ce didacticiel, vous pouvez démarrer un flux en utilisant l'exemple de code.
Si c'est la première fois que vous utilisez Amazon GameLift Streams, nous vous recommandons vivement de commencer par le [Démarrage de votre premier stream dans Amazon GameLift Streams](streaming-process.md) didacticiel, qui vous explique comment télécharger un jeu sur Amazon S3 et tester sa diffusion en continu depuis la console Amazon GameLift Streams de votre navigateur.
## Conditions préalables
+ Un compte AWS avec les informations d'identification appropriées pour un accès programmatique. Pour de plus amples informations, veuillez consulter [Configuration d'Amazon GameLift Streams en tant que développeur](setting-up.md).
+ Le kit SDK AWS.
+ Un navigateur Web GameLift compatible avec Amazon Streams — voir. [Navigateurs et saisie pris en charge](sdk-browsers-input.md)
+ Node.js : voir la page de [téléchargement de Node.js](https://nodejs.org/en/download).
## Téléchargez le SDK Web
Pour ce didacticiel, vous devrez télécharger les documents suivants depuis la section Ressources de la [page produit Getting Started](https://aws.amazon.com/gamelift/streams/getting-started/) :
+ **Offre groupée Amazon GameLift Streams Web SDK** : elle inclut un exemple de code pour un service principal et un client Web simples.
+ Référence d'**API du SDK Web Amazon GameLift Streams : cette référence** d'API documente les wrappers d'API Amazon GameLift Streams pour. JavaScript
## Configurez vos ressources de streaming
Vous devez disposer de ressources de flux (une application et un groupe de flux) pour démarrer un flux. Plus précisément, vous devez avoir :
+ Une application à l'état **Prêt**.
+ Un groupe de flux en état **actif** avec une capacité de flux disponible.
+ Pour le streaming dans des emplacements autres que l'emplacement principal, l'application doit avoir terminé la réplication vers cet emplacement.
Pour configurer une application et un groupe de flux à l'aide de la console Amazon GameLift Streams ou de la CLI Amazon GameLift Streams, reportez-vous respectivement à [Préparation d'une candidature dans Amazon GameLift Streams](applications.md) et[Gérez le streaming avec un groupe de GameLift flux Amazon Streams](stream-groups.md). Sinon, pour une end-to-end présentation détaillée de la console Amazon GameLift Streams, reportez-vous à[Démarrage de votre premier stream dans Amazon GameLift Streams](streaming-process.md).
## Configuration d'un serveur principal
Le serveur principal est chargé de gérer les tâches telles que l'authentification des utilisateurs, la configuration des paramètres de flux et l'exécution des appels d'API du service Amazon GameLift Streams pour le compte des utilisateurs finaux. Consultez l'exemple de code et le manuel de référence de l'API du SDK Web Amazon GameLift Streams pour en savoir plus sur sa configuration. Plus précisément, consultez le fichier server.js dans le package Amazon GameLift Streams Web SDK.
**Important**
Ce code est un exemple de code à des fins de test et d'évaluation uniquement et ne doit pas être utilisé dans une capacité de production.
**Pour exécuter l'exemple de service principal**
1. Ouvrez un terminal ou une invite de commande et naviguez jusqu'au dossier`AmazonGameLiftStreamsWebSDK\GameLiftStreamsSampleGamePublisherService\`.
1. Exécutez les commandes suivantes :
```
npm install
node server.js
```
Lorsque l'exemple de service principal est en cours d'exécution, les utilisateurs finaux peuvent se connecter à un flux via le client Web. Testez le client Web à l'étape suivante.
## Lancer un client Web
L'application cliente Web est chargée de recevoir et de décoder les GameLift flux Amazon Streams, de les diffuser aux utilisateurs finaux et de fournir l'interface utilisateur du navigateur Web aux utilisateurs finaux pour qu'ils puissent interagir avec l'application. Consultez l'exemple de code et la référence d'API du SDK Web Amazon GameLift Streams pour en savoir plus sur la façon d'intégrer le SDK Web JavaScript Amazon GameLift Streams dans votre propre application client Web. Plus précisément, consultez `public/index.html` le package Amazon GameLift Streams Web SDK. Vous pouvez également consulter la source de la page Web lorsque vous lancez un client Web dans votre navigateur.
**Note**
Le moteur d'exécution Windows d'Amazon GameLift Streams prend en charge les sessions de streaming sur IPv4 ou IPv6. Cependant, les environnements d'exécution Linux et Proton ne prennent en charge que le streaming IPv4.
**Pour lancer une application cliente Web**
1. Ouvrez un navigateur Web et accédez à`http://localhost:port/`. Le numéro de port est défini par le serveur principal ; par défaut, il s'agit du port HTTP 8000.
1. Jouez au jeu ou utilisez le logiciel.
1. Pour joindre une entrée, telle que votre souris, choisissez **Joindre une entrée**.
1. Pour quitter le jeu, appuyez sur la touche **Esc**.
1. Pour arrêter le processus du serveur, choisissez la touche **Ctrl\$1C**.
## Nettoyez les ressources de streaming
**Avertissement**
Un groupe de flux entraîne des coûts lorsqu'il dispose d'une capacité de diffusion allouée, même si cette capacité n'est pas utilisée. Pour éviter des coûts inutiles, adaptez vos groupes de flux à la taille requise. Au cours du développement, nous vous suggérons de réduire à zéro la capacité permanente et la capacité cible d'inactivité de vos groupes de flux lorsqu'ils ne sont pas utilisés. Pour plus d’informations, consultez [Élargir les groupes de flux à une capacité nulle](pricing.md#pricing-pause-stream-groups).
Une fois que vous avez terminé le didacticiel et que vous n'avez plus besoin de diffuser votre application, procédez comme suit pour nettoyer vos ressources Amazon GameLift Streams.
**Supprimer un groupe de flux**
Lorsque vous supprimez un groupe de flux, Amazon GameLift Streams s'efforce de libérer toute la capacité du flux.
**Pour supprimer un groupe de flux à l'aide de la console Amazon GameLift Streams**
1. Connectez-vous à la [console Amazon GameLift Streams AWS Management Console et ouvrez-la](https://console.aws.amazon.com/gameliftstreams/).
1. Pour afficher la liste de vos groupes de flux existants, dans le volet de navigation, sélectionnez **Groupes de flux**.
1. Choisissez le nom du groupe de flux que vous souhaitez supprimer.
1. Sur la page détaillée du groupe de flux, choisissez **Supprimer**.
1. Dans la boîte de dialogue **Supprimer**, confirmez l'action de suppression.
Amazon GameLift Streams commence à libérer des ressources de calcul et à supprimer le groupe de flux. Pendant ce temps, le groupe de flux est en état de **suppression**. Une fois qu'Amazon GameLift Streams a supprimé le groupe de flux, vous ne pouvez plus le récupérer.
**Supprimer une application**
Vous ne pouvez supprimer qu’une application qui répond aux conditions suivantes :
+ L’application a l’état **Prêt** ou **Erreur**.
+ Aucune application n’est en cours de diffusion lors d’une session de flux en cours. Vous devez attendre que le client mette fin à la session de diffusion ou appeler [TerminateStreamSession](https://docs.aws.amazon.com/gameliftstreams/latest/apireference/API_TerminateStreamSession.html)l'API Amazon GameLift Streams pour mettre fin au flux.
Si l’application est liée à un groupe de flux, vous devez la dissocier de tous les groupes de flux associés avant de pouvoir la supprimer. Dans la console, une boîte de dialogue vous guide tout au long de ce processus.
**Pour supprimer une application à l'aide de la console Amazon GameLift Streams**
1. Connectez-vous à la [console Amazon GameLift Streams AWS Management Console et ouvrez-la](https://console.aws.amazon.com/gameliftstreams/).
1. Dans la barre de navigation, choisissez **Applications** pour afficher la liste de vos applications existantes. Choisissez l'application que vous souhaitez supprimer.
1. Sur la page détaillée de l'application, choisissez **Supprimer**.
1. Dans la boîte de dialogue **Supprimer**, confirmez l'action de suppression.
Amazon GameLift Streams commence à supprimer l'application. Pendant ce temps, le `Deleting` statut de la demande est en cours. Une fois qu'Amazon GameLift Streams a supprimé l'application, vous ne pouvez plus la récupérer.
# Personnaliser l'apparence du stream
## Écran de chargement
Lorsqu'un client ouvre un navigateur Web pour consulter un flux, il commence à établir une connexion à la session de diffusion Amazon GameLift Streams. Pendant le chargement de la session de streaming, vous pouvez afficher un arrière-plan et un logo personnalisés sur l'écran du client.
L'exemple de client Amazon GameLift Streams Web SDK, dans le `GameLiftStreamsSampleGamePublisherService/public/LoadingScreen/loadingscreen.js` fichier, montre comment implémenter un logo animé dans votre client Web frontal. L'écran de chargement par défaut se compose de 2 images : arrière-plan et premier plan. L'image de premier plan est positionnée au milieu et comporte une animation pulsée. L'animation ne s'affiche que lorsque la session de diffusion est connectée.
**Pour activer un écran de chargement**
1. Dans l'exemple de client Amazon GameLift Streams Web SDK, accédez au `GameLiftStreamsSampleGamePublisherService/public/LoadingScreen/` dossier.
1. Ajoutez vos images d'arrière-plan et de premier plan en utilisant les noms par défaut, `Background.png` et`LoadingLogo.png`. Si vous souhaitez les renommer ou utiliser un format d'image différent, vous devez mettre à jour le code dans`GameLiftStreamsSampleGamePublisherService/public/loadingscreen.js`.
1. (Facultatif) Dans`GameLiftStreamsSampleGamePublisherService/public/loadingscreen.js`, mettez à jour le JavaScript code pour implémenter différentes animations.
# Préférence locale
Dans Amazon GameLift Streams, vous pouvez définir les préférences locales par flux. Cela est utile si votre application récupère des informations spécifiques à l'emplacement à partir du système d'exploitation de l'utilisateur final, telles que l'heure ou la devise.
Amazon GameLift Streams prend en charge les langues suivantes :
| Value | Description |
| --- | --- |
| `en_US` | Anglais américain (par défaut) |
| `ja_jp.UTF-8` | Japonais |
**Pour modifier les paramètres régionaux**
Lorsque vous appelez [StartStreamSession](https://docs.aws.amazon.com/gameliftstreams/latest/apireference/API_StartStreamSession.html)à l'aide de l'API Amazon GameLift Streams, ajoutez `LANG=` à votre`AdditionalEnvironmentVariables`. La préférence locale étant unique par utilisateur, vous la définissez au niveau de la session de streaming. Si ce n'est pas le cas, le stream utilise l'anglais américain par défaut.
**Example Exemple**
```
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"}'
```
# Gestion des mouvements de la souris
La gestion des mouvements de la souris est essentielle pour offrir des expériences utilisateur réactives et intuitives dans les applications diffusées en continu. Amazon GameLift Streams optimise automatiquement la transmission des entrées de la souris en fonction du comportement du curseur de votre application, garantissant ainsi que les mouvements de la souris sont naturels, que le curseur soit masqué ou visible. Comprendre comment Amazon GameLift Streams traite les événements liés à la souris vous permet de concevoir des applications qui fonctionnent parfaitement avec le service de streaming et offrent la meilleure expérience utilisateur possible.
## Modes de saisie de la souris
Amazon GameLift Streams utilise deux modes distincts pour transmettre les événements liés à la souris à votre application, en sélectionnant automatiquement le mode approprié en fonction de la visibilité du curseur :
Mode relatif
En mode relatif, les mises à jour de la souris sont transmises sous forme de petites différences incrémentielles par rapport à la position précédente. Ce mode est idéal pour les applications qui nécessitent un suivi précis et continu des mouvements de la souris, comme les jeux de tir à la première personne (FPS) ou les interfaces utilisant l'orientation 3D. Amazon GameLift Streams utilise le mode relatif lorsque le curseur du système d'exploitation est masqué ou totalement transparent.
Mode absolu
En mode absolu, la position du curseur de la souris est transmise sous forme de coordonnées exactes à l'écran. Ce mode fonctionne bien pour les applications qui reposent sur le positionnement précis du curseur, comme les point-and-click jeux ou toute interface utilisateur comportant des éléments cliquables. Amazon GameLift Streams utilise le mode absolu lorsque le curseur du système d'exploitation est visible, même si votre application affiche une image de curseur personnalisée.
Cette sélection automatique garantit des performances optimales pour différents types d'applications sans nécessiter de configuration manuelle.
## Verrou du pointeur
Le verrouillage du pointeur est une fonctionnalité de l'API Web qui capture le curseur de la souris dans un élément spécifique, le masque et l'empêche de quitter la zone désignée. Cette fonctionnalité est particulièrement utile pour les jeux qui nécessitent un mouvement illimité de la souris pour contrôler la caméra ou viser, sans être distrait par un curseur visible ou avoir à atteindre les bords des fenêtres.
Amazon GameLift Streams fournit une fonctionnalité de verrouillage automatique du pointeur via la `autoPointerLock` propriété de l'`InputConfiguration`interface du SDK Web. Cette fonctionnalité s'intègre à l'[requestPointerLock API](https://developer.mozilla.org/en-US/docs/Web/API/Element/requestPointerLock) pour permettre une capture de souris intuitive et contextuelle.
### Comportement du verrouillage automatique du pointeur
Amazon GameLift Streams active automatiquement le verrouillage du pointeur lorsque l'application est en plein écran et que le curseur distant est invisible sur l'hôte du flux. Ce comportement correspond bien aux modèles de développement de jeux courants :
+ **Jeux FPS/TPS et contrôle de l'orientation 3D** - Le pointeur est automatiquement verrouillé et le curseur est masqué, ce qui permet un contrôle illimité de la caméra, essentiel au jeu FPS.
+ **Point-and-click jeux et contrôle de l'interface utilisateur** - Lorsque les jeux rendent le curseur visible pour les interactions dans les menus ou pour les jeux de stratégie, le pointeur reste visible et déverrouillé, préservant ainsi l'expérience utilisateur prévue.
### Options de configuration
L'`autoPointerLock`établissement accepte les valeurs suivantes :
`true`
La souris est toujours capturée lorsque le curseur distant est invisible.
`false`
La souris n'est jamais capturée, quelle que soit la visibilité du curseur.
`'fullscreen'` (default)
La souris n'est capturée que lorsque l'élément vidéo est en mode plein écran et que le curseur de la télécommande est invisible.
**Important**
`autoPointerLock`n'a aucun effet dans le navigateur Safari ou sur les plateformes iOS en raison des limitations de la plate-forme.
## Bonnes pratiques
Pour garantir une manipulation optimale de la souris dans vos applications diffusées en continu :
+ **Diffusez toujours en plein écran** - Votre application devrait déjà fonctionner en mode plein écran pour fonctionner correctement sur notre service. En outre, nous recommandons d'utiliser le support du navigateur pour faire du stream un élément en plein écran afin d'optimiser l'expérience de l'utilisateur final. Cela permettra d'éviter des problèmes tels que les problèmes d'alignement entre le curseur système et le curseur logiciel.
+ **Masquer le curseur pour détecter les mouvements relatifs : si votre application prévoit un mouvement** relatif de la souris (par exemple, des commandes de caméra de type FPS ou des interactions basées sur le glisser-déplacer), masquez le curseur du système d'exploitation lors de ces interactions. Dans certains scénarios, il se peut que vous deviez masquer le curseur lorsque vous maintenez la souris enfoncée et l'afficher à nouveau lorsque vous cliquez dessus.
+ **Afficher le curseur pour un positionnement absolu** - Lorsque votre application a besoin d'un positionnement précis du curseur pour les interactions avec l'interface utilisateur, assurez-vous que le curseur du système d'exploitation reste visible pour activer le mode de coordonnées absolues.
+ **Testez différents scénarios de saisie** : vérifiez que votre application gère correctement les modes de souris relatif et absolu, car Amazon GameLift Streams peut passer d'un mode à l'autre en fonction de l'évolution de la visibilité de votre curseur.
+ **Testez différents modes de fenêtre** - Testez le comportement de la souris de votre application en mode fenêtré et en mode plein écran, le cas échéant. Déterminez le `autoPointerLock` paramètre le mieux adapté à votre configuration d'entrée.
# Communication par canal de données entre une application et un client Web
Les canaux de données vous permettent de communiquer en toute sécurité des messages arbitraires entre votre application Amazon GameLift Streams et le client Web (le JavaScript code s'exécutant dans le navigateur Web de l'utilisateur final). Cela permet aux utilisateurs finaux d'interagir avec l'application diffusée par Amazon GameLift Streams, via le navigateur Web dans lequel ils visionnent le flux.
Voici quelques exemples de cas d'utilisation de canaux de données dans Amazon GameLift Streams :
+ Les utilisateurs peuvent ouvrir URLs l'application dans leur navigateur local.
+ Les utilisateurs peuvent transmettre le contenu du presse-papiers à l'application dans les deux sens.
+ Les utilisateurs peuvent télécharger du contenu depuis leur machine locale vers l'application.
+ Les développeurs peuvent implémenter une interface utilisateur dans le navigateur qui envoie des commandes à l'application.
+ Les utilisateurs peuvent transmettre des schémas pour contrôler l'affichage des couches de visualisation.
## Fonctionnalités
**Limites de taille des messages**
Le SDK Web Amazon GameLift Streams impose une limite de taille maximale de 64 Ko (65536 octets) par message. Cela garantit que les limites de taille des messages sont compatibles avec la plupart des navigateurs et que la communication a un faible impact sur la bande passante totale du flux.
**Métriques**
Les mesures relatives à l'utilisation de vos canaux de données sont envoyées à votre compte AWS à la fin d'une session de streaming. Pour plus d'informations, reportez-vous [Canaux de données](monitoring-cloudwatch.md#monitoring-data-channels) à la section *Monitoring Amazon GameLift Streams*.
## Utilisation des canaux de données
Le SDK Web Amazon GameLift Streams fournit la `sendApplicationMessage` fonction qui envoie un message sous forme de tableau d'octets à l'application. Le message est traité par une fonction de rappel `clientConnection.applicationMessage` que vous définissez.
Si le client envoie des messages avant que l'application ne se connecte au port du canal de données, les messages sont mis en file d'attente. Ensuite, lorsque l'application se connecte, elle reçoit les messages. Toutefois, si l'application envoie des messages avant que le client ne se connecte au port du canal de données, les messages sont perdus. L'application doit vérifier l'état de connexion des clients avant d'envoyer un message.
## Du côté du client
Écrivez le code suivant dans votre application cliente Web.
1. Définissez la fonction de rappel pour recevoir les messages entrants de l'application.
```
function streamApplicationMessageCallback(message) {
console.log('Received ' + message.length + ' bytes of message from
Application');
}
```
1. Réglez `clientConnection.applicationMessage` sur votre fonction de rappel.
```
clientConnection: {
connectionState: streamConnectionStateCallback,
channelError: streamChannelErrorCallback,
serverDisconnect: streamServerDisconnectCallback,
applicationMessage: streamApplicationMessageCallback,
}
```
1. Appelez la `GameLiftStreams.sendApplicationMessage` fonction pour envoyer des messages à votre application. Vous pouvez l'appeler à tout moment, tant que la session de diffusion est active et que l'entrée est jointe.
À titre d'exemple, reportez-vous à l'exemple de client Amazon GameLift Streams Web SDK, qui montre comment configurer un canal de données simple côté client.
## Du côté de l'application
Écrivez la logique suivante dans votre application.
### Étape 1. Connectez-vous au port du canal de données
Lorsque votre application démarre, connectez-vous au port `40712` activé`localhost`. Votre application doit conserver cette connexion pendant toute la durée de son exécution. Si l'application ferme la connexion, elle ne peut pas être rouverte.
### Étape 2. Écoutez les événements
Un événement commence par un en-tête de taille fixe, suivi de données associées de longueur variable. Lorsque votre application reçoit un événement, analysez-le pour récupérer les informations.
**Format d’événement**
+ **En-tête** : un en-tête de 4 octets sous la forme `abcc`
+ `a`: octet d'identifiant du client. Cela permet d'identifier une connexion client spécifique, dans le cas de connexions multiples (en raison d'une déconnexion ou d'une reconnexion).
+ `b`: octet de type d'événement. `0`- le client est connecté, `1` - le client est déconnecté, `2` - un message est envoyé par le client. D'autres types d'événements peuvent être reçus lors des futures mises à jour du service Amazon GameLift Streams et doivent être ignorés.
+ `cc`: longueur des données d'événement associées. Cela est représenté par 2 octets dans un ordre big-endian (le premier octet est le plus significatif). Si le type d'événement est 2, les données de l'événement représentent le contenu du message envoyé par le client.
+ **Données** : Les octets restants contiennent les données de l'événement, telles qu'un message client. La longueur des données est indiquée `cc` dans l'en-tête.
**Pour écouter les événements**
1. Lisez les quatre octets d'en-tête pour récupérer l'identifiant du client, le type d'événement et la longueur des données d'événement.
1. Lisez les données d'événement de longueur variable, quels que soient l'identifiant du client et le type d'événement, conformément à la longueur décrite dans l'en-tête. Il est important de lire les données de manière inconditionnelle afin que les données d'événements ne soient jamais laissées dans la mémoire tampon, où elles pourraient être confondues avec l'en-tête de l'événement suivant. Ne faites pas d'hypothèses sur la longueur des données en fonction des types d'événements.
1. Prenez les mesures appropriées en fonction du type d'événement, s'il est reconnu par votre application. Cette action peut inclure l'enregistrement d'une connexion entrante ou d'une déconnexion, ou l'analyse du message du client et le déclenchement de la logique de l'application.
### Étape 3. Transmettre des messages au client
L'application doit transmettre les messages avec le même format d'en-tête à quatre octets que celui utilisé pour les événements entrants.
**Pour transmettre un message au client**
1. Écrivez l'en-tête avec les propriétés suivantes :
1. `a`: octet d'identifiant du client. Si votre message est une réponse à un message client, il doit utiliser le même identifiant client que le message client entrant, afin d'éviter des situations de course telles que l'envoi d'une réponse depuis une ancienne connexion client à un client récemment reconnecté. Si votre application envoie un message non sollicité au client, elle doit définir l'identifiant du client de manière à ce qu'il corresponde à l'événement de « connexion client » le plus récent (type d'événement 0).
1. `b`: Le type d'événement des messages sortants doit toujours être 2. Le client ignore les messages contenant d'autres types d'événements.
1. `cc`: longueur du message, en octets.
1. Écrivez les octets du message.
Le message est livré au client spécifié, sauf si le client se déconnecte. Lorsqu'un client déconnecté se reconnecte, un nouvel identifiant client est attribué par le biais d'un événement client connecté. Tous les messages non remis correspondant à l'ancien identifiant client sont supprimés.
**Example**
Le pseudo-code suivant illustre la logique de communication des messages côté application. Pour un exemple complet d'utilisation de Winsock, reportez-vous à la section [Complete Winsock Client Code](https://learn.microsoft.com/en-us/windows/win32/winsock/complete-client-code) dans la documentation de Windows Sockets 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)
```