# Publication et abonnement avec le SDK de diffusion iOS IVS \| Streaming en temps réel Ce document explique les étapes nécessaires pour la publication et l'abonnement à une étape à l'aide du SDK de diffusion iOS IVS en temps réel. ## Concepts Trois concepts de base sous-tendent la fonctionnalité temps réel : [scène](#ios-publish-subscribe-concepts-stage), [stratégie](#ios-publish-subscribe-concepts-strategy) et [moteur de rendu](#ios-publish-subscribe-concepts-renderer). L’objectif de la conception consiste à minimiser la quantité de logique côté client nécessaire à la création d’un produit fonctionnel. ### Étape La classe `IVSStage` est le principal point d’interaction entre l’application hôte et le kit SDK. La classe représente l’étape elle-même et est utilisée pour rejoindre et quitter l’étape. La création ou la participation à une étape nécessitent une chaîne de jetons valide et non expirée provenant du plan de contrôle (représentée par `token`). Il est très facile de rejoindre une étape et de la quitter. ``` let stage = try IVSStage(token: token, strategy: self) try stage.join() stage.leave() ``` La classe `IVSStage` est également l’endroit où vous pouvez joindre le `IVSStageRenderer` et le `IVSErrorDelegate` : ``` let stage = try IVSStage(token: token, strategy: self) stage.errorDelegate = self stage.addRenderer(self) // multiple renderers can be added ``` ### Strategy Le protocole `IVSStageStrategy` permet à l’application hôte de communiquer l’état de l’étape souhaité au kit SDK. Trois fonctions doivent être mises en œuvre :`shouldSubscribeToParticipant`, `shouldPublishParticipant` et `streamsToPublishForParticipant`. Elles sont toutes abordées ci-dessous. #### Abonnement aux participants ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType ``` Lorsqu’un participant distant rejoint une étape, le kit SDK interroge l’application hôte sur l’état de l’abonnement souhaité pour ce participant. Les options sont `.none`, `.audioOnly` et `.audioVideo`. Lors d’un renvoi d’une valeur pour cette fonction, l’application hôte n’a pas à se soucier de l’état de publication, de l’état actuel de l’abonnement ou de l’état de la connexion de l’étape. Si `.audioVideo` est renvoyé, le kit SDK attend que le participant distant effectue une publication avant de s’abonner, puis il met à jour l’application hôte par le biais du moteur de rendu tout au long du processus. Voici un exemple d’implémentation : ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { return .audioVideo } ``` Il s’agit de l’implémentation complète de cette fonction pour une application hôte qui souhaite toujours que tous les participants se voient mutuellement, comme une application de chat vidéo. Des implémentations plus avancées sont également possibles. Utilisez la propriété `attributes` sur `IVSParticipantInfo` pour vous abonner de manière sélective aux participants en fonction des attributs fournis par le serveur : ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { switch participant.attributes["role"] { case "moderator": return .none case "guest": return .audioVideo default: return .none } } ``` Elle peut servir à créer une scène où les modérateurs peuvent surveiller tous les invités sans être vus ou entendus. L’application hôte pourrait utiliser une logique métier supplémentaire pour permettre aux modérateurs de se voir mutuellement tout en restant invisible pour les invités. #### Configuration d’abonnement aux participants ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration ``` [Lorsqu’un participant distant est abonné (voir Abonnement aux participants](#ios-publish-subscribe-concepts-strategy-participants)), le kit SDK interroge l’application hôte sur une configuration d’abonnement personnalisée pour ce participant. Cette configuration est facultative et permet à l’application hôte de contrôler certains aspects du comportement de l’abonné. Pour plus d’informations sur les options de configuration, consultez [SubscribeConfiguration](https://aws.github.io/amazon-ivs-web-broadcast/docs/sdk-reference/interfaces/SubscribeConfiguration) dans la documentation de référence du kit SDK. Voici un exemple d’implémentation : ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration { let config = IVSSubscribeConfiguration() try! config.jitterBuffer.setMinDelay(.medium()) return config } ``` Cette implémentation met à jour le délai minimum de la mémoire tampon pour tous les participants abonnés à un préréglage de `MEDIUM`. Comme pour `shouldSubscribeToParticipant`, des implémentations plus avancées sont possibles. `ParticipantInfo` peut être utilisé pour mettre à jour de manière sélective la configuration d’abonnement pour des participants spécifiques. Nous recommandons d’utiliser les comportements par défaut. Spécifiez une configuration personnalisée uniquement si vous souhaitez modifier un comportement particulier. #### Publication ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool ``` Une fois connecté à l’étape, le kit SDK interroge l’application hôte pour savoir si un participant en particulier doit effectuer une publication. Elle n’est invoquée que pour les participants locaux autorisés à publier sur la base du jeton fourni. Voici un exemple d’implémentation : ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool { return true } ``` Il s’agit d’une application de chat vidéo standard dans laquelle les utilisateurs souhaitent toujours publier. Ils peuvent désactiver et réactiver leur son et leur vidéo pour être instantanément masqués ou vus/entendus. (Ils peuvent également utiliser la fonction de publication/d’annulation de la publication, mais c’est beaucoup plus lent. Il est préférable de désactiver ou de réactiver le son dans les cas d’utilisation où il est souvent souhaitable de modifier la visibilité.) #### Choix des flux à publier ``` func stage(_ stage: IVSStage, streamsToPublishForParticipant participant: IVSParticipantInfo) -> [IVSLocalStageStream] ``` Lors de la publication, cette fonction est utilisée pour déterminer les flux audio et vidéo à publier. Ce point est abordé plus en détail dans la section [Publier un flux multimédia](#ios-publish-subscribe-publish-stream). #### Mise à jour de la stratégie La stratégie se veut dynamique : les valeurs renvoyées par n’importe laquelle des fonctions ci-dessus peuvent être modifiées à tout moment. Par exemple, si l’application hôte ne souhaite pas publier tant que l’utilisateur final n’a pas appuyé sur un bouton, vous pouvez renvoyer une variable depuis `shouldPublishParticipant` (quelque chose comme `hasUserTappedPublishButton`). Lorsque cette variable change en fonction d’une interaction de l’utilisateur final, appelez `stage.refreshStrategy()` pour signaler au kit SDK qu’il doit interroger la stratégie pour connaître les dernières valeurs, en appliquant uniquement les éléments qui ont changé. Si le kit SDK constate que la valeur `shouldPublishParticipant` a changé, il lance le processus de publication. Si les requêtes du kit SDK et toutes les fonctions renvoient la même valeur qu’auparavant, l’appel `refreshStrategy` n’apportera aucune modification à l’étape. Si la valeur de retour de `shouldSubscribeToParticipant` passe de `.audioVideo` à `.audioOnly`, le flux vidéo sera supprimé pour tous les participants dont les valeurs renvoyées ont été modifiées, s’il existait déjà un flux vidéo. En général, l’étape utilise la stratégie pour appliquer au mieux la différence entre les stratégies précédentes et actuelles, sans que l’application hôte n’ait à se soucier de tout l’état requis pour la gérer correctement. Pour cette raison, et pour réduire les frais, envisagez d’appeler `stage.refreshStrategy()`, car cela ne fait rien à moins que la stratégie ne change. ### Moteur de rendu Le protocole `IVSStageRenderer` communique l’état de l’étape à l’application hôte. Les mises à jour de l’interface utilisateur de l’application hôte peuvent généralement être entièrement optimisées par les événements fournis par le moteur de rendu. Le moteur de rendu fournit les fonctions suivantes : ``` func stage(_ stage: IVSStage, participantDidJoin participant: IVSParticipantInfo) func stage(_ stage: IVSStage, participantDidLeave participant: IVSParticipantInfo) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didChange publishState: IVSParticipantPublishState) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didChange subscribeState: IVSParticipantSubscribeState) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didAdd streams: [IVSStageStream]) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didRemove streams: [IVSStageStream]) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didChangeMutedStreams streams: [IVSStageStream]) func stage(_ stage: IVSStage, didChange connectionState: IVSStageConnectionState, withError error: Error?) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, stream: IVSRemoteStageStream, didChangeStreamAdaption adaption: Bool) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, stream: IVSRemoteStageStream, didChange layers: [IVSRemoteStageStreamLayer]) func stage(_ stage: IVSStage, participant: IVSParticipantInfo, stream: IVSRemoteStageStream, didSelect layer: IVSRemoteStageStreamLayer?, reason: IVSRemoteStageStream.LayerSelectedReason) ``` Les informations fournies par le moteur de rendu ne devraient pas avoir d’impact sur les valeurs de retour de la stratégie. Par exemple, la valeur de retour de `shouldSubscribeToParticipant` ne devrait pas changer lors de l’appel de `participant:didChangePublishState`. Si l’application hôte souhaite s’abonner à un participant en particulier, elle doit renvoyer le type d’abonnement souhaité, quel que soit l’état de publication de ce participant. Le kit SDK est chargé de s’assurer que l’état souhaité de la stratégie est appliqué au bon moment en fonction de l’état de l’étape. Notez que seuls les participants à la publication déclenchent `participantDidJoin` et que chaque fois qu’un participant arrête de publier ou quitte la session de l’étape, `participantDidLeave` est déclenché. ## Publier un flux multimédia Les appareils locaux tels que les microphones et les caméras intégrés sont découverts via `IVSDeviceDiscovery`. Voici un exemple de sélection de la caméra frontale et du microphone par défaut, puis de leur renvoi en tant que `IVSLocalStageStreams` à publier par le SDK : ``` let devices = IVSDeviceDiscovery().listLocalDevices() // Find the camera virtual device, choose the front source, and create a stream let camera = devices.compactMap({ $0 as? IVSCamera }).first! let frontSource = camera.listAvailableInputSources().first(where: { $0.position == .front })! camera.setPreferredInputSource(frontSource) let cameraStream = IVSLocalStageStream(device: camera) // Find the microphone virtual device and create a stream let microphone = devices.compactMap({ $0 as? IVSMicrophone }).first! let microphoneStream = IVSLocalStageStream(device: microphone) // Configure the audio manager to use the videoChat preset, which is optimized for bi-directional communication, including echo cancellation. IVSStageAudioManager.sharedInstance().setPreset(.videoChat) // This is a function on IVSStageStrategy func stage(_ stage: IVSStage, streamsToPublishForParticipant participant: IVSParticipantInfo) -> [IVSLocalStageStream] { return [cameraStream, microphoneStream] } ``` ## Afficher et supprimer des participants Une fois l’abonnement effectué, vous recevrez un tableau d’objets `IVSStageStream` via la fonction `didAddStreams` du moteur de rendu. Pour avoir un aperçu ou recevoir des statistiques de niveau audio concernant ce participant, vous pouvez accéder à l’objet `IVSDevice` sous-jacent depuis le flux : ``` if let imageDevice = stream.device as? IVSImageDevice { let preview = imageDevice.previewView() /* attach this UIView subclass to your view */ } else if let audioDevice = stream.device as? IVSAudioDevice { audioDevice.setStatsCallback( { stats in /* process stats.peak and stats.rms */ }) } ``` Lorsqu’un participant arrête de publier ou en cas de désabonnement, la fonction `didRemoveStreams` est appelée avec les flux qui ont été supprimés. Les applications hôte doivent utiliser ce signal pour supprimer le flux vidéo du participant de la hiérarchie des vues. `didRemoveStreams` est invoqué pour tous les scénarios dans lesquels un flux peut être supprimé, notamment : + Le participant distant arrête de publier. + Un appareil local se désabonne ou modifie l’abonnement de `.audioVideo` en `.audioOnly`. + Le participant distant quitte l’étape. + Le participant local quitte l’étape. Comme `didRemoveStreams` est invoqué pour tous les scénarios, aucune logique métier personnalisée n’est requise pour supprimer des participants de l’interface utilisateur lors des opérations de départ locales ou à distance. ## Désactiver et réactiver le son des flux de médias sociaux Les objets `IVSLocalStageStream` ont une fonction `setMuted` qui contrôle si le son du flux est désactivé. Cette fonction peut être appelée sur le flux avant ou après son renvoi par la fonction de stratégie `streamsToPublishForParticipant`. **Important** : si une nouvelle instance d’objet `IVSLocalStageStream` est renvoyée par `streamsToPublishForParticipant` après un appel à `refreshStrategy`, l’état muet du nouvel objet de flux est appliqué à l’étape. Lorsque vous créez des instances `IVSLocalStageStream`, veillez à ce que l’état muet attendu soit conservé. ## Surveiller l’état muet du contenu multimédia des participants distants Lorsqu’un participant modifie l’état muet de son flux vidéo ou audio, la fonction `didChangeMutedStreams` du moteur de rendu est invoquée avec un tableau des flux qui ont changé. Utilisez la propriété `isMuted` sur `IVSStageStream` pour mettre à jour votre interface utilisateur en conséquence : ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didChangeMutedStreams streams: [IVSStageStream]) { streams.forEach { stream in /* stream.isMuted */ } } ``` ## Création d’une configuration d’étape Pour personnaliser les valeurs de la configuration vidéo d’une étape, utilisez `IVSLocalStageStreamVideoConfiguration` : ``` let config = IVSLocalStageStreamVideoConfiguration() try config.setMaxBitrate(900_000) try config.setMinBitrate(100_000) try config.setTargetFramerate(30) try config.setSize(CGSize(width: 360, height: 640)) config.degradationPreference = .balanced ``` ## Obtenir les statistiques WebRTC Pour obtenir les dernières statistiques WebRTC relatives à un flux de publication ou d’abonnement, utilisez `requestRTCStats` sur `IVSStageStream`. Lorsqu’une collecte est réalisée, vous recevez des statistiques via le `IVSStageStreamDelegate` que vous pouvez définir sur `IVSStageStream`. Pour collecter en permanence des statistiques WebRTC, appelez cette fonction sur un `Timer`. ``` func stream(_ stream: IVSStageStream, didGenerateRTCStats stats: [String : [String : String]]) { for stat in stats { for member in stat.value { print("stat \(stat.key) has member \(member.key) with value \(member.value)") } } } ``` ## Obtenir les attributs des participants Si vous spécifiez des attributs dans la demande de l’opération `CreateParticipantToken`, vous pouvez les voir dans les propriétés `IVSParticipantInfo` : ``` func stage(_ stage: IVSStage, participantDidJoin participant: IVSParticipantInfo) { print("ID: \(participant.participantId)") for attribute in participant.attributes { print("attribute: \(attribute.key)=\(attribute.value)") } } ``` ## Messages intégrés La méthode `embedMessage` sur IVSImageDevice permet d’insérer des données utiles de métadonnées directement dans les images vidéo lors de la publication. Cela permet une messagerie synchronisée avec les images pour les applications en temps réel. L’intégration de messages est disponible uniquement lors de l’utilisation du SDK pour la publication en temps réel (et non pour la publication à faible latence). Les messages intégrés ne sont pas garantis d’arriver aux abonnés, car ils sont intégrés directement dans les images vidéo et transmis via UDP, qui ne garantit pas la livraison des paquets. La perte de paquets pendant la transmission peut entraîner la perte de messages, en particulier dans des conditions réseau médiocres. Pour atténuer ce problème, la méthode `embedMessage` inclut un paramètre `repeatCount` qui duplique le message sur plusieurs images consécutives, augmentant ainsi la fiabilité de la livraison. Cette fonctionnalité est disponible uniquement pour les flux vidéo. ### Utilisation de embedMessage Les clients de publication peuvent intégrer des données utiles de messages dans leur flux vidéo en utilisant la méthode `embedMessage` sur IVSImageDevice. La taille des données utiles doit être supérieure à 0 Ko et inférieure à 1 Ko. Le nombre de messages intégrés insérés par seconde ne doit pas dépasser 10 Ko. ``` let imageDevice: IVSImageDevice = imageStream.device as! IVSImageDevice let messageData = Data("hello world".utf8) do { try imageDevice.embedMessage(messageData, withRepeatCount: 0) } catch { print("Failed to embed message: \(error)") } ``` ### Répétition des données utiles de messages Utilisez `repeatCount` pour dupliquer le message sur plusieurs images afin d’améliorer la fiabilité. La valeur doit être comprise entre 0 et 30. Les clients destinataires doivent disposer d'une logique permettant de dédupliquer le message. ``` try imageDevice.embedMessage(messageData, withRepeatCount: 5) // repeatCount: 0-30, receiving clients should handle duplicates ``` ### Lecture des messages intégrés Consultez la section « Obtenir des informations supplémentaires sur les améliorations (SEI) » ci-dessous pour savoir comment lire les messages intégrés à partir des flux entrants. ## Obtenir des informations supplémentaires sur les améliorations (SEI) L’unité NAL d’informations supplémentaires sur les améliorations (SEI) est utilisée pour stocker des métadonnées alignées sur l’image à côté de la vidéo. Les clients abonnés peuvent lire les données utiles SEI d’un diffuseur de publication qui publie une vidéo H.264 en inspectant la propriété `embeddedMessages` sur les objets `IVSImageDeviceFrame` provenant de l’objet `IVSImageDevice` du diffuseur de publication. Pour ce faire, acquérez `IVSImageDevice` d’un diffuseur de publication, puis observez chaque image via un rappel fourni à `setOnFrameCallback`, comme le montre l’exemple suivant : ``` // in an IVSStageRenderer’s stage:participant:didAddStreams: function, after acquiring the new IVSImageStream let imageDevice: IVSImageDevice? = imageStream.device as? IVSImageDevice imageDevice?.setOnFrameCallback { frame in for message in frame.embeddedMessages { if let seiMessage = message as? IVSUserDataUnregisteredSEIMessage { let seiMessageData = seiMessage.data let seiMessageUUID = seiMessage.UUID // interpret the message's data based on the UUID } } } ``` ## Poursuivre la session en arrière-plan Lorsque l’application passe en arrière-plan, vous pouvez rester dans l’étape tout en écoutant le son distant, mais il n’est pas possible de continuer à envoyer vos propres images et sons. Vous devrez mettre à jour votre implémentation `IVSStrategy` pour arrêter la publication et vous abonner à `.audioOnly` (ou `.none`, le cas échéant) : ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool { return false } func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { return .audioOnly } ``` Passez ensuite un appel à `stage.refreshStrategy()`. ## Encodage en couches avec Simulcast L’encodage en couches avec diffusion simultanée est une fonctionnalité de diffusion en temps réel d’IVS qui permet aux diffuseurs d’envoyer plusieurs couches de vidéo de qualité différente et aux abonnés de configurer ces couches de manière dynamique ou manuelle. Cette fonctionnalité est décrite plus en détail dans le document [Optimisations de la diffusion](real-time-streaming-optimization.md). ### Configuration du codage en couches (diffuseur de publication) En tant que diffuseur de publication, pour activer l’encodage en couches avec la diffusion simultanée, ajoutez la configuration suivante à votre `IVSLocalStageStream` lors de l’instanciation : ``` // Enable Simulcast let config = IVSLocalStageStreamVideoConfiguration() config.simulcast.enabled = true let cameraStream = IVSLocalStageStream(device: camera, configuration: config) // Other Stage implementation code ``` En fonction de la résolution que vous avez définie dans la configuration vidéo, un certain nombre de couches seront encodées et envoyées comme défini dans la section [Couches, qualités et fréquences d’images par défaut](real-time-streaming-optimization.md#real-time-streaming-optimization-default-layers) de la section *Optimisations de la diffusion*. Vous avez également la possibilité de configurer des couches individuelles depuis la configuration de diffusion simultanée : ``` // Enable Simulcast let config = IVSLocalStageStreamVideoConfiguration() config.simulcast.enabled = true let layers = [ IVSStagePresets.simulcastLocalLayer().default720(), IVSStagePresets.simulcastLocalLayer().default180() ] try config.simulcast.setLayers(layers) let cameraStream = IVSLocalStageStream(device: camera, configuration: config) // Other Stage implementation code ``` Vous pouvez également créer vos propres configurations de couches personnalisées pour un maximum de trois couches. Si vous fournissez un tableau vide ou ne contenant aucune valeur, les valeurs par défaut décrites ci-dessus sont utilisées. Les couches sont décrites avec les propriétés setter requises suivantes : + `setSize: CGSize;` + `setMaxBitrate: integer;` + `setMinBitrate: integer;` + `setTargetFramerate: float;` À partir des préréglages, vous pouvez remplacer des propriétés individuelles ou créer une toute nouvelle configuration : ``` // Enable Simulcast let config = IVSLocalStageStreamVideoConfiguration() config.simulcast.enabled = true let customHiLayer = IVSStagePresets.simulcastLocalLayer().default720() try customHiLayer.setTargetFramerate(15) let layers = [ customHiLayer, IVSStagePresets.simulcastLocalLayer().default180() ] try config.simulcast.setLayers(layers) let cameraStream = IVSLocalStageStream(device: camera, configuration: config) // Other Stage implementation code ``` Pour connaître les valeurs maximales, les limites et les erreurs qui peuvent être déclenchées lors de la configuration de couches individuelles, consultez la documentation de référence du kit SDK. ### Configuration de l’encodage en couches (abonné) En tant qu’abonné, il n’est pas nécessaire d’activer l’encodage en couches. Si un diffuseur de publication envoie des couches de diffusion simultanée, le serveur s’adapte dynamiquement entre les couches pour choisir la qualité optimale en fonction de l’appareil de l’abonné et des conditions du réseau. Sinon, pour choisir les couches explicites que le diffuseur de publication envoie, il existe plusieurs options, décrites ci-dessous. ### Option 1 : préférence pour la qualité de la couche initiale En utilisant la stratégie `subscribeConfigurationForParticipant`, il est possible de choisir la couche initiale que vous voulez recevoir en tant qu’abonné : ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration { let config = IVSSubscribeConfiguration() config.simulcast.initialLayerPreference = .lowestQuality return config } ``` Par défaut, les abonnés reçoivent toujours d’abord la couche de qualité la plus faible, puis la couche de qualité la plus élevée. Cela permet d’optimiser la consommation de bande passante de l’utilisateur final et d’offrir le meilleur temps d’accès à la vidéo, réduisant ainsi les blocages initiaux de la vidéo pour les utilisateurs sur des réseaux plus faibles. Ces options sont disponibles pour `InitialLayerPreference` : + `lowestQuality` : le serveur diffuse d’abord la couche de vidéo de qualité la plus faible. Cela permet d’optimiser la consommation de la bande passante ainsi que le temps d’accès au contenu multimédia. La qualité est définie comme la combinaison de la taille, du débit binaire et de la fréquence d’images de la vidéo. Par exemple, une vidéo 720p est de moins bonne qualité qu’une vidéo 1080p. + `highestQuality` : le serveur délivre d’abord la couche de vidéo de la plus haute qualité. Cela permet d’optimiser la qualité, mais peut augmenter le temps d’accès au contenu multimédia. La qualité est définie comme la combinaison de la taille, du débit binaire et de la fréquence d’images de la vidéo. Par exemple, la vidéo 1080p est de meilleure qualité que la vidéo 720p. **Remarque :** pour que les préférences de couche initiale (l’appel `initialLayerPreference`) prennent effet, un nouvel abonnement est nécessaire car ces mises à jour ne s’appliquent pas à l’abonnement actif. ### Option 2 : couche préférée pour le flux La méthode de stratégie `preferredLayerForStream` vous permet de sélectionner une couche après le démarrage du flux. Cette méthode de stratégie reçoit les informations relatives au participant et au flux, ce qui vous permet de sélectionner une couche participant par participant. Le kit SDK appelle cette méthode en réponse à des événements spécifiques, par exemple lorsque les couches de flux changent, que l’état des participants change ou que l’application hôte actualise la stratégie. La méthode de stratégie renvoie un objet `IVSRemoteStageStreamLayer`, qui peut être l’un des suivants : + Un objet de couche, tel qu’un objet renvoyé par `IVSRemoteStageStream.layers`. + null, qui indique qu’aucune couche ne doit être sélectionnée et que l’adaptation dynamique est privilégiée. Par exemple, dans la stratégie suivante, les utilisateurs sélectionneront toujours la couche de vidéo de la plus basse qualité disponible : ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, preferredLayerFor stream: IVSRemoteStageStream) -> IVSRemoteStageStreamLayer? { return stream.lowestQualityLayer } ``` Pour réinitialiser la sélection des couches et revenir à l’adaptation dynamique, renvoyez null ou undefined dans la stratégie. Dans cet exemple, `appState` est une variable d’espace réservé qui représente l’état de l’application hôte. ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, preferredLayerFor stream: IVSRemoteStageStream) -> IVSRemoteStageStreamLayer? { If appState.isAutoMode { return nil } else { return appState.layerChoice } } ``` ### Option 3 : aides pour les couches de RemoteStageStream `IVSRemoteStageStream` possède plusieurs aides qui peuvent être utilisées pour prendre des décisions concernant la sélection des couches et afficher les sélections correspondantes aux utilisateurs finaux : + **Événements relatifs aux couches** : tout comme `IVSStageRenderer`, `IVSRemoteStageStreamDelegate` possède des événements qui communiquent les modifications apportées aux couches et à l’adaptation de la diffusion simultanée : + `func stream(_ stream: IVSRemoteStageStream, didChangeAdaption adaption: Bool)` + `func stream(_ stream: IVSRemoteStageStream, didChange layers: [IVSRemoteStageStreamLayer])` + `func stream(_ stream: IVSRemoteStageStream, didSelect layer: IVSRemoteStageStreamLayer?, reason: IVSRemoteStageStream.LayerSelectedReason)` + **Méthodes relatives aux couches** : `IVSRemoteStageStream` possède plusieurs méthodes d’aide qui peuvent être utilisées pour obtenir des informations sur le flux et les couches présentées. Ces méthodes sont disponibles sur le flux distant fourni dans la stratégie `preferredLayerForStream`, ainsi que sur les flux distants exposés via `func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didAdd streams: [IVSStageStream])`. + `stream.layers` + `stream.selectedLayer` + `stream.lowestQualityLayer` + `stream.highestQualityLayer` + `stream.layers(with: IVSRemoteStageStreamLayerConstraints)` Pour plus de détails, consultez la classe `IVSRemoteStageStream` dans la [documentation de référence du kit SDK](https://aws.github.io/amazon-ivs-broadcast-docs/latest/ios/) (français non garanti). Pour la raison `LayerSelected`, si le message `UNAVAILABLE` est renvoyé, cela indique que la couche demandée n'a pas pu être sélectionnée. La meilleure sélection est faite à sa place, qui est généralement une couche de qualité inférieure pour maintenir la stabilité du flux. ## Diffuser la scène sur un canal IVS Pour diffuser une étape, créez une `IVSBroadcastSession` distincte, puis suivez les instructions habituelles de diffusion avec le kit SDK, décrites ci-dessus. La propriété `device` sur `IVSStageStream` sera soit un `IVSImageDevice` soit un `IVSAudioDevice` comme indiqué dans l’extrait ci-dessus. Ils peuvent être connectés au `IVSBroadcastSession.mixer` pour diffuser l’intégralité de l’étape dans une disposition personnalisable. Vous pouvez éventuellement composer une scène et la diffuser sur un canal IVS à faible latence, afin de toucher un public plus large. Consultez la section [Activation d’hôtes multiples sur un flux Amazon IVS](https://docs.aws.amazon.com//ivs/latest/LowLatencyUserGuide/multiple-hosts.html) dans le guide de l’utilisateur du streaming à faible latence IVS.