Transmissões interativas ao vivo em vídeo

Em uma transmissão de vídeo interativa ao vivo, um grande número de clientes pode se comunicar em tempo real, publicando e assinando as transmissões uns dos outros durante a sessão. Uma sessão de transmissão de vídeo interativa ao vivo pode acomodar até 15.000 participantes no total, com base no número de transmissores ativos na sessão.

A tabela abaixo detalha o número de participantes da transmissão interativa ao vivo que podem se inscrever para receber todas as transmissões publicadas da sessão. Os participantes da transmissão interativa são os assinantes de baixa latência, com acesso apenas para visualização, de todas as transmissões publicadas e os espectadores da transmissão interativa ao vivo. Os editores da sessão podem ser considerados os anfitriões da transmissão e, nessa função, também podem se inscrever para receber os outros fluxos publicados. À medida que o número de editores por sessão aumenta, o número de espectadores simultâneos de todos os fluxos publicados também diminui.

Por exemplo, com base na tabela abaixo, quando há 1 ou 2 transmissões publicadas na sessão, até 15.000 participantes podem assistir a ambas as transmissões publicadas com latência em tempo real, como participantes de uma transmissão ao vivo. Da mesma forma, quando há 3 transmissões publicadas na sessão, até 13.000 participantes podem assistir a todas as 3 transmissões publicadas com latência em tempo real, como participantes da transmissão ao vivo.

• As transmissões publicadas incluem tanto transmissões de câmera quanto transmissões com compartilhamento de tela.

Se o número de participantes na sessão for maior do que o valor indicado na tabela, você deve usar o recurso de transmissão ao vivo (consulte Transmissões ao vivo).

Da mesma forma, as sessões suportam até 15.000 clientes conectados simultaneamente a uma sessão.

Os desenvolvedores de aplicativos devem gerenciar os limites da plataforma no próprio aplicativo. Consulte a próxima seção.

O recurso de transmissão de vídeo interativa ao vivo está disponível apenas para sessões roteadas (sessões que utilizam o Vonage Media Router). Para obter mais informações, consulte o Roteador de mídia e modos de mídia.

As transmissões de vídeo interativas ao vivo suportam vídeo em HD (assim como vídeo em resolução inferior) desde que os recursos do cliente (largura de banda e CPU) suportem a resolução.

Como desenvolver seu aplicativo para oferecer suporte a transmissões de vídeo interativas ao vivo

Existem algumas melhorias na API que você deve utilizar para dar suporte a um grande número de clientes conectados às sessões. Consulte as seções a seguir:

• Supressão de eventos de conexão
• Detecção de excedimento dos limites de conexão e de fluxo

Supressão de eventos de conexão

Se um grande número de clientes se conectar a uma sessão, é importante desativar os eventos de conexão nos clientes. Esses eventos incluem aqueles disparados quando outros clientes se conectam e se desconectam da sessão. A maioria dos clientes não precisa processar esses eventos, e desativá-los evita que os clientes sofram perdas de desempenho (por exemplo, na publicação ou assinatura de fluxos de áudio e vídeo) causadas por esses eventos de alto volume.

Na versão 2.10.0 e posteriores, cada um dos SDKs de cliente (para Web, iOS e Android) inclui uma melhoria na API para desativar eventos de conexão no cliente.

Embora seja possível usar outras versões compatíveis do cliente (2.9.0+) em sessões de grande porte, os eventos de conexão não serão suprimidos em clientes que utilizem versões anteriores à 2.10.0+. Clientes que utilizem versões mais antigas do OpenTok.js podem apresentar desempenho reduzido, devido ao alto volume de eventos de conexão.

Suprimindo eventos de conexão com o OpenTok.js (web)

Ao inicializar o objeto Session, crie um objeto com o connectionEventsSuppressed propriedade definida como true, e passar esse objeto como o options parâmetro ao chamar o OT.initSession() método. Em seguida, conecte-se à sessão:

var props = {connectionEventsSuppressed: true};
var session = OT.initSession(APPLICATION_ID, SESSION_ID, props);
session.connect(token, function(error) {
  if (error) {
    console.log('Error connecting: ', error.code, error.message);
  } else {
    console.log('Connected to the session.');
  }
});

Isso impede que o objeto Session execute connectionCreated e connectionDestroyed eventos que ocorrem quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor da Vonage não envia esses eventos ao cliente web.)

Suprimindo eventos de conexão com o SDK do iOS

Ao inicializar um objeto OTSessionSettings, defina seu connectionEventsSuppressed propriedade para YES. Em seguida, passe esse objeto como o settings parâmetro ao chamar o [OTSession initWithApiKey:sessionId:delegate:settings:] método para inicializar o objeto OTSession:

OTSessionSettings *settings = [[OTSessionSettings alloc] init];
settings.connectionEventsSuppressed = YES;
OTSession *session = [[OTSession alloc] initWithApiKey:applicationId
                                        sessionId:sessionId
                                        delegate:self
                                        Settings:settings];

Em seguida, conecte-se à sessão:

OTError* error = nil;
[session connectWithToken:kToken error:&error];
if (error) {
  NSLog(@"connect failed with error: (%@)", error);
}

Isso evita que o [SessionDelegate session:connectionCreated:] impedem que as mensagens sejam enviadas quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor da Vonage não envia esses eventos para o cliente iOS.)

Suprimindo eventos de conexão com o SDK do Android

Para se conectar à sessão, instancie um objeto Session.Builder, passando seu ID do aplicativo e o ID da sessão. Em seguida, chame o connectionEventsSuppressed() método do objeto Builder, passando true. Ligue para o build() método para criar o objeto Session. Em seguida, chame o connect() método do objeto Session para se conectar à sessão:

Session session = new Session.Builder(this, APPLICATION_ID, mySessionId)
                    .connectionEventsSuppressed(true)
                    .build();

session.connect(myToken);

Não ligue para o Session.setConnectionListener(ConnectionListener listener) método (para definir um ConnectionListener para o objeto Session); chamar esse método não terá efeito algum. Suprimir eventos de conexão impede que os métodos do ConnectionListener sejam chamados quando outros clientes se conectarem ou se desconectarem da sessão. (Além disso, o servidor da Vonage não envia esses eventos para o cliente Android.)

Suprimindo eventos de conexão com o SDK do Windows

Para se conectar à sessão, instancie um objeto Session usando a classe Session.Builder. Passe seu App ID e seu ID de sessão para o Session.Builder() construtor e definir o connectionEventsSuppressed parâmetro para true. Em seguida, chame o Connect() método do objeto Session para se conectar à sessão:

Session = new Session.Builder(Context.Instance, APPLICATION_ID, SESSION_ID, true).Build();
// Set event handlers for the Session object. Then, connect:
Session.Connect(TOKEN);

Não defina os manipuladores de eventos Session.StreamReceived ou Session.StreamDropped. A supressão de eventos de conexão impede que esses eventos sejam acionados quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor da Vonage não envia esses eventos ao cliente do Windows.)

Suprimindo eventos de conexão com o SDK do Linux

Para se conectar à sessão, instancie um otc_session_settings struct, passando seu ID do aplicativo e o ID da sessão da Vonage. Em seguida, chame a função otc_session_settings_set_connection_events_suppressed() função, passando a instância `otc_session_settings` como primeiro parâmetro, e OTC_TRUE como o segundo, suppress, parâmetro. Em seguida, chame o otc_session_new_with_settings() função para criar a estrutura otc_session. Em seguida, função para se conectar à sessão:

otc_session_settings *session_settings = otc_session_settings_new();
otc_session_settings_set_connection_events_suppressed(session_settings, OTC_TRUE);

otc_session_callbacks session_callbacks = {0};
// Set the callback functions of the otc_session_callbacks instance.

otc_session *session = otc_session_new_with_settings(APPLICATION_ID, SESSION_ID,
                                                     &session_callbacks,
                                                     session_settings);
otc_session_connect(session, TOKEN);

Não defina o otc_session_callbacks.on_connection_created ou otc_session_callbacks.on_connection_dropped funções de retorno de chamada. A supressão de eventos de conexão impede que essas funções de retorno de chamada sejam chamadas quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor da Vonage não envia esses eventos ao cliente Linux.)

Detecção de excedimento dos limites de conexão e de fluxo

Os SDKs de cliente incluem erros que indicam quando um cliente está tentando se conectar a uma sessão ou se inscrever em um fluxo, caso o limite de conexões (15.000) ou de fluxos (15.000) para a sessão tenha sido excedido.

Se o cliente não conseguir se conectar a uma sessão ou se inscrever em um fluxo porque o limite de conexões ou de fluxos foi atingido, você pode fazer com que o cliente visualize um transmissão ao vivo da sessão (caso você tenha implementado uma).

Erros de conexão e de limite de transmissão no OpenTok.js (web)

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente) tiver sido atingido, o manipulador de conclusão para o Session.connect() O método é chamado com o error parâmetro definido como um objeto Error com o name propriedade definida como 'OT_CONNECTION_LIMIT_EXCEEDED'.

Se você tentar se inscrever em um fluxo quando o limite de fluxos para uma sessão tiver sido excedido, o manipulador de conclusão para o Session.subscribe() O método é chamado com o error parâmetro definido como um objeto Error com o name propriedade definida como 'OT_STREAM_LIMIT_EXCEEDED'.

Erros de conexão e de limite de fluxo no SDK do Android

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente) tiver sido atingido, o Session.SessionListener.onError(session, error) O método é chamado com o error parâmetro definido como um objeto Error com a propriedade code definida como SessionConnectionLimitExceeded.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o Session.SubscriberListener.onError(subscriber, error) O método é chamado com o error parâmetro definido como um objeto Error com a propriedade code definida como SubscriberStreamLimitExceeded.

Qualidade de vídeo em transmissões interativas ao vivo

Sessões em grande escala se beneficiam do recurso de vídeo escalável. Com esse recurso, os terminais assinantes podem consumir diferentes resoluções de vídeo e taxas de quadros com base nas condições de sua rede e CPU. Esse recurso está disponível no SDK da Vonage para iOS (em determinados dispositivos), no SDK para Android (em determinados dispositivos), no SDK para Windows e no OpenTok.js no Chrome e no Safari.

Erros de conexão e de limite de fluxo no SDK do iOS

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente) tiver sido atingido, o [SessionDelegate session:didFailWithError:] a mensagem é enviada com o error definido como um objeto OTError com o code propriedade definida como OTSessionConnectionLimitExceeded.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o [OTSubscriberKitDelegate subscriber:didFailWithError:] a mensagem é enviada com o error definido como um objeto OTError com o code propriedade definida como OTSubscriberStreamLimitExceeded.

Erros de conexão e de limite de fluxo no SDK do Windows

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente) tiver sido atingido, o Session o objeto envia um Error evento enviado com o ErrorCode definir como ErrorCode.SessionConnectionLimitExceeded.

Se você tentar se inscrever em um fluxo quando o limite de fluxos para uma sessão tiver sido atingido, o objeto Subscriber envia um evento Error com o ErrorCode definido como um objeto OTError com o code propriedade definida como ErrorCode.SubscriberStreamLimitExceeded.

Erros de conexão e de limite de fluxo no SDK do Linux

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente) tiver sido atingido, o otc_session_callbacks.on_error() a função é chamada com o parâmetro de erro definido como OTC_SESSION_CONNECTION_LIMIT_EXCEEDED.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o otc_subscriber_callbacks.on_error() a função é chamada com o error parâmetro definido como OTC_SUBSCRIBER_STREAM_LIMIT_EXCEEDED.

Preços para transmissões interativas ao vivo

O vídeo interativo ao vivo utiliza o mesmo modelo de cobrança por minuto de assinatura aplicado às outras sessões. Para mais detalhes, consulte Preços.