# Publicação e assinatura com o SDK de Transmissão para iOS do IVS \$1 Streaming em tempo real Este documento descreve as etapas envolvidas na publicação e assinatura de um estágio usando o SDK de Transmissão para iOS para streaming em tempo real do IVS. ## Conceitos Existem três conceitos principais que fundamentam a funcionalidade em tempo real: [palco](#ios-publish-subscribe-concepts-stage), [estratégia](#ios-publish-subscribe-concepts-strategy) e [renderizador](#ios-publish-subscribe-concepts-renderer). O objetivo do projeto é minimizar a quantidade de lógica do lado do cliente que é necessária para desenvolver um produto funcional. ### Estágio A classe `IVSStage` corresponde ao principal ponto de interação entre a aplicação de host e o SDK. A classe representa o próprio palco e é usada para entrar e sair do palco. Criar ou entrar em um palco requer uma string de token válida e não expirada do ambiente de gerenciamento (representada como `token`). Entrar e sair de um palco é simples. ``` let stage = try IVSStage(token: token, strategy: self) try stage.join() stage.leave() ``` Na classe `IVSStage`, também é possível anexar `IVSStageRenderer` e `IVSErrorDelegate`: ``` let stage = try IVSStage(token: token, strategy: self) stage.errorDelegate = self stage.addRenderer(self) // multiple renderers can be added ``` ### Estratégia O protocolo `IVSStageStrategy` fornece uma maneira para a aplicação de host comunicar o estado desejado do palco ao SDK. Três funções precisam ser implementadas: `shouldSubscribeToParticipant`, `shouldPublishParticipant` e `streamsToPublishForParticipant`. Todas serão discutidas abaixo. #### Como se inscrever como participante ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType ``` Quando um participante remoto entra em um palco, o SDK consulta a aplicação de host sobre o estado de inscrição desejado para esse participante. As opções são `.none`, `.audioOnly` e `.audioVideo`. Ao retornar um valor para essa função, a aplicação de host não precisa se preocupar com o estado de publicação, o estado atual da inscrição ou o estado da conexão do palco. Se `.audioVideo` for retornado, o SDK aguardará até que o participante remoto esteja publicando antes de inscrever e atualizará a aplicação de host por meio do renderizador durante todo o processo. Veja a seguir uma amostra de implementação: ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { return .audioVideo } ``` Esta é a implementação completa desta função para uma aplicação de host que sempre deseja que todos os participantes se vejam, por exemplo, uma aplicação de bate-papo por vídeo. Implementações mais avançadas também são possíveis. Use a propriedade `attributes` em `IVSParticipantInfo` para se inscrever, de forma seletiva, como participante com base nos atributos fornecidos pelo servidor: ``` func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { switch participant.attributes["role"] { case "moderator": return .none case "guest": return .audioVideo default: return .none } } ``` Isso pode ser usado para criar um palco no qual os moderadores podem monitorar todos os convidados sem serem vistos ou ouvidos. A aplicação de host pode usar uma lógica de negócios adicional para permitir que os moderadores se vejam, mas permaneçam invisíveis para os convidados. #### Configuração da assinatura de participantes ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration ``` Se um participante remoto estiver fazendo uma assinatura (consulte [Assinatura de participantes](#ios-publish-subscribe-concepts-strategy-participants)), o SDK consultará a aplicação host sobre uma configuração de assinatura personalizada para esse participante. Essa configuração é opcional e permite que a aplicação host controle certos aspectos do comportamento do assinante. Para obter informações sobre o que pode ser configurado, consulte [SubscribeConfiguration](https://aws.github.io/amazon-ivs-web-broadcast/docs/sdk-reference/interfaces/SubscribeConfiguration) na documentação de referência do SDK. Veja a seguir uma amostra de implementação: ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration { let config = IVSSubscribeConfiguration() try! config.jitterBuffer.setMinDelay(.medium()) return config } ``` Essa implementação atualiza o atraso mínimo do buffer de instabilidade para todos os participantes assinantes para uma predefinição de `MEDIUM`. Como com `shouldSubscribeToParticipant`, implementações mais avançadas são possíveis. As `ParticipantInfo` fornecidas podem ser usadas para atualizar seletivamente a configuração de assinatura para participantes específicos. Recomendamos usar os valores padrão. Especifique a configuração personalizada somente se houver um comportamento específico que você queira alterar. #### Publicação ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool ``` Uma vez conectado ao palco, o SDK consulta a aplicação de host para visualizar se um determinado participante deve realizar uma publicação. Isso é invocado somente para participantes locais que têm permissão para realizar publicações com base no token fornecido. Veja a seguir uma amostra de implementação: ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool { return true } ``` Isso é para uma aplicação de bate-papo por vídeo padrão na qual os usuários sempre desejam realizar publicações. Eles podem ativar e desativar o áudio e o vídeo para serem ocultados ou vistos/ouvidos instantaneamente. (Também é possível usar publicar/cancelar a publicação, mas isso é muito mais lento. Ativar/Desativar o áudio é preferível para casos de uso em que é desejável alterar a visibilidade com frequência.) #### Como escolher streams para realizar publicações ``` func stage(_ stage: IVSStage, streamsToPublishForParticipant participant: IVSParticipantInfo) -> [IVSLocalStageStream] ``` Ao realizar publicações, isso é usado para determinar quais streams de áudio e de vídeo devem ser publicados. Isso será abordado com mais detalhes posteriormente em [Publish a Media Stream](#ios-publish-subscribe-publish-stream). #### Como atualizar a estratégia A estratégia pretende ser dinâmica, ou seja, os valores retornados de qualquer uma das funções acima podem ser alterados a qualquer momento. Por exemplo, se a aplicação de host não desejar realizar publicações até que o usuário final toque em um botão, será possível retornar uma variável de `shouldPublishParticipant` (algo como `hasUserTappedPublishButton`). Quando essa variável for alterada com base em uma interação do usuário final, chame `stage.refreshStrategy()` para sinalizar ao SDK que ele deve consultar a estratégia para obter os valores mais recentes, aplicando somente o que sofreu alterações. Se o SDK observar que o valor `shouldPublishParticipant` foi alterado, ele iniciará o processo de publicação. Se as consultas do SDK e todas as funções retornarem o mesmo valor anterior, a chamada `refreshStrategy` não fará nenhuma modificação no palco. Se o valor de retorno de `shouldSubscribeToParticipant` for alterado de `.audioVideo` para `.audioOnly`, a transmissão de vídeo será removida para todos os participantes com os valores retornados alterados, caso uma transmissão de vídeo tenha existido anteriormente. Geralmente, o palco usa a estratégia para aplicar com mais eficiência a diferença entre as estratégias anteriores e atuais, sem que a aplicação de host precise se preocupar com todo o estado necessário para realizar o gerenciamento adequado. Por causa disso, pense na chamada `stage.refreshStrategy()` como uma operação barata, porque ela não faz nada a menos que a estratégia seja alterada. ### Renderizador O protocolo `IVSStageRenderer` comunica o estado do palco à aplicação de host. Geralmente, as atualizações na interface do usuário da aplicação de host podem ser baseadas inteiramente nos eventos fornecidos pelo renderizador. O renderizador fornece as seguintes funções: ``` 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) ``` Não é esperado que as informações fornecidas pelo renderizador impactem os valores de retorno da estratégia. Por exemplo, não se espera que o valor de retorno de `shouldSubscribeToParticipant` seja alterado quando `participant:didChangePublishState` for chamado. Se a aplicação de host desejar inscrever um determinado participante, ele deverá retornar o tipo de inscrição desejado, independentemente do estado de publicação desse participante. O SDK é responsável por garantir que o estado desejado da estratégia seja acionado no momento correto com base no estado do palco. Observe que somente a publicação de participantes aciona `participantDidJoin` e, sempre que um participante interrompe as publicações ou sai da sessão de palco, `participantDidLeave` é acionado. ## Publicação de uma transmissão de mídia Dispositivos locais, como microfones e câmeras integrados, são descobertos por meio de `IVSDeviceDiscovery`. Veja a seguir um exemplo de como selecionar a câmera frontal e o microfone padrão e, em seguida, retorná-los como `IVSLocalStageStreams` para serem publicados pelo 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] } ``` ## Exibição e remoção de participantes Após a conclusão da inscrição, você receberá uma matriz de objetos `IVSStageStream` por meio da função `didAddStreams` do renderizador. Para visualizar previamente ou receber estatísticas de nível de áudio sobre este participante, é possível acessar o objeto `IVSDevice` subjacente da transmissão: ``` 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 */ }) } ``` Quando um participante interrompe as publicações ou cancela a inscrição, a função `didRemoveStreams` é chamada com as transmissões que foram removidas. As aplicações de host devem usar isso como um sinal para remover a transmissão de vídeo do participante da hierarquia de visualização. `didRemoveStreams` é invocada para todos os cenários em que uma transmissão pode ser removida, incluindo: + Um participante remoto que interrompe as publicações. + Um dispositivo local que cancela a inscrição ou altera a inscrição de `.audioVideo` para `.audioOnly`. + Um participante remoto que sai do palco. + Um participante local que sai do palco. Como `didRemoveStreams` é invocada para todos os cenários, nenhuma lógica de negócios personalizada é necessária para remover participantes da IU durante operações de saída remotas ou locais. ## Ativação ou desativação do áudio para transmissões de mídia Os objetos `IVSLocalStageStream` têm uma função `setMuted` que controla se a transmissão é silenciada. Essa função pode ser chamada na transmissão antes ou depois de ser retornada da função de estratégia `streamsToPublishForParticipant`. **Importante**: se uma nova instância de objeto `IVSLocalStageStream` for retornada por `streamsToPublishForParticipant` após uma chamada para `refreshStrategy`, o estado mudo do novo objeto de transmissão será aplicado ao palco. Tenha cuidado ao criar novas instâncias `IVSLocalStageStream` para garantir que o estado mudo esperado seja mantido. ## Monitoramento do estado mudo da mídia do participante remoto Quando um participante altera o estado mudo de sua transmissão de vídeo ou áudio, a função `didChangeMutedStreams` do renderizador é invocada com uma matriz de transmissões que foram alteradas. Use a propriedade `isMuted` na `IVSStageStream` para atualizar a IU adequadamente: ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didChangeMutedStreams streams: [IVSStageStream]) { streams.forEach { stream in /* stream.isMuted */ } } ``` ## Criação de uma configuração de palco Para personalizar os valores da configuração de vídeo de um palco, use `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 ``` ## Obtenção de estatísticas WebRTC Para obter as estatísticas WebRTC mais recentes para uma transmissão de publicação ou uma transmissão de inscrição, use `requestRTCStats` em `IVSStageStream`. Quando uma coleta for concluída, você receberá as estatísticas por meio do `IVSStageStreamDelegate`, que pode ser definido em `IVSStageStream`. Para coletar estatísticas WebRTC de forma contínua, chame esta função em um `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)") } } } ``` ## Obtenção de atributos do participante Se você especificar atributos na solicitação da operação `CreateParticipantToken`, poderá visualizar os atributos nas propriedades `IVSParticipantInfo`: ``` func stage(_ stage: IVSStage, participantDidJoin participant: IVSParticipantInfo) { print("ID: \(participant.participantId)") for attribute in participant.attributes { print("attribute: \(attribute.key)=\(attribute.value)") } } ``` ## Incorporar mensagens O método `embedMessage` em IVSImageDevice permite inserir cargas de metadados diretamente nos quadros de vídeo durante a publicação. Isso torna possível o envio de mensagens sincronizadas aos quadros para aplicações em tempo real. A incorporação de mensagens está disponível somente quando o SDK é usado para publicação em tempo real (e não publicação de baixa latência). Não há garantias de que as mensagens incorporadas chegarão aos assinantes, pois elas são incorporadas diretamente aos quadros de vídeo e transmitidas por UDP, o que não garante a entrega de pacotes. A perda de pacotes durante a transmissão pode resultar na perda de mensagens, especialmente em condições de rede precárias. Para mitigar esse problema, o método `embedMessage` inclui um parâmetro `repeatCount` que duplica a mensagem em vários quadros consecutivos, aumentando a confiabilidade da entrega. Esse recurso está disponível somente para fluxos de vídeo. ### Usar embedMessage Os clientes de publicação podem incorporar cargas úteis de mensagens em seus fluxos de vídeo usando o método `embedMessage` em IVSImageDevice. A carga útil deve ter mais de 0 KB e menos de 1 KB. O número de mensagens incorporadas inseridas não deve exceder 10 KB por segundo. ``` 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)") } ``` ### Repetir cargas úteis das mensagens Use `repeatCount` para duplicar a mensagem em vários quadros para melhorar a confiabilidade. Esse valor deve ser entre 0 e 30. Os clientes destinatários devem ter uma lógica para desduplicar a mensagem. ``` try imageDevice.embedMessage(messageData, withRepeatCount: 5) // repeatCount: 0-30, receiving clients should handle duplicates ``` ### Ler mensagens incorporadas Consulte "Obter informações de aprimoramento suplementares (SEI)" abaixo para saber como ler mensagens incorporadas de fluxos recebidos. ## Obter informações de aprimoramento suplementares (SEI) A unidade NAL de informações de aprimoramento suplementar (SEI) é usada para armazenar metadados alinhados ao quadro ao lado do vídeo. Os clientes assinantes podem ler as cargas úteis do SEI de um publicador que está publicando um vídeo H.264 inspecionando a propriedade `embeddedMessages` nos objetos `IVSImageDeviceFrame` que saem do `IVSImageDevice` do publicador. Para fazer isso, adquira o `IVSImageDevice` de um publicador e observe cada quadro por meio de um retorno de chamada fornecido para `setOnFrameCallback`, conforme mostrado no exemplo a seguir: ``` // 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 } } } ``` ## Continuação da sessão em segundo plano Quando a aplicação entra em segundo plano, é possível continuar no palco enquanto ouve o áudio remoto, embora não seja possível continuar enviando a própria imagem e áudio. Você precisará atualizar a implementação de sua `IVSStrategy` para interromper as publicações e se inscrever como `.audioOnly` (ou `.none`, se aplicável): ``` func stage(_ stage: IVSStage, shouldPublishParticipant participant: IVSParticipantInfo) -> Bool { return false } func stage(_ stage: IVSStage, shouldSubscribeToParticipant participant: IVSParticipantInfo) -> IVSStageSubscribeType { return .audioOnly } ``` Em seguida, realize uma chamada para `stage.refreshStrategy()`. ## Codificação em camadas com transmissão simultânea A codificação em camadas com transmissão simultânea é um atributo de streaming em tempo real do IVS que permite que os publicadores enviem várias camadas de vídeo de qualidade diferentes e que os assinantes configurem essas camadas de forma dinâmica ou manual. O atributo é descrito mais detalhadamente no documento [Otimizações de streaming](real-time-streaming-optimization.md). ### Configuração da codificação em camadas (Publicador) Como publicador, para habilitar a codificação em camadas com a transmissão simultânea, adicione a seguinte configuração à sua `IVSLocalStageStream` na instanciação: ``` // Enable Simulcast let config = IVSLocalStageStreamVideoConfiguration() config.simulcast.enabled = true let cameraStream = IVSLocalStageStream(device: camera, configuration: config) // Other Stage implementation code ``` Dependendo da resolução definida na configuração do vídeo, um determinado número de camadas será codificado e enviado conforme definido na seção [Camadas, qualidades e taxas de quadros padrão](real-time-streaming-optimization.md#real-time-streaming-optimization-default-layers) de *Otimizações de streaming*. Também é possível configurar opcionalmente camadas individuais a partir da configuração do simulcast: ``` // 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 ``` Como alternativa, é possível criar suas próprias configurações de camada personalizadas para até três camadas. Se você fornecer uma matriz vazia ou não fornecer um valor, serão usados os padrões descritos acima. As camadas são descritas com os seguintes definidores de propriedade obrigatórios: + `setSize: CGSize;` + `setMaxBitrate: integer;` + `setMinBitrate: integer;` + `setTargetFramerate: float;` Começando com as predefinições, você pode substituir propriedades individuais ou criar uma configuração totalmente nova: ``` // 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 ``` Para obter informações sobre valores máximos, limites e erros que podem ser acionados ao configurar camadas individuais, consulte a documentação de referência do SDK. ### Configuração da codificação em camadas (Assinante) Como assinante, você não precisa fazer nada para habilitar a codificação em camadas. Se um publicador estiver enviando camadas de transmissão simultânea, por padrão, o servidor se adapta dinamicamente entre as camadas para escolher a qualidade ideal com base no dispositivo e nas condições da rede do assinante. Alternativamente, para escolher camadas explícitas que o publicador está enviando, há várias opções, descritas abaixo. ### Opção 1: preferência de qualidade da camada inicial Usando a estratégia `subscribeConfigurationForParticipant`, é possível escolher qual camada inicial você deseja receber como assinante: ``` func stage(_ stage: IVSStage, subscribeConfigurationForParticipant participant: IVSParticipantInfo) -> IVSSubscribeConfiguration { let config = IVSSubscribeConfiguration() config.simulcast.initialLayerPreference = .lowestQuality return config } ``` Por padrão, os assinantes sempre recebem primeiro a camada de qualidade mais baixa; isso aumenta lentamente até a camada de mais alta qualidade. Isso otimiza o consumo de largura de banda do usuário final e fornece o melhor tempo para vídeo, reduzindo os congelamentos iniciais de vídeo para usuários em redes mais fracas. Essas opções estão disponíveis para `InitialLayerPreference`: + `lowestQuality` — O servidor fornece primeiro a camada de vídeo de menor qualidade. Isso otimiza o consumo de largura de banda, bem como o tempo até a mídia. A qualidade é definida como a combinação de tamanho, taxa de bits e taxa de quadros do vídeo. Por exemplo, o vídeo 720p tem qualidade inferior ao vídeo 1080p. + `highestQuality` — O servidor fornece primeiro a camada de vídeo de mais alta qualidade. Isso otimiza a qualidade, mas pode aumentar o tempo até a mídia. A qualidade é definida como a combinação de tamanho, taxa de bits e taxa de quadros do vídeo. Por exemplo, o vídeo 1080p tem qualidade superior ao vídeo 720p. **Observação:** para que as preferências iniciais da camada (a chamada `initialLayerPreference`) entrem em vigor, é necessária uma nova assinatura, pois essas atualizações não se aplicam à assinatura ativa. ### Opção 2: Camada preferida para fluxo O método de estratégia `preferredLayerForStream` permite selecionar uma camada após o início da transmissão. Esse método de estratégia recebe as informações do participante e do stream, para que você possa selecionar uma camada participante por participante. O SDK chama esse método em resposta a eventos específicos, como quando as camadas do stream mudam, o estado do participante muda ou a aplicação host atualiza a estratégia. O método de estratégia retorna um objeto `IVSRemoteStageStreamLayer`, que pode ser um dos seguintes: + Um objeto de camada, como um retornado por `IVSRemoteStageStream.layers`. + null, o que indica que nenhuma camada deve ser selecionada e que a adaptação dinâmica é preferida. Por exemplo, a estratégia a seguir sempre fará com que os usuários selecionem a camada de vídeo de menor qualidade disponível: ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, preferredLayerFor stream: IVSRemoteStageStream) -> IVSRemoteStageStreamLayer? { return stream.lowestQualityLayer } ``` Para redefinir a seleção de camadas e retornar à adaptação dinâmica, retorne null ou undefined na estratégia. Neste exemplo, `appState` é uma variável de espaço reservado que representa o estado da aplicação do host. ``` func stage(_ stage: IVSStage, participant: IVSParticipantInfo, preferredLayerFor stream: IVSRemoteStageStream) -> IVSRemoteStageStreamLayer? { If appState.isAutoMode { return nil } else { return appState.layerChoice } } ``` ### Opção 3: auxiliares da camada RemoteStageStream `IVSRemoteStageStream` tem vários auxiliares que podem ser usados para tomar decisões sobre a seleção de camadas e exibir as seleções correspondentes aos usuários finais: + **Eventos de camada** — Além de `IVSStageRenderer`, o `IVSRemoteStageStreamDelegate` tem eventos que comunicam mudanças de adaptação de camada e transmissão simultânea: + `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étodos de camada** — `IVSRemoteStageStream` tem vários métodos auxiliares que podem ser usados para obter informações sobre o fluxo e as camadas que estão sendo apresentadas. Esses métodos estão disponíveis no fluxo remoto fornecido na estratégia `preferredLayerForStream`, bem como nos fluxos remotos expostos via `func stage(_ stage: IVSStage, participant: IVSParticipantInfo, didAdd streams: [IVSStageStream])`. + `stream.layers` + `stream.selectedLayer` + `stream.lowestQualityLayer` + `stream.highestQualityLayer` + `stream.layers(with: IVSRemoteStageStreamLayerConstraints)` Para obter detalhes, consulte a classe `IVSRemoteStageStream` na [documentação de referência do SDK](https://aws.github.io/amazon-ivs-broadcast-docs/latest/ios/). Pelo motivo `LayerSelected`, se `UNAVAILABLE` for retornado, isso indica que não foi possível selecionar a camada solicitada. Em vez disso, a melhor seleção é feita, que normalmente é uma camada de qualidade inferior para manter a estabilidade do fluxo. ## Transmissão do palco para um canal do IVS Para transmitir um palco, crie uma `IVSBroadcastSession` separada e, em seguida, siga as instruções usuais para uma transmissão com o SDK, descritas acima. A propriedade `device` na `IVSStageStream` será um `IVSImageDevice` ou um `IVSAudioDevice`, conforme mostrado no trecho de código acima. Eles podem ser conectados ao `IVSBroadcastSession.mixer` para transmitir todo o palco em um layout personalizável. Você também pode compor um palco e transmiti-lo para um canal de baixa latência do IVS para alcançar um público maior. Consulte [Enabling Multiple Hosts on an Amazon IVS Stream](https://docs.aws.amazon.com//ivs/latest/LowLatencyUserGuide/multiple-hosts.html) no Guia do usuário do streaming de baixa latência do IVS.