O objeto Session retornado pelo OT.initSession() O método oferece acesso a grande parte das funcionalidades da Video API do Vonage.

Propriedades

Métodos

addEventListener(tipo, ouvinte, contexto)

Parâmetros:

Obsoleto — uso on() ou uma vez() em vez disso.

Este método registra um método como um ouvinte de evento para um evento específico.

Se um manipulador não estiver registrado para um evento, o evento é ignorado localmente. Se a função de escuta de eventos não existir, o evento é ignorado localmente.

Gera uma exceção se o listener O nome é inválido.

Veja: : - on() - uma vez() - Eventos

connect(token, completionHandler)

Conecta-se a uma sessão da Video API da Vonage.

Após uma conexão bem-sucedida, o manipulador de conclusão (o segundo parâmetro do método) é chamado sem que seja passado um objeto de erro. (Se ocorrer um erro na conexão, o manipulador de conclusão é chamado com um objeto de erro.) Certifique-se de ter se conectado com sucesso à sessão antes de chamar outros métodos do objeto Session.

O objeto Session despacha um connectionCreated evento que ocorre quando qualquer cliente (incluindo o seu próprio) se conecta à sessão.

Exemplo

O código a seguir inicializa uma sessão e configura um ouvinte de eventos para quando a sessão se conectar:

 var apiKey = ""; // Replace with your API key. See https://tokbox.com/account
 var sessionID = ""; // Replace with your own session ID.
                     // See https://tokbox.com/developer/guides/create-session/.
 var token = ""; // Replace with a generated token.
                 // See https://tokbox.com/developer/guides/create-token/.

 var session = OT.initSession(apiKey, sessionID);
 session.connect(token, function(error) {
   if (error) {
     console.log(error.message);
   } else {
     // You have connected to the session. You could publish a stream now.
   }
 });

Eventos disparados:

exception (ExceptionEvent) — Enviado pela classe OT localmente em caso de erro.

connectionCreated (ConnectionEvent) — Enviado pelo objeto Session a todos os clientes conectados à sessão.

sessionConnected (SessionConnectEvent) — Chamado localmente pelo objeto Session quando a conexão é estabelecida. No entanto, é possível passar uma função de manipulador de conclusão como segundo parâmetro do connect() e use essa função em vez de um ouvinte para o sessionConnected evento.

Parâmetros:

Veja: : - SessionConnectEvent

disableForceMute() → {Promise}

Desativa o estado de mudo ativo da sessão. Após chamar esse método, os novos streams publicados na sessão não terão mais o áudio silenciado.

Depois de ligar para o Session.forceMuteAll() método (ou quando um moderador em outro cliente realiza uma chamada para silenciar todas as transmissões), quaisquer transmissões publicadas após a chamada de moderação são publicadas com o áudio silenciado. Chame o disableForceMute() método para remover o estado de mudo de uma sessão (para que os novos fluxos publicados não sejam automaticamente silenciados).

A chamada a esse método faz com que o objeto Session em cada cliente conectado envie um muteForced evento, com o active flag definido como false.

Verifique o capabilities.canForceMute propriedade do objeto Session para verificar se é possível chamar essa função com sucesso. Isso está reservado para clientes que se conectaram com um token ao qual foi atribuída a função de moderador (consulte o Criação de tokens (documentação).

Veja: : - Session.capabilities - Session.forceMuteAll() - Evento `muteForced`

Devoluções:

Uma promessa que retorna um valor nulo quando a operação é concluída com sucesso. A promessa é rejeitada se ocorrer um erro. A name A propriedade do objeto Error é definida como um dos seguintes valores, dependendo do tipo de erro:

• 'OT_NOT_CONNECTED' — O cliente não está conectado à sessão.
• 'OT_PERMISSION_DENIED' — A função do usuário não inclui as permissões necessárias para forçar outros usuários a ficarem em silêncio. Você define a função de um usuário ao criar o token do usuário (consulte o Visão geral da criação de tokens). Você passa a string do token como parâmetro da função connect() método do objeto Session.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — No caso de um erro interno do servidor.

disconnect() → {Promise.<void>}

Desconecta a sessão da Video API da Vonage.

Chamando o disconnect() O método encerra sua conexão com a sessão. Ao encerrar sua conexão, ele também interrompe a publicação de qualquer fluxo que você estivesse publicando.

Desencadeamento de objetos de sessão em clientes remotos streamDestroyed eventos para qualquer fluxo que você estivesse publicando. O objeto Session despacha um sessionDisconnected evento localmente. Os objetos Session nos clientes remotos acionam connectionDestroyed eventos, informando aos outros participantes que você saiu da sessão. O Event de Desconexão de Sessão e StreamEvent objetos que definem o sessionDisconnect e connectionDestroyed cada evento tem um reason propriedade. A reason Essa propriedade permite que o desenvolvedor determine se a conexão está sendo encerrada voluntariamente e se algum fluxo está sendo destruído como consequência do encerramento voluntário da conexão subjacente.

Se a sessão não estiver conectada no momento, a chamada a este método fará com que um aviso seja registrado no log. Consulte OT.setLogLevel().

Observação: Se você pretende reutilizar um objeto Publisher para publicar em diferentes sessões (ou na mesma sessão) sequencialmente, adicione um ouvinte de evento para o streamDestroyed evento disparado pelo objeto Publisher (quando ele interrompe a publicação). No ouvinte de eventos, chame o preventDefault() método do objeto de evento para impedir que o vídeo do Editor seja removido da página.

Eventos disparados:

sessionDisconnected (Event de Desconexão de Sessão) — Enviado localmente quando a conexão é interrompida.

connectionDestroyed (ConnectionEvent) — Enviado em outros clientes, juntamente com o streamDestroyed evento (conforme necessário).

streamDestroyed (StreamEvent) — Enviado a outros clientes caso os fluxos sejam perdidos devido ao desligamento da sessão.

Devoluções:

Uma promessa que será resolvida quando o evento `sessionDisconnected` for disparado

forceDisconnect(conexão, manipuladorDeConclusão) → {Promise.<void>}

Força uma conexão remota a encerrar a sessão.

O forceDisconnect() O método é normalmente utilizado como ferramenta de moderação para remover usuários de uma sessão em andamento.

Quando uma conexão é encerrada por meio do forceDisconnect(), sessionDisconnected, connectionDestroyed e streamDestroyed os eventos são disparados da mesma forma que seriam se a conexão tivesse sido encerrada automaticamente por meio do disconnect() método. No entanto, o reason propriedade de um ConnectionEvent ou StreamEvent O objeto especifica "forceDisconnected" como motivo para a interrupção da conexão e da(s) transmissão(ões).

Embora você possa usar o forceDisconnect() método para encerrar sua própria conexão, chamando o disconnect() O método é mais simples.

O objeto OT despacha um exception mesmo que a função do usuário não inclua as permissões necessárias para forçar outros usuários a se desconectarem. Você define a função de um usuário ao criar o token do usuário (consulte o Visão geral da criação de tokens). Veja ExceptionEvent e OT.on().

O aplicativo exibe uma mensagem de erro se a sessão não estiver conectada.

Eventos disparados:

connectionDestroyed (ConnectionEvent) — Nos clientes que não foram aqueles cuja conexão foi encerrada.

exception (ExceptionEvent) — A função do usuário não permite forçar outros usuários a se desconectarem (event.code = 1530), ou o fluxo especificado não está publicando na sessão (event.code = 1535).

sessionDisconnected (Event de Desconexão de Sessão) — No cliente cuja conexão foi encerrada.

streamDestroyed (StreamEvent) — Se as transmissões forem interrompidas devido ao término da conexão.

Parâmetros:

Devoluções:

Uma promessa que é resolvida quando ocorre a desconexão

forceMuteAll(excludedStreams) → {Promise}

Obliga todos os transmissores na sessão (exceto aqueles que estão transmitindo streams excluídos) a silenciar o áudio.

Uma transmissão publicada pelo moderador chamando o forceMuteAll() O método fica silenciado junto com outras transmissões da sessão, a menos que você adicione a transmissão (ou transmissões) do moderador à matriz de transmissões excluídas.

Se você deixar de fora o excludedStreams parâmetro, todas as transmissões da sessão (incluindo as do moderador) deixarão de transmitir áudio:

session.forceMuteAll();

Além disso, quaisquer streams publicados após a chamada à função forceMuteAll() método são publicadas com o áudio silenciado. É possível desativar o silenciamento de uma sessão chamando o disableForceMute() método do objeto Session.

session.disableForceMute();

Depois de chamar a Session.disableForceMute() Com esse método, as novas transmissões publicadas na sessão não terão mais o áudio silenciado.

A chamada a este método faz com que os objetos Publisher nos clientes que estão publicando os fluxos enviem muteForced eventos. Além disso, o objeto Session em cada cliente conectado à sessão despacha o muteForced evento (com o active propriedade do objeto do evento definida como true).

Verifique o capabilities.canForceMute propriedade do objeto Session para verificar se é possível chamar essa função com sucesso. Isso está reservado para clientes que se conectaram com um token ao qual foi atribuída a função de moderador (consulte o Criação de tokens (documentação).

Parâmetros:

Veja: : - Session.capabilities - Session.forceMuteStream() - Session.disableForceMute() - Evento `muteForced` da sessão - Evento “muteForced” do editor - Silenciar o áudio das transmissões em uma sessão

Devoluções:

Uma promessa que retorna um valor nulo quando a operação é concluída com sucesso. A promessa é rejeitada se ocorrer um erro. A name A propriedade do objeto Error é definida como um dos seguintes valores, dependendo do tipo de erro:

• 'OT_NOT_CONNECTED' — O cliente não está conectado à sessão.
• 'INVALID_PARAMETER' — se um ou mais dos parâmetros passados forem inválidos.
• 'OT_PERMISSION_DENIED' — A função do usuário não inclui as permissões necessárias para forçar outros usuários a ficarem em silêncio. Você define a função de um usuário ao criar o token do usuário (consulte o Visão geral da criação de tokens). Você passa a string do token como parâmetro da função connect() método do objeto Session.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — no caso de um erro interno do servidor.

forceMuteStream(stream) → {Promise}

Obliga o emissor de uma transmissão especificada a silenciar seu áudio.

A chamada a este método faz com que o objeto Publisher no cliente que está publicando o fluxo envie um muteForced evento.

Verifique o capabilities.canForceMute propriedade do objeto Session para verificar se é possível chamar essa função com sucesso. Isso está reservado para clientes que se conectaram com um token ao qual foi atribuída a função de moderador (consulte o Criação de tokens (documentação).

Parâmetros:

Veja: : - Session.capabilities - Session.forceMuteAll() - Evento “muteForced” do editor - Silenciar o áudio das transmissões em uma sessão

Devoluções:

Uma promessa que retorna um valor nulo quando a operação é concluída com sucesso. A promessa é rejeitada se ocorrer um erro. A name A propriedade do objeto Error é definida como um dos seguintes valores, dependendo do tipo de erro:

• 'OT_NOT_CONNECTED' — O cliente não está conectado à sessão.
• 'OT_INVALID_PARAMETER' — se um ou mais dos parâmetros passados forem inválidos.
• 'OT_PERMISSION_DENIED' — A função do usuário não inclui as permissões necessárias para forçar outros usuários a ficarem em silêncio. Você define a função de um usuário ao criar o token do usuário (consulte o Visão geral da criação de tokens). Você passa a string do token como parâmetro da função connect() método do objeto Session.
• 'OT_NOT_FOUND' — A transmissão não foi encontrada nesta sessão.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — No caso de um erro interno do servidor.

forceUnpublish(stream, completionHandler) → {Promise.<void>}

Obliga o editor do fluxo especificado a interromper a publicação do fluxo.

A chamada a esse método faz com que o objeto Session envie um streamDestroyed evento em todos os clientes inscritos no fluxo (incluindo o cliente que está publicando o fluxo). O reason A propriedade do objeto StreamEvent está definida como "forceUnpublished".

O objeto OT despacha um exception mesmo que a função do usuário não inclua as permissões necessárias para obrigar outros usuários a cancelar a publicação. Você define a função de um usuário ao criar o token do usuário (consulte o Visão geral da criação de tokens). Você passa a string do token como parâmetro da função connect() método do objeto Session. Consulte ExceptionEvent e OT.on().

Eventos disparados:

exception (ExceptionEvent) — A função do usuário não permite obrigar outros usuários a retirar a publicação.

streamDestroyed (StreamEvent) — O fluxo foi retirado do ar. O objeto Session notifica todos os clientes assinantes do fluxo, bem como o cliente do editor.

Parâmetros:

Devoluções:

Uma promessa que é resolvida quando ocorre a retirada da publicação

getPublisherForStream(stream) → {Editora}

Retorna o objeto Publisher local para um determinado fluxo.

Parâmetros:

Veja: : - forceUnpublish() - Assinante - StreamEvent

Devoluções:

Um objeto Publisher para o fluxo especificado. Retorna null se não houver um objeto Publisher local para o fluxo especificado.

getSubscribersForStream(stream) → {Array}

Retorna uma matriz de objetos Subscriber locais para um determinado fluxo.

Parâmetros:

Veja: : - cancelar inscrição() - Assinante - StreamEvent

Devoluções:

Uma variedade de Assinante objetos para o fluxo especificado.

off(tipo, manipulador, contexto) → {Object}

Remove um ou mais manipuladores de eventos.

Se você passar o nome de um evento e um método manipulador, o manipulador será removido para esse evento:

obj.off("eventName", eventHandler);

Se você passar vários nomes de eventos e um método manipulador, o manipulador será removido para esses eventos:

obj.off("eventName1 eventName2", eventHandler);

Se você passar um nome de evento (ou nomes) e não método de manipulador, todos os manipuladores são removidos para esses eventos:

obj.off("event1Name event2Name");

Se você não passar nenhum argumento, todos os manipuladores de eventos são removidos para todos os eventos desencadeados pelo objeto:

obj.off();

O método também suporta uma sintaxe alternativa, na qual o primeiro parâmetro é um objeto que é um mapa de nomes de eventos e funções de tratamento, e o segundo parâmetro (opcional) é o contexto para isso em cada função de tratamento:

obj.off(
   {
      eventName1: event1Handler,
      eventName2: event2Handler
   });

Parâmetros:

Veja: : - on() - uma vez() - Eventos

Devoluções:

O objeto que disparou o evento.

on(tipo, manipulador, contexto) → {EventDispatcher}

Adiciona uma função de manipulador de eventos para um ou mais eventos.

O código a seguir adiciona um manipulador de eventos para um evento:

obj.on("eventName", function (event) {
    // This is the event handler.
});

Se você passar vários nomes de eventos e um método manipulador, o manipulador será registrado para cada um desses eventos:

obj.on("eventName1 eventName2",
       function (event) {
           // This is the event handler.
       });

Você também pode passar um terceiro context parâmetro (que é opcional) para definir o valor de this no método do manipulador:

obj.on("eventName",
       function (event) {
           // This is the event handler.
       },
       obj);

O método também suporta uma sintaxe alternativa, na qual o primeiro parâmetro é um objeto que representa um mapa de nomes de eventos e funções de tratamento, e o segundo parâmetro (opcional) é o contexto para isso em cada função de tratamento:

obj.on(
   {
      eventName1: function (event) {
              // This is the handler for eventName1.
          },
      eventName2:  function (event) {
              // This is the handler for eventName2.
          }
   },
   obj);

Se você não adicionar um manipulador para um evento, o evento será ignorado localmente.

Parâmetros:

Veja: : - off() - uma vez() - Eventos

Devoluções:

O objeto EventDispatcher.

once(tipo, manipulador, contexto) → {Object}

Adiciona uma função de manipulador de eventos para um ou mais eventos. Assim que o manipulador for chamado, o método de manipulador especificado é removido como manipulador desse evento. (Quando você usa o on() método para adicionar um manipulador de eventos; o manipulador é não é removido quando é chamado.) O once() O método é equivalente a chamar o on() método e chamada off() na primeira vez que o manipulador for chamado.

O código a seguir adiciona um manipulador de evento único para um evento:

obj.once("eventName", function (event) {
   // This is the event handler.
});

Se você passar vários nomes de eventos e um método de tratamento, o tratamento será registrado para cada um desses eventos:

obj.once("eventName1 eventName2"
         function (event) {
             // This is the event handler.
         });

Você também pode passar um terceiro context parâmetro (que é opcional) para definir o valor de this no método do manipulador:

obj.once("eventName",
         function (event) {
             // This is the event handler.
         },
         obj);

O método também suporta uma sintaxe alternativa, na qual o primeiro parâmetro é um objeto que é um mapa de nomes de eventos e funções de tratamento, e o segundo parâmetro (opcional) é o contexto para isso em cada função de tratamento:

obj.once(
   {
      eventName1: function (event) {
                 // This is the event handler for eventName1.
          },
      eventName2:  function (event) {
                 // This is the event handler for eventName1.
          }
   },
   obj);

Parâmetros:

Veja: : - on() - off() - Eventos

Devoluções:

O objeto que disparou o evento.

publish(editor, manipuladorDeConclusão)

O publish() O método inicia a publicação de um fluxo de áudio e vídeo na sessão. O fluxo de áudio e vídeo é capturado a partir de um microfone e de uma webcam locais. Após a publicação bem-sucedida, os objetos Session em todos os clientes conectados disparam o streamCreated evento.

Você passa um objeto Publisher como único parâmetro do método. É possível inicializar um objeto Publisher chamando o OT.initPublisher() método. Antes de chamar Session.publish().

Esse método assume uma forma alternativa: publish(targetElement: String | HTMLElement, properties: Object, completionHandler: Function): Publisher — Dessa forma, você faz não passar um objeto Publisher para a função. Em vez disso, você passa um targetElement (o elemento HTML de destino ou o ID do elemento HTML de destino para o Publisher), um opcional properties objeto que define as opções do Publisher (consulte OT.initPublisher()), e uma função opcional de tratamento de conclusão. O método retorna um novo objeto Publisher, que começa a enviar um fluxo de áudio e vídeo para a sessão. O restante desta documentação descreve a forma que recebe um único objeto Publisher como parâmetro.

Uma exibição local do stream publicado é criada na página da web ao substituir o elemento especificado no DOM por uma exibição de vídeo em streaming. O fluxo de vídeo é espelhado automaticamente na horizontal para que os usuários vejam a si mesmos e os movimentos em seu fluxo de maneira natural. Se a largura e a altura da exibição não corresponderem à proporção de 4:3 do sinal de vídeo, o fluxo de vídeo será recortado para se ajustar à exibição.

Se a chamada a este método criar um novo objeto Publisher e a biblioteca da Video API do Vonage não tiver acesso à câmera ou ao microfone, a página da web alertará o usuário para que conceda acesso à câmera e ao microfone.

O objeto OT despacha um exception mesmo que a função do usuário não inclua as permissões necessárias para publicar. Por exemplo, se a função do usuário estiver definida como “assinante”, ele não poderá publicar. Você define a função de um usuário ao criar o token do usuário (consulte Visão geral da criação de tokens). Você passa a string do token como parâmetro da função connect() método do objeto Session. Consulte ExceptionEvent e OT.on().

O aplicativo exibe uma mensagem de erro se a sessão não estiver conectada.

Eventos disparados:

exception (ExceptionEvent) — Enviado pelo objeto OT. Isso pode ocorrer quando a função do usuário não permite a publicação (o code a propriedade do objeto de evento está definida como 1500); isso também pode ocorrer se a conexão falhar (o code a propriedade do objeto de evento está definida como 1013). O WebRTC é um protocolo ponto a ponto, e é possível que as conexões não sejam estabelecidas. A causa mais comum para a falha é um firewall que o protocolo não consegue atravessar.

streamCreated (StreamEvent) — O fluxo foi publicado. O objeto Session distribui essa informação a todos os clientes assinantes do fluxo, bem como ao cliente do editor.

Exemplo

O exemplo a seguir publica um vídeo assim que a sessão é estabelecida:

var apiKey = ""; // Replace with your API key. See https://tokbox.com/account
var sessionId = ""; // Replace with your own session ID.
                    // /developer/guides/create-session/.
var token = ""; // Replace with a generated token that has been assigned the publish role.
                // See https://tokbox.com/developer/guides/create-token/.
var session = OT.initSession(apiKey, sessionID);
session.connect(token, function(error) {
  if (error) {
    console.log(error.message);
  } else {
    var publisherOptions = {width: 400, height:300, name:"Bob's stream"};
    // This assumes that there is a DOM element with the ID 'publisher':
    publisher = OT.initPublisher('publisher', publisherOptions);
    session.publish(publisher);
  }
});

Parâmetros:

Devoluções:

O objeto Publisher para este fluxo.

removeEventListener(tipo, ouvinte, contexto)

Parâmetros:

Obsoleto — uso off() em vez disso.

Remove um ouvinte de evento para um evento específico.

Gera uma exceção se o listener O nome é inválido.

Veja: : - off() - Eventos

setEncryptionSecret(secret) → {Promise}

Define o segredo de criptografia para uma sessão com criptografia de ponta a ponta ativada. Se esse método for chamado em uma sessão sem a criptografia ativada, a função será executada e nenhum erro será gerado. Os usuários podem alterar a chave de criptografia definida a qualquer momento. Consulte a seção sobre criptografia de ponta a ponta guia do desenvolvedor.

Parâmetros:

Veja: : - OT.initSession - Eventos para assinantes

Devoluções:

Uma promessa que retorna um valor nulo quando a operação é concluída com sucesso. A promessa é rejeitada se ocorrer um erro. A name A propriedade do objeto Error é definida como um dos seguintes valores, dependendo do tipo de erro:

• 'OT_INVALID_ENCRYPTION_SECRET'; A senha não é válida.

Pode ocorrer uma incompatibilidade oculta quando nenhum erro é gerado. Consulte eventos para assinantes para mais informações.

setIceConfig(newIceConfig)

Define a configuração do ICE para todas as conexões em uma sessão. Isso substitui quaisquer configurações do ICE definidas anteriormente.

Esse recurso está disponível para projetos que utilizam o configurável Complemento do servidor TURN.

Parâmetros:

Veja: : - OT.initSession()

signal(signal, completionHandler) → {Promise.<void>}

Envia um sinal para cada cliente ou para um cliente específico na sessão. Especifique um to propriedade do signal parâmetro para limitar o sinal a ser enviado a um cliente específico; caso contrário, o sinal é enviado a cada cliente conectado à sessão.

O exemplo a seguir envia um sinal do tipo “foo” com uma carga útil de dados especificada (“hello”) para todos os clientes conectados à sessão:

try {
  await session.signal({
    type: "foo",
    data: "hello"
  });
  console.log("signal sent");
} catch (error) {
  console.log("signal error: " + error.message);
}

Chamar esse método sem especificar um cliente destinatário (definindo o to propriedade do signal (parâmetro) resulta no envio de vários sinais (um para cada cliente na sessão). Para obter informações sobre as tarifas de sinalização, consulte o Preços da Video API da Vonage página.

O exemplo a seguir envia um sinal do tipo “foo” com uma carga de dados (“hello”) para um cliente específico conectado à sessão:

try {
  await session.signal({
    type: "foo",
    to: recipientConnection, // a Connection object
    data: "hello"
  });
  console.log("signal sent");
} catch (error) {
  console.log("signal error: " + error.message);
}

Adicione um manipulador de eventos para o signal evento para monitorar todos os sinais recebidos na sessão. Adicione um manipulador de eventos para o signal:type evento para monitorar apenas sinais de um tipo específico (substitua type, em signal:type, com o tipo de sinal a ser monitorado). O objeto Session dispara esses eventos. (Consulte eventos.)

Parâmetros:

Veja: : - sinal e sinal:tipo eventos

Devoluções:

Uma promessa que é resolvida quando o sinal é enviado

subscribe(stream, targetElement, properties, completionHandler) → {Assinante}

Assina um fluxo disponível para a sessão. É possível obter uma matriz de fluxos disponíveis a partir do streams propriedade do sessionConnected e streamCreated eventos (ver SessionConnectEvent e StreamEvent).

O fluxo de vídeo assinado é exibido na página da web local substituindo-se o elemento especificado no DOM por uma exibição de vídeo em streaming. Se a largura e a altura da tela não corresponderem à proporção de 4:3 do sinal de vídeo, o fluxo de vídeo é recortado para se ajustar à tela. Se o fluxo não tiver um componente de vídeo, uma tela em branco com um indicador de áudio é exibida no lugar do fluxo de vídeo.

O aplicativo gera um erro se a sessão não estiver conectada ou se o targetElement não existe no DOM do HTML.

Exemplo

O código a seguir assina os fluxos de outros clientes:

var apiKey = ""; // Replace with your API key. See https://tokbox.com/account
var sessionID = ""; // Replace with your own session ID.
                    // See https://tokbox.com/developer/guides/create-session/.
var token = ""; // Replace with a generated token.
                // See https://tokbox.com/developer/guides/create-token/.

var session = OT.initSession(apiKey, sessionID);
session.on("streamCreated", function(event) {
  subscriber = session.subscribe(event.stream, targetElement);
});
session.connect(token);

Parâmetros:

Devoluções:

O objeto Subscriber para este fluxo. As funções de controle do fluxo são disponibilizadas por meio do objeto Subscriber.

retirar da publicação (editor)

Interrompe a transmissão do fluxo de áudio e vídeo do emissor especificado para a sessão. Por padrão, a representação local do fluxo de áudio e vídeo é removida da página da web. Após a interrupção bem-sucedida, o objeto Session em todas as páginas da web conectadas dispara um streamDestroyed evento.

Para evitar que o Publisher seja removido do DOM, adicione um ouvinte de evento para o streamDestroyed evento disparado pelo objeto Publisher e chamar o preventDefault() método do objeto de evento.

Observação: Se você pretende reutilizar um objeto Publisher para publicar em diferentes sessões (ou na mesma sessão) sequencialmente, adicione um ouvinte de evento para o streamDestroyed evento disparado pelo objeto Publisher (quando ele interrompe a publicação). No ouvinte de eventos, chame o preventDefault() método do objeto de evento para impedir que o vídeo do Editor seja removido da página.

Eventos disparados:

streamDestroyed (StreamEvent) — O fluxo associado ao Publisher foi destruído. Enviado pelo Publisher no navegador do Publisher. Enviado pelo objeto Session em todas as outras conexões inscritas no fluxo do Publisher.

Exemplo

O exemplo a seguir publica um stream em uma sessão e adiciona um link “Desconectar” à página da web. Ao clicar nesse link, a publicação do stream é interrompida.

<script>
  var apiKey = ""; // Replace with your API key. See https://tokbox.com/account
  var sessionID = ""; // Replace with your own session ID.
                   // See https://tokbox.com/developer/guides/create-session/.
  var token = ""; // Replace with a generated token.
                  // See https://tokbox.com/developer/guides/create-token/.
  var publisher;
  var session = OT.initSession(apiKey, sessionID);
  session.connect(token, function(error) {
    if (error) {
      console.log(error.message);
    } else {
      // This assumes that there is a DOM element with the ID 'publisher':
      publisher = OT.initPublisher('publisher');
      session.publish(publisher);
    }
  });

  function unpublish() {
    session.unpublish(publisher);
  }
</script>

<body>

    <div id="publisherContainer/>
    <br/>

    [Stop Publishing](javascript:unpublish())

</body>

Parâmetros:

Veja: : - publish() - Evento streamDestroyed

cancelar inscrição (assinante)

Cancela a assinatura de um fluxo na sessão. A exibição do fluxo de áudio e vídeo é removida da página da web local.

Exemplo

O código a seguir assina os feeds de outros clientes. Para cada feed, o código também adiciona um link para cancelar a assinatura.

var apiKey = ""; // Replace with your API key. See See https://tokbox.com/account
var sessionID = ""; // Replace with your own session ID.
                    // See https://tokbox.com/developer/guides/create-session/.
var token = ""; // Replace with a generated token.
                // See https://tokbox.com/developer/guides/create-token/.
var streams = [];

var session = OT.initSession(apiKey, sessionID);
session.on("streamCreated", function(event) {
    var stream = event.stream;
    displayStream(stream);
});
session.connect(token);

function displayStream(stream) {
    var div = document.createElement('div');
    div.setAttribute('id', 'stream' + stream.streamId);

    var subscriber = session.subscribe(stream, div);
    subscribers.push(subscriber);

    var aLink = document.createElement('a');
    aLink.setAttribute('href', 'javascript: unsubscribe("' + subscriber.id + '")');
    aLink.innerHTML = "Unsubscribe";

    var streamsContainer = document.getElementById('streamsContainer');
    streamsContainer.appendChild(div);
    streamsContainer.appendChild(aLink);

    streams = event.streams;
}

function unsubscribe(subscriberId) {
    console.log("unsubscribe called");
    for (var i = 0; i < subscribers.length; i++) {
        var subscriber = subscribers[i];
        if (subscriber.id == subscriberId) {
            session.unsubscribe(subscriber);
        }
    }
}

Parâmetros:

Veja: : - subscribe()

Eventos

início do arquivo

Enviado quando começa uma gravação de arquivo da sessão.

Veja: : - Arquivo de Eventos - Visão geral do arquivamento

arquivoInterrompido

É enviado quando a gravação de arquivo da sessão é encerrada.

Veja: : - Arquivo de Eventos - Visão geral do arquivamento

conexãoCriada

É disparado quando um novo cliente (incluindo o seu próprio) se conecta à sessão e para cada cliente na sessão quando você se conecta pela primeira vez. (O objeto Session também dispara um sessionConnected evento que ocorre quando seu cliente local se conecta.)

Veja: : - ConnectionEvent - OT.initSession()

conexão interrompida

Um cliente, que não é o seu, se desconectou da sessão.

Veja: : - ConnectionEvent

cpuPerformanceChanged

O estado de desempenho da CPU mudou. Ele pode ser definido como uma das seguintes opções: “nominal”, “razoável”, “grave” ou “crítico”.

Veja: : - CpuPerformanceChangedEvent

silenciarForçado

Um moderador obrigou os clientes que estavam transmitindo para a sessão a silenciar o áudio (o active A propriedade deste objeto MuteForcedEvent está definida como true), ou um moderador desativou o modo de silenciamento de áudio na sessão (o active A propriedade deste objeto MuteForcedEvent está definida como false).

Veja: : - MuteForcedEvent - Session.forceMuteAll() - Session.disableForceMute() - Silenciar o áudio das transmissões em uma sessão

sessionConnected

O cliente se conectou a uma sessão da Video API da Vonage. Esse evento é disparado de forma assíncrona em resposta a uma chamada bem-sucedida à connect() método de um objeto Session. Antes de chamar o connect() método, inicialize a sessão chamando o OT.initSession() método. Para ver um exemplo de código e mais detalhes, consulte Session.connect().

Veja: : - SessionConnectEvent - Session.connect() - OT.initSession()

sessão desconectada

O cliente se desconectou da sessão. Esse evento pode ser disparado de forma assíncrona em resposta a uma chamada bem-sucedida à disconnect() método do objeto Session. O evento também pode ser disparado se uma conexão de sessão for perdida inadvertidamente, como no caso de uma perda de conexão de rede.

O comportamento padrão é que todos os objetos Subscriber tenham sua assinatura cancelada e sejam removidos do DOM HTML. Cada objeto Subscriber dispara um destroyed evento que ocorre quando o elemento é removido do DOM HTML. Se você chamar o preventDefault() método no ouvinte de eventos para o sessionDisconnect evento, o comportamento padrão é impedido, e você pode, opcionalmente, limpar os objetos Subscriber usando seu próprio código.

O reason A propriedade do objeto de evento indica o motivo pelo qual o cliente foi desconectado.

Veja: : - Session.disconnect() - Session.forceDisconnect() - Event de Desconexão de Sessão

sessão reconectada

O cliente local se reconectou à sessão da Video API da Vonage após a perda temporária da conexão. Quando a conexão é perdida, o objeto Session dispara um sessionReconnecting evento, antes do sessionReconnected evento. Se o cliente não conseguir se reconectar à sessão, o objeto Session dispara um sessionDisconnected evento em vez deste evento.

Quaisquer editores e assinantes existentes são automaticamente reconectados quando o cliente se reconecta e o objeto Session dispara esse evento.

Quaisquer sinais enviados por outros clientes enquanto o seu cliente estava desconectado são recebidos ao se reconectar. Por padrão, os sinais iniciados pelo cliente local enquanto estava desconectado (ao chamar a função Session.signal() (método) são enviadas quando o cliente se reconecta à sessão da Video API do Vonage. É possível evitar isso definindo o retryAfterReconnect propriedade para false no signal objeto que você passa para o Session.signal() método.

Veja: : - Evento - Evento de reconexão da sessão - Evento sessionDisconnected

sessão: reconectando

O cliente local perdeu a conexão com uma sessão da Video API da Vonage e está tentando se reconectar. Isso ocorre devido a uma perda de conectividade de rede. Se o cliente conseguir se reconectar à sessão, o objeto Session dispara um sessionReconnected evento. Caso contrário, se o cliente não conseguir se reconectar, o objeto Session dispara um sessionDisconnected evento.

Em resposta a esse evento, talvez seja interessante exibir uma notificação na interface do usuário, para informar ao usuário que o aplicativo está tentando se reconectar à sessão e que os fluxos de áudio e vídeo estão temporariamente desconectados.

Veja: : - Evento - evento sessionReconnected - Evento sessionDisconnected

sinal

Foi recebido um sinal da sessão. O SignalEvent A classe define esse objeto de evento. Ela inclui as seguintes propriedades:

• data — (String) A sequência de caracteres enviada junto com o sinal (se houver).
• from — (Conexão) A conexão correspondente ao cliente que enviou o sinal.
• type — (String) O tipo atribuído ao sinal (se houver algum).

Você pode se cadastrar para receber todos os sinais enviados durante a sessão, adicionando um manipulador de eventos para o signal evento. Por exemplo, o código a seguir adiciona um manipulador de eventos para processar todos os sinais enviados na sessão:

session.on("signal", function(event) {
  console.log("Signal sent from connection: " + event.from.id);
  console.log("Signal data: " + event.data);
});

Você pode se inscrever para receber sinais de um tipo específico adicionando um manipulador de eventos para o signal:type evento (substituindo type com a string do tipo real para filtrar).

Veja: : - Session.signal() - SignalEvent - sinal:tipo evento

streamCreado

Um novo fluxo, publicado por outro cliente, foi criado nesta sessão. Para fluxos publicados pelo seu próprio cliente, o objeto Publisher despacha um streamCreated evento. Para ver um exemplo de código e mais detalhes, consulte StreamEvent.

Veja: : - StreamEvent - Session.publish()

streamDestruído

Um stream de outro cliente parou de publicar na sessão.

O comportamento padrão é que todos os objetos Subscriber inscritos no fluxo sejam cancelados e removidos do DOM HTML. Cada objeto Subscriber dispara um destroyed evento que ocorre quando o elemento é removido do DOM HTML. Se você chamar o preventDefault() método no ouvinte de eventos para o streamDestroyed evento, o comportamento padrão é impedido e você pode liberar um objeto Subscriber do stream chamando seu destroy() método. Veja Session.getSubscribersForStream().

Para fluxos publicados pelo seu próprio cliente, o objeto Publisher despacha um streamDestroyed evento.

Para ver um exemplo de código e mais detalhes, consulte StreamEvent.

Veja: : - StreamEvent

streamPropertyChanged

Define um evento acionado quando uma propriedade de um fluxo é alterada. Isso pode ocorrer nas seguintes condições:

• Uma transmissão começou ou parou de transmitir áudio, legendas ou vídeo (consulte Publisher.publishAudio(), Publisher.publishCaptions() e Publisher.publishVideo()). Observação: o vídeo de um assinante pode ser desativado ou ativado por motivos que não sejam a desativação ou ativação por parte do editor. Um objeto Assinante dispacha videoDisabled e videoEnabled eventos em todas as condições que levam à desativação ou ativação do stream do assinante.
• O videoDimensions a propriedade do objeto Stream foi alterada (consulte Stream.videoDimensions).
• O videoType A propriedade do objeto Stream foi alterada. Isso pode ocorrer em um stream publicado por um dispositivo móvel. (Consulte Stream.videoType.)

Veja: : - StreamPropertyChangedEvent - Publisher.publishAudio() - Publisher.publishCaptions() - Publisher.publishVideo() - Stream.hasAudio - Stream.hasCaptions - Stream.hasVideo - Stream.videoDimensions - Vídeo do assinante: Evento desativado - Evento com vídeos habilitados para assinantes

sinal:tipo

Foi recebido um sinal do tipo especificado da sessão. O SignalEvent A classe define esse objeto de evento. Ela inclui as seguintes propriedades:

• data — (String) A sequência de caracteres enviada com o sinal.
• from — (Conexão) A conexão correspondente ao cliente que enviou o sinal.
• type — (String) O tipo atribuído ao sinal (se houver).

Você pode se inscrever para receber sinais de um tipo específico adicionando um manipulador de eventos para o signal:type evento (substituindo type com a string do tipo real para filtrar). Por exemplo, o código a seguir adiciona um manipulador de eventos para sinais do tipo “foo”:

session.on("signal:foo", function(event) {
  console.log("foo signal sent from connection " + event.from.id);
  console.log("Signal data: " + event.data);
});

Você pode se cadastrar para receber todos sinais enviados na sessão, adicionando um manipulador de eventos para o signal evento.

Veja: : - Session.signal() - SignalEvent - sinal evento