El objeto «Session» devuelto por el OT.initSession() Este método permite acceder a gran parte de las funciones de la Video API de Vonage.

Propiedades

Métodos

addEventListener(tipo, oyente, contexto)

Parámetros:

En desuso — uso on() o una vez() en su lugar.

Este método registra un método como detector de eventos para un evento concreto.

Si no hay ningún controlador registrado para un evento, dicho evento se ignora a nivel local. Si la función de escucha de eventos no existe, el evento se ignora a nivel local.

Lanza una excepción si el listener El nombre no es válido.

Véase: : - on() - una vez() - Eventos

connect(token, completionHandler)

Se conecta a una sesión de la Video API de Vonage.

Una vez establecida la conexión, se invoca el controlador de finalización (el segundo parámetro del método) sin que se le pase ningún objeto de error. (Si se produce un error al conectarse, el controlador de finalización se invoca con un objeto de error). Asegúrate de que te has conectado correctamente a la sesión antes de llamar a otros métodos del objeto Session.

El objeto «Session» envía un connectionCreated cada vez que un cliente (incluido el tuyo) se conecte a la sesión.

Ejemplo

El siguiente código inicializa una sesión y configura un detector de eventos para cuando la sesión se conecte:

 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 enviados:

exception (ExceptionEvent) — Enviado por la clase OT a nivel local en caso de error.

connectionCreated (ConnectionEvent) — Enviado por el objeto «Session» a todos los clientes conectados a la sesión.

sessionConnected (SessionConnectEvent) — Lo envía localmente el objeto Session cuando se establece la conexión. Sin embargo, puedes pasar una función de controlador de finalización como segundo parámetro de la connect() y utiliza esta función en lugar de un oyente para el sessionConnected evento.

Parámetros:

Véase: : - SessionConnectEvent

disableForceMute() → {Promise}

Desactiva el estado de silencio activo de la sesión. Una vez que se llame a este método, las nuevas transmisiones publicadas en la sesión ya no tendrán el audio silenciado.

Después de llamar al Session.forceMuteAll() método (o cuando un moderador de otro cliente realiza una llamada para silenciar todas las transmisiones), cualquier transmisión publicada tras la llamada de moderación se publica con el audio silenciado. Llama al disableForceMute() Método para desactivar el estado de silencio de una sesión (de modo que las nuevas transmisiones publicadas no se silencien automáticamente).

Al llamar a este método, el objeto `Session` de cada cliente conectado envía un muteForced con el evento active bandera establecida en false.

Compruebe el capabilities.canForceMute propiedad del objeto Session para comprobar si puedes llamar a esta función correctamente. Está reservada para los clientes que se hayan conectado con un token al que se le haya asignado el rol de moderador (consulta el Creación de fichas (documentación).

Véase: : - Session.capabilities - Session.forceMuteAll() - Evento «muteForced»

Devoluciones:

Una promesa que devuelve un valor nulo cuando la operación se completa con éxito. La promesa se rechaza si se produce un error. La name La propiedad del objeto Error se establece en uno de los siguientes valores, dependiendo del tipo de error:

• 'OT_NOT_CONNECTED' — El cliente no está conectado a la sesión.
• 'OT_PERMISSION_DENIED' — El rol del usuario no incluye los permisos necesarios para forzar el silencio de otros usuarios. El rol de un usuario se define al crear el token de usuario (véase el Descripción general de la creación de tokens). Se pasa la cadena del token como parámetro de la función connect() método del objeto Session.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — En caso de que se produzca un error interno del servidor.

disconnect() → {Promise.<void>}

Se desconecta de la sesión de la Video API de Vonage.

Llamada al disconnect() Este método finaliza tu conexión con la sesión. Al finalizar tu conexión, también se interrumpe la publicación de cualquier flujo que estuvieras publicando.

Los objetos de sesión en los clientes remotos se distribuyen streamDestroyed eventos de cualquier flujo que estuvieras publicando. El objeto Session envía un sessionDisconnected evento a nivel local. Los objetos Session de los clientes remotos envían connectionDestroyed eventos, para que el resto de contactos sepan que has abandonado la sesión. El SessionDisconnectEvent y StreamEvent objetos que definen el sessionDisconnect y connectionDestroyed Cada evento tiene un reason propiedad. El reason Esta propiedad permite al desarrollador determinar si la conexión se está cerrando de forma voluntaria y si se están destruyendo algunos flujos como consecuencia de la destrucción voluntaria de la conexión subyacente.

Si la sesión no está conectada en ese momento, al llamar a este método se registra una advertencia. Véase OT.setLogLevel().

Nota: Si tienes intención de reutilizar un objeto Publisher para publicar en diferentes sesiones (o en la misma sesión) de forma secuencial, añade un detector de eventos para el streamDestroyed evento enviado por el objeto Publisher (cuando deja de publicar). En el oyente de eventos, llama a la preventDefault() método del objeto de evento para evitar que el vídeo del editor se elimine de la página.

Eventos enviados:

sessionDisconnected (SessionDisconnectEvent) — Se envía a nivel local cuando se interrumpe la conexión.

connectionDestroyed (ConnectionEvent) — Enviado en otros clientes, junto con el streamDestroyed evento (si procede).

streamDestroyed (StreamEvent) — Se envía a otros clientes si se pierden las transmisiones como consecuencia de la desconexión de la sesión.

Devoluciones:

Una promesa que se resolverá cuando se active el evento «sessionDisconnected»

forceDisconnect(conexión, gestionadorDefinalización) → {Promise.<void>}

Obliga a una conexión remota a salir de la sesión.

El forceDisconnect() Este método se utiliza normalmente como herramienta de moderación para expulsar a los usuarios de una sesión en curso.

Cuando se cierra una conexión mediante el forceDisconnect(), sessionDisconnected, connectionDestroyed y streamDestroyed Los eventos se envían de la misma forma que se harían si la conexión se hubiera cerrado por sí misma utilizando el disconnect() método. Sin embargo, el reason propiedad de un ConnectionEvent o StreamEvent El objeto especifica "forceDisconnected" como motivo de la interrupción de la conexión y de la(s) transmisión(es).

Aunque puedes utilizar el forceDisconnect() método para cerrar tu propia conexión, llamando a la función disconnect() Este método es más sencillo.

El objeto OT envía un exception incluso si el rol del usuario no incluye los permisos necesarios para obligar a otros usuarios a desconectarse. El rol de un usuario se define al crear el token de usuario (véase la Descripción general de la creación de tokens). Véase ExceptionEvent y OT.on().

La aplicación muestra un error si la sesión no está conectada.

Eventos enviados:

connectionDestroyed (ConnectionEvent) — En los clientes distintos de aquellos cuya conexión se había interrumpido.

exception (ExceptionEvent) — El rol del usuario no le permite obligar a otros usuarios a desconectarse (event.code = 1530), o bien la transmisión especificada no se está publicando en la sesión (event.code = 1535).

sessionDisconnected (SessionDisconnectEvent) — En el cliente cuya conexión se ha interrumpido.

streamDestroyed (StreamEvent) — Si las transmisiones se interrumpen como consecuencia de la interrupción de la conexión.

Parámetros:

Devoluciones:

Una promesa que se resuelve cuando se produce la desconexión

forceMuteAll(excludedStreams) → {Promise}

Obliga a todos los emisores de la sesión (excepto a aquellos que emiten transmisiones excluidas) a silenciar el audio.

Una retransmisión publicada por el moderador en la que se hace referencia al forceMuteAll() El método está silenciado junto con el resto de transmisiones de la sesión, a menos que añadas la transmisión (o transmisiones) del moderador a la matriz de transmisiones excluidas.

Si omites el excludedStreams parámetro, todas las transmisiones de la sesión (incluidas las del moderador) dejarán de emitir audio:

session.forceMuteAll();

Además, cualquier flujo que se publique después de la llamada a la función forceMuteAll() método se publican con el audio silenciado. Puedes desactivar el silencio de una sesión llamando al disableForceMute() método del objeto Session.

session.disableForceMute();

Después de llamar a la Session.disableForceMute() De esta forma, las nuevas transmisiones publicadas en la sesión ya no tendrán el audio silenciado.

Al llamar a este método, los objetos Publisher de los clientes que publican los flujos envían muteForced eventos. Además, el objeto «Session» de cada cliente conectado a la sesión envía el muteForced evento (con el active del objeto de evento como true).

Compruebe el capabilities.canForceMute propiedad del objeto Session para comprobar si puedes llamar a esta función correctamente. Está reservada para los clientes que se hayan conectado con un token al que se le haya asignado el rol de moderador (consulta el Creación de fichas (documentación).

Parámetros:

Véase: : - Session.capabilities - Session.forceMuteStream() - Session.disableForceMute() - Evento «muteForced» de la sesión - Evento «muteForced» del editor - Silenciar el audio de las transmisiones en una sesión

Devoluciones:

Una promesa que devuelve un valor nulo cuando la operación se completa con éxito. La promesa se rechaza si se produce un error. La name La propiedad del objeto Error se establece en uno de los siguientes valores, dependiendo del tipo de error:

• 'OT_NOT_CONNECTED' — El cliente no está conectado a la sesión.
• 'INVALID_PARAMETER' — si uno o varios de los parámetros pasados no son válidos.
• 'OT_PERMISSION_DENIED' — El rol del usuario no incluye los permisos necesarios para forzar el silencio de otros usuarios. El rol de un usuario se define al crear el token de usuario (véase el Descripción general de la creación de tokens). Se pasa la cadena del token como parámetro de la función connect() método del objeto Session.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — en caso de que se produzca un error interno del servidor.

forceMuteStream(stream) → {Promise}

Obliga al editor de una transmisión específica a silenciar su audio.

Al llamar a este método, el objeto Publisher del cliente que publica el flujo envía un muteForced evento.

Compruebe el capabilities.canForceMute propiedad del objeto Session para comprobar si puedes llamar a esta función correctamente. Está reservada para los clientes que se hayan conectado con un token al que se le haya asignado el rol de moderador (consulta el Creación de fichas (documentación).

Parámetros:

Véase: : - Session.capabilities - Session.forceMuteAll() - Evento «muteForced» del editor - Silenciar el audio de las transmisiones en una sesión

Devoluciones:

Una promesa que devuelve un valor nulo cuando la operación se completa con éxito. La promesa se rechaza si se produce un error. La name La propiedad del objeto Error se establece en uno de los siguientes valores, dependiendo del tipo de error:

• 'OT_NOT_CONNECTED' — El cliente no está conectado a la sesión.
• 'OT_INVALID_PARAMETER' — si uno o varios de los parámetros pasados no son válidos.
• 'OT_PERMISSION_DENIED' — El rol del usuario no incluye los permisos necesarios para forzar el silencio de otros usuarios. El rol de un usuario se define al crear el token de usuario (véase el Descripción general de la creación de tokens). Se pasa la cadena del token como parámetro de la función connect() método del objeto Session.
• 'OT_NOT_FOUND' — No se ha encontrado la retransmisión en esta sesión.
• 'OT_UNEXPECTED_SERVER_RESPONSE' — En caso de que se produzca un error interno del servidor.

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

Obliga al editor de la transmisión especificada a dejar de publicarla.

Al llamar a este método, el objeto Session envía un streamDestroyed evento en todos los clientes suscritos a la transmisión (incluido el cliente que está publicando la transmisión). El reason La propiedad del objeto StreamEvent está establecida en "forceUnpublished".

El objeto OT envía un exception incluso si el rol del usuario no incluye los permisos necesarios para obligar a otros usuarios a retirar la publicación. El rol de un usuario se define al crear el token de usuario (véase el Descripción general de la creación de tokens). Se pasa la cadena del token como parámetro de la función connect() método del objeto Session. Véase ExceptionEvent y OT.on().

Eventos enviados:

exception (ExceptionEvent) — El rol del usuario no le permite obligar a otros usuarios a retirar la publicación.

streamDestroyed (StreamEvent) — La transmisión se ha retirado. El objeto Session envía esta notificación a todos los clientes suscritos a la transmisión, así como al cliente del editor.

Parámetros:

Devoluciones:

Una promesa que se resuelve cuando se lleva a cabo la retirada de la publicación

getPublisherForStream(stream) → {Editorial}

Devuelve el objeto Publisher local correspondiente a un flujo determinado.

Parámetros:

Véase: : - forceUnpublish() - Suscriptor - StreamEvent

Devoluciones:

Un objeto Publisher para el flujo especificado. Devuelve null si no existe ningún objeto Publisher local para el flujo especificado.

getSubscribersForStream(stream) → {Array}

Devuelve una matriz de objetos «Subscriber» locales para un flujo determinado.

Parámetros:

Véase: : - unsubscribe() - Suscriptor - StreamEvent

Devoluciones:

Una variedad de Suscriptor objetos para el flujo especificado.

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

Elimina uno o varios controladores de eventos.

Si se pasa un nombre de evento y un método de gestión, dicho método se elimina para ese evento:

obj.off("eventName", eventHandler);

Si se pasan varios nombres de eventos y un método de gestión, dicho método se elimina para esos eventos:

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

Si pasas un nombre de evento (o varios nombres) y no método de controladores: se eliminan todos los controladores para esos eventos:

obj.off("event1Name event2Name");

Si no se pasan argumentos, todos Se eliminan los controladores de eventos para todos los eventos enviados por el objeto:

obj.off();

El método también admite una sintaxis alternativa, en la que el primer parámetro es un objeto que consta de un mapa hash con los nombres de los eventos y las funciones de gestión, y el segundo parámetro (opcional) es el contexto para cada una de estas funciones:

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

Parámetros:

Véase: : - on() - una vez() - Eventos

Devoluciones:

El objeto que ha activado el evento.

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

Añade una función de gestión de eventos para uno o varios eventos.

El siguiente código añade un controlador de eventos para un evento:

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

Si se pasan varios nombres de eventos y un método de gestión, dicho método se registra para cada uno de esos eventos:

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

También puedes pasar un tercer context parámetro (que es opcional) para definir el valor de this en el método del controlador:

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

El método también admite una sintaxis alternativa, en la que el primer parámetro es un objeto que constituye un mapa hash de nombres de eventos y funciones de gestión, y el segundo parámetro (opcional) es el contexto para cada una de estas funciones de gestión:

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

Si no se añade un controlador para un evento, este se ignora a nivel local.

Parámetros:

Véase: : - off() - una vez() - Eventos

Devoluciones:

El objeto EventDispatcher.

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

Añade una función de gestión de eventos para uno o varios eventos. Una vez que se invoca el gestor, el método de gestión especificado deja de ser el gestor de este evento. (Cuando se utiliza el on() método para añadir un controlador de eventos; el controlador es no se elimina cuando se invoca.) El once() El método es equivalente a llamar a la on() método y llamada off() la primera vez que se invoca el controlador.

El siguiente código añade un controlador de eventos de uso único para un evento:

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

Si se pasan varios nombres de eventos y un método de gestión, dicho método se registra para cada uno de esos eventos:

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

También puedes pasar un tercer context parámetro (que es opcional) para definir el valor de this en el método del controlador:

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

El método también admite una sintaxis alternativa, en la que el primer parámetro es un objeto que consta de un mapa hash con los nombres de los eventos y las funciones de gestión, y el segundo parámetro (opcional) es el contexto para cada una de estas funciones:

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:

Véase: : - on() - off() - Eventos

Devoluciones:

El objeto que ha activado el evento.

publish(editor, gestorDeFinalización)

El publish() El método comienza a publicar un flujo de audio y vídeo en la sesión. El flujo de audio y vídeo se captura desde un micrófono y una cámara web locales. Una vez que la publicación se ha realizado con éxito, los objetos «Session» de todos los clientes conectados envían el streamCreated evento.

Se pasa un objeto `Publisher` como único parámetro del método. Se puede inicializar un objeto `Publisher` llamando al método OT.initPublisher() método. Antes de llamar a Session.publish().

Este método adopta una forma alternativa: publish(targetElement: String | HTMLElement, properties: Object, completionHandler: Function): Publisher — De esta forma, tú... no No se pasa un objeto Publisher a la función. En su lugar, se pasa un targetElement (el elemento HTML de destino o el ID del elemento HTML de destino para el editor), un properties objeto que define las opciones del Publisher (véase OT.initPublisher()), y una función de gestión de finalización opcional. El método devuelve un nuevo objeto `Publisher`, que comienza a enviar un flujo de audio y vídeo a la sesión. El resto de esta documentación describe la forma que toma un único objeto `Publisher` como parámetro.

En la página web se crea una visualización local de la transmisión publicada sustituyendo el elemento especificado en el DOM por una visualización de vídeo en streaming. La transmisión de vídeo se refleja automáticamente en horizontal para que los usuarios se vean a sí mismos y los movimientos de su transmisión de forma natural. Si la anchura y la altura de la pantalla no se ajustan a la relación de aspecto 4:3 de la señal de vídeo, la transmisión de vídeo se recorta para adaptarse a la pantalla.

Si al llamar a este método se crea un nuevo objeto Publisher y la biblioteca de la Video API de Vonage no tiene acceso a la cámara ni al micrófono, la página web avisa al usuario para que conceda acceso a la cámara y al micrófono.

El objeto OT envía un exception incluso si el rol del usuario no incluye los permisos necesarios para publicar. Por ejemplo, si el rol del usuario está configurado como «suscriptor», entonces no podrá publicar. El rol de un usuario se define al crear el token de usuario (véase Descripción general de la creación de tokens). Se pasa la cadena del token como parámetro de la función connect() método del objeto Session. Véase ExceptionEvent y OT.on().

La aplicación muestra un error si la sesión no está conectada.

Eventos enviados:

exception (ExceptionEvent) — Enviado por el objeto OT. Esto puede ocurrir cuando el rol del usuario no permite la publicación (el code la propiedad del objeto de evento está establecida en 1500); también puede producirse si la conexión falla (el code la propiedad del objeto de evento está establecida en 1013). WebRTC es un protocolo punto a punto, por lo que es posible que las conexiones no se establezcan. La causa más habitual de fallo es un cortafuegos que el protocolo no puede atravesar.

streamCreated (StreamEvent) — Se ha publicado el flujo. El objeto Session distribuye esta información a todos los clientes suscritos al flujo, así como al cliente del editor.

Ejemplo

En el siguiente ejemplo se publica un vídeo una vez que se establece la conexión de la sesión:

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:

Devoluciones:

El objeto Publisher correspondiente a este flujo.

removeEventListener(tipo, oyente, contexto)

Parámetros:

En desuso — uso off() en su lugar.

Elimina un detector de eventos para un evento concreto.

Lanza una excepción si el listener El nombre no es válido.

Véase: : - off() - Eventos

setEncryptionSecret(secret) → {Promise}

Establece la clave de cifrado para una sesión en la que se haya activado el cifrado de extremo a extremo. Si se invoca este método en una sesión en la que no se haya activado el cifrado, la función se ejecutará sin que se produzca ningún error. Los usuarios pueden cambiar su clave de cifrado en cualquier momento. Consulta la sección sobre cifrado de extremo a extremo Guía para desarrolladores.

Parámetros:

Véase: : - OT.initSession - Eventos para suscriptores

Devoluciones:

Una promesa que devuelve un valor nulo cuando la operación se completa con éxito. La promesa se rechaza si se produce un error. La name La propiedad del objeto Error se establece en uno de los siguientes valores, dependiendo del tipo de error:

• 'OT_INVALID_ENCRYPTION_SECRET'; La contraseña no es válida.

Puede producirse una discrepancia oculta cuando no se notifica ningún error. Véase eventos para suscriptores para más información.

setIceConfig(newIceConfig)

Establece la configuración ICE para todas las conexiones de una sesión. Esto sustituye cualquier configuración ICE establecida anteriormente.

Esta función está disponible para los proyectos que utilizan el configurable Complemento del servidor TURN.

Parámetros:

Véase: : - OT.initSession()

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

Envía una señal a cada cliente o a un cliente concreto de la sesión. Especifica un to propiedad del signal Parámetro para limitar la señal que se envía a un cliente concreto; de lo contrario, la señal se envía a todos los clientes conectados a la sesión.

El siguiente ejemplo envía una señal de tipo «foo» con una carga útil de datos especificada («hello») a todos los clientes conectados a la sesión:

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

Al llamar a este método sin especificar un cliente destinatario (al establecer el to propiedad de la signal parámetro) da lugar al envío de varias señales (una a cada cliente de la sesión). Para obtener información sobre las tarifas de señalización, consulte el Precios de la Video API de Vonage página.

El siguiente ejemplo envía una señal de tipo «foo» con una carga útil de datos («hello») a un cliente concreto conectado a la sesión:

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);
}

Añade un controlador de eventos para el signal evento para detectar todas las señales enviadas en la sesión. Añade un controlador de eventos para el signal:type evento para detectar solo señales de un tipo específico (sustituir type, en signal:type, con el tipo de señal que se debe detectar). El objeto Session gestiona estos eventos. (Véase eventos.)

Parámetros:

Véase: : - señal y señal:tipo eventos

Devoluciones:

Una promesa que se resuelve cuando se ha enviado la señal

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

Se suscribe a un flujo disponible para la sesión. Puedes obtener una matriz de flujos disponibles desde el streams propiedad del sessionConnected y streamCreated eventos (véase SessionConnectEvent y StreamEvent).

La transmisión a la que se ha suscrito se muestra en la página web local sustituyendo el elemento especificado en el DOM por una ventana de reproducción de vídeo en streaming. Si la anchura y la altura de la ventana no se ajustan a la relación de aspecto 4:3 de la señal de vídeo, la transmisión de vídeo se recorta para adaptarse a la ventana. Si la transmisión carece de componente de vídeo, se muestra una pantalla en blanco con un indicador de audio en lugar de la transmisión de vídeo.

La aplicación genera un error si la sesión no está conectada o si el targetElement no existe en el DOM de HTML.

Ejemplo

El siguiente código se suscribe a las transmisiones de otros 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:

Devoluciones:

El objeto «Subscriber» correspondiente a este flujo. Las funciones de control del flujo se acceden a través del objeto «Subscriber».

despublicar(editor)

Deja de publicar el flujo de audio y vídeo del emisor especificado en la sesión. De forma predeterminada, la representación local del flujo de audio y vídeo se elimina de la página web. Si la finalización se realiza correctamente, el objeto Session de cada página web conectada envía un streamDestroyed evento.

Para evitar que el Publisher sea eliminado del DOM, añade un detector de eventos para el streamDestroyed evento enviado por el objeto Publisher y llamar a la preventDefault() método del objeto de evento.

Nota: Si tienes intención de reutilizar un objeto Publisher para publicar en diferentes sesiones (o en la misma sesión) de forma secuencial, añade un detector de eventos para el streamDestroyed evento enviado por el objeto Publisher (cuando deja de publicar). En el oyente de eventos, llama a la preventDefault() método del objeto de evento para evitar que el vídeo del editor se elimine de la página.

Eventos enviados:

streamDestroyed (StreamEvent) — Se ha eliminado el flujo asociado al editor. Enviado por el editor en el navegador del editor. Enviado por el objeto «Session» en todas las demás conexiones suscritas al flujo del editor.

Ejemplo

En el siguiente ejemplo se publica una transmisión en una sesión y se añade un enlace «Desconectar» a la página web. Al hacer clic en este enlace, se detiene la publicación de la transmisión.

<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:

Véase: : - publish() - Evento «streamDestroyed»

cancelar suscripción (suscriptor)

Deja de suscribirse a una transmisión en la sesión. La visualización de la transmisión de audio y vídeo se elimina de la página web local.

Ejemplo

El siguiente código se suscribe a los flujos de otros clientes. Para cada flujo, el código también añade un enlace para darse de baja.

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:

Véase: : - subscribe()

Eventos

Inicio del archivo

Se envía cuando comienza la grabación de archivo de la sesión.

Véase: : - Archivo de eventos - Descripción general del archivado

archivoDetenido

Se envía cuando finaliza la grabación de archivo de la sesión.

Véase: : - Archivo de eventos - Descripción general del archivado

conexiónCreada

Se activa cuando un nuevo cliente (incluido el propio) se ha conectado a la sesión, y para cada cliente de la sesión la primera vez que se conecta. (El objeto Session también activa un sessionConnected (evento que se produce cuando tu cliente local se conecta.)

Véase: : - ConnectionEvent - OT.initSession()

conexión interrumpida

Un cliente, que no es el tuyo, se ha desconectado de la sesión.

Véase: : - ConnectionEvent

cpuPerformanceChanged

El estado de rendimiento de la CPU ha cambiado. Se puede establecer en una de las siguientes opciones: «nominal», «moderado», «grave» o «crítico».

Véase: : - CpuPerformanceChangedEvent

silenciamiento forzado

Un moderador ha obligado a los clientes que publican transmisiones en la sesión a silenciar el audio (el active La propiedad de este objeto MuteForcedEvent está establecida en true), o un moderador ha desactivado el estado de silencio de audio en la sesión (el active La propiedad de este objeto MuteForcedEvent está establecida en false).

Véase: : - MuteForcedEvent - Session.forceMuteAll() - Session.disableForceMute() - Silenciar el audio de las transmisiones en una sesión

sessionConnected

El cliente se ha conectado a una sesión de la Video API de Vonage. Este evento se envía de forma asíncrona en respuesta a una llamada realizada con éxito a la connect() método de un objeto Session. Antes de llamar al connect() método, inicializa la sesión llamando a la OT.initSession() método. Para ver un ejemplo de código y obtener más detalles, consulta Session.connect().

Véase: : - SessionConnectEvent - Session.connect() - OT.initSession()

sesión desconectada

El cliente se ha desconectado de la sesión. Este evento puede activarse de forma asíncrona en respuesta a una llamada correcta al disconnect() método del objeto Session. El evento también puede activarse si se pierde una conexión de sesión de forma involuntaria, como en el caso de una pérdida de conexión de red.

El comportamiento predeterminado es que todos los objetos «Subscriber» se den de baja y se eliminen del DOM HTML. Cada objeto «Subscriber» envía un destroyed evento que se produce cuando el elemento se elimina del DOM HTML. Si llamas a la función preventDefault() método en el escuchador de eventos para el sessionDisconnect evento, se impide el comportamiento predeterminado y puedes, si lo deseas, limpiar los objetos Subscriber utilizando tu propio código.

El reason La propiedad del objeto de evento indica el motivo por el que el cliente se ha desconectado.

Véase: : - Session.disconnect() - Session.forceDisconnect() - SessionDisconnectEvent

sessionReconnected

El cliente local se ha vuelto a conectar a la sesión de la Video API de Vonage tras haber perdido la conexión temporalmente. Cuando se pierde la conexión, el objeto «Session» envía un sessionReconnecting evento, antes del sessionReconnected evento. Si el cliente no puede volver a conectarse a la sesión, el objeto Session envía un sessionDisconnected evento en lugar de este evento.

Los editores y suscriptores existentes se vuelven a conectar automáticamente cuando el cliente se vuelve a conectar y el objeto «Session» activa este evento.

Las señales enviadas por otros clientes mientras tu cliente estaba desconectado se reciben al volver a conectarse. Por defecto, las señales iniciadas por el cliente local mientras estaba desconectado (mediante la llamada a la función Session.signal() método) se envían cuando el cliente se vuelve a conectar a la sesión de la Video API de Vonage. Puedes evitarlo configurando el retryAfterReconnect propiedad a false en el signal que se pasa al objeto Session.signal() método.

Véase: : - Evento - Evento de reconexión de sesión - Evento «sessionDisconnected»

Reconexión de sesión

El cliente local ha perdido la conexión con una sesión de la Video API de Vonage y está intentando volver a conectarse. Esto se debe a una pérdida de conectividad de red. Si el cliente consigue volver a conectarse a la sesión, el objeto Session envía un sessionReconnected evento. De lo contrario, si el cliente no puede volver a conectarse, el objeto Session envía un sessionDisconnected evento.

Ante esta situación, quizá te interese mostrar una notificación en la interfaz de usuario para informar al usuario de que la aplicación está intentando volver a conectarse a la sesión y de que las transmisiones de audio y vídeo se han interrumpido temporalmente.

Véase: : - Evento - Evento «sessionReconnected» - Evento «sessionDisconnected»

señal

Se ha recibido una señal de la sesión. La SignalEvent La clase define este objeto de evento. Incluye las siguientes propiedades:

• data — (Cadena) La cadena de datos enviada junto con la señal (si hay alguna).
• from — (Conexión) La conexión correspondiente al cliente que envió la señal.
• type — (Cadena) El tipo asignado a la señal (si hay alguna).

Puedes registrarte para recibir todas las señales enviadas durante la sesión añadiendo un controlador de eventos para el signal evento. Por ejemplo, el siguiente código añade un controlador de eventos para procesar todas las señales enviadas durante la sesión:

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

Puedes registrarte para recibir señales de un tipo concreto añadiendo un controlador de eventos para el signal:type evento (en sustitución de type con la cadena del tipo real sobre la que se va a filtrar).

Véase: : - Session.signal() - SignalEvent - señal:tipo evento

streamCreado

Se ha creado un nuevo flujo, publicado por otro cliente, en esta sesión. En el caso de los flujos publicados por tu propio cliente, el objeto Publisher envía un streamCreated evento. Para ver un ejemplo de código y obtener más detalles, consulta StreamEvent.

Véase: : - StreamEvent - Session.publish()

streamDestroyed

Una transmisión de otro cliente ha dejado de publicarse en la sesión.

El comportamiento predeterminado es que todos los objetos «Subscriber» suscritos al flujo se desenregistran y se eliminan del DOM HTML. Cada objeto «Subscriber» envía un destroyed evento que se produce cuando el elemento se elimina del DOM HTML. Si llamas a la función preventDefault() método en el oyente de eventos para el streamDestroyed evento, se impide el comportamiento predeterminado y puedes liberar un objeto «Subscriber» de la secuencia llamando a su destroy() método. Véase Session.getSubscribersForStream().

En el caso de las transmisiones publicadas por tu propio cliente, el objeto Publisher envía un streamDestroyed evento.

Para ver un ejemplo de código y obtener más detalles, consulta StreamEvent.

Véase: : - StreamEvent

streamPropertyChanged

Define un evento que se activa cuando cambia una propiedad de un flujo. Esto puede ocurrir en las siguientes situaciones:

• Una retransmisión ha comenzado o ha dejado de emitir audio, subtítulos o vídeo (véase Publisher.publishAudio(), Publisher.publishCaptions() y Publisher.publishVideo()). Ten en cuenta que el vídeo de un suscriptor puede desactivarse o activarse por motivos distintos a que el editor lo desactive o lo active. Un objeto «Suscriptor» envía videoDisabled y videoEnabled eventos en todas las condiciones que provocan que la transmisión del suscriptor se desactive o se active.
• El videoDimensions La propiedad del objeto Stream ha cambiado (véase Stream.videoDimensions).
• El videoType Se ha modificado una propiedad del objeto Stream. Esto puede ocurrir en una transmisión publicada por un dispositivo móvil. (Véase Stream.videoType.)

Véase: : - StreamPropertyChangedEvent - Publisher.publishAudio() - Publisher.publishCaptions() - Publisher.publishVideo() - Stream.hasAudio - Stream.hasCaptions - Stream.hasVideo - Stream.videoDimensions - Vídeo de suscriptor: evento desactivado - Evento con vídeo habilitado para suscriptores

señal:tipo

Se ha recibido una señal del tipo especificado procedente de la sesión. La SignalEvent La clase define este objeto de evento. Incluye las siguientes propiedades:

• data — (Cadena) La cadena de datos enviada junto con la señal.
• from — (Conexión) La conexión correspondiente al cliente que envió la señal.
• type — (Cadena) El tipo asignado a la señal (si lo hay).

Puedes registrarte para recibir señales de un tipo concreto añadiendo un controlador de eventos para el signal:type evento (en sustitución de type con la cadena del tipo concreto sobre la que se quiere filtrar). Por ejemplo, el siguiente código añade un controlador de eventos para señales de tipo «foo»:

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

Puedes registrarte para recibir todos señales enviadas durante la sesión, añadiendo un gestor de eventos para el signal evento.

Véase: : - Session.signal() - SignalEvent - señal evento