SDK de nodo de la API de Video de Vonage

El SDK de Node proporciona métodos para:

Generar sesiones y fichas
Trabajar con archivos
Trabajar con retransmisiones en directo
Envío de señales a los clientes conectados a una sesión

Instalación mediante npm (recomendado):

NPM ayuda a gestionar las dependencias de los proyectos de nodos. Más información aquí: http://npmjs.org

Ejecute este comando para instalar el paquete y añadirlo a su package.json:

npm install @vonage/server-sdk

Utilización

Inicialización de

Importa el módulo para obtener una función constructora para un objeto de vídeo y, a continuación, llámala con new a instanciar un objeto de vídeo con su propio App ID y clave privada.

const { Auth } = require('@vonage/auth');
const { Vonage } = require('@vonage/server-sdk');
const { MediaMode } = require('@vonage/video');

const credentials = new Auth({
    applicationId: 'APP_ID',
    privateKey: 'PRIVATE_KEY_PATH',
});

const vonage = new Vonage(credentials);

Creación de sesiones

Para crear una sesión, utilice la función createSession(properties) método. En properties es un objeto opcional que se utiliza para especificar si la sesión utiliza el Media Router, para especificar una pista de ubicación y para especificar si la sesión se archivará automáticamente o no. automáticamente. session devuelto es una instancia de sesión. Los objetos session tienen un sessionId propiedad que es útil para ser guardada en un almacén persistente (como una base de datos).

// Create a session that will attempt to transmit streams directly between
// clients. If clients cannot connect, the session uses the Vonage TURN server:
try {
    const session = await vonage.video.createSession();
    // save the sessionId
    db.save("session", session.sessionId, done);
} catch(error) {
    console.error("Error creating session: ", error);
}

// The session will use the Vonage Media Router:
try {
    const session = await vonage.video.createSession({ mediaMode: MediaMode.ROUTED });
    // save the sessionId
    db.save("session", session.sessionId, done);
} catch(error) {
    console.error("Error creating session: ", error);
}

// A Session with a location hint
try {
    const session = await vonage.video.createSession({ location: "12.34.56.78" });
    // save the sessionId
    db.save("session", session.sessionId, done);
} catch(error) {
    console.error("Error creating session: ", error);
}

// A Session with an automatic archiving
try {
    const session = await vonage.video.createSession({ mediaMode: MediaMode.ROUTED, archiveMode: "always" });
    // save the sessionId
    db.save("session", session.sessionId, done);
} catch(error) {
    console.error("Error creating session: ", error);
}

Generación de fichas

Una vez creada una Sesión, puede empezar a generar Tokens para que los clientes los utilicen cuando se conecten a ella. Puede generar un token llamando a la función generateClientToken(sessionId) método.

Para el control del diseño en archivos y emisiones, la lista inicial de clases de diseño de los flujos publicados de las conexiones que utilizan este token.

// Generate a Token from just a sessionId (fetched from a database)
const options = {
    role: "moderator",
    expireTime: new Date().getTime() / 1000 + 7 * 24 * 60 * 60, // in one week
    data: "name=Johnny",
    initialLayoutClassList: ["focus"]
}
const token = vonage.video.generateClientToken(sessionId, options);

Trabajar con archivos

Puede iniciar la grabación de una sesión con la tecla startArchive(sessionId, options) método. En options es un objeto opcional que se utiliza para establecer el nombre de archivo. El parámetro archive es una instancia de Archive.

Tenga en cuenta que sólo puede iniciar un archivo en una Sesión con clientes conectados.

try {
    const archive = await vonage.video.startArchive(sessionId);
    // The id property is useful to save off into a database
    console.log("new archive:", archive.id);
} catch(error) {
    console.error("Error starting archive: ", error);
}

También puedes desactivar la grabación de audio o vídeo configurando la opción hasAudio o hasVideo propiedad de la página options a false:

const archiveOptions = {
  name: "Important Presentation",
  hasVideo: false, // Record audio only
};
try {
    const archive = await vonage.video.startArchive(sessionId, archiveOptions);
    // The id property is useful to save off into a database
    console.log("new archive:", archive.id);
} catch(error) {
    console.error("Error starting archive: ", error);
}

Por defecto, todos los flujos se graban en un único archivo (compuesto). Puede grabar los distintos de la sesión en archivos individuales (en lugar de en un único archivo compuesto) configurando la opción outputMode opción de 'individual' cuando llame al startArchive() método:

const archiveOptions = {
  name: "Important Presentation",
  outputMode: "individual",
};
try {
    const archive = await vonage.video.startArchive(sessionId, archiveOptions);
    // The id property is useful to save off into a database
    console.log("new archive:", archive.id);
} catch(error) {
    console.error("Error starting archive: ", error);
}

Puede detener la grabación de un Archivo iniciado utilizando la tecla stopArchive(archiveId) método. En archive devuelto en la llamada de retorno es una instancia de Archive.

try {
    const archiveResponse = await vonage.video.stopArchive(archiveId);
    console.log("Successfully stopped archive:", archiveResponse.id);
} catch(error) {
    console.error("Error stopping archive: ", error);
}

Para obtener un Archive (y toda la información sobre ella) de una instancia de archiveIdutilice el botón getArchive(archiveId) método.

Puede consultar las propiedades del archivo para obtener más detalles.

try {
    const archive = await vonage.video.getArchive(archiveId);
    console.log("Successfully retrieved archive:", archive.id);
} catch(error) {
    console.error("Error retrieving archive: ", error);
}

Para eliminar un Archivo, puede llamar a la función deleteArchive(archiveId) método.

// Delete an Archive from an archiveId (fetched from database)
try {
    const archiveResponse = await vonage.video.deleteArchive(archiveId);
    console.log("Successfully deleted archive:", archiveResponse.id);
} catch(error) {
    console.error("Error deleting archive: ", error);
}

También puedes obtener una lista de todos los Archivos que has creado (hasta 1000) con tu App ID. Para ello utilizando la función searchArchives(filter) método. El parámetro filter es un objeto opcional utilizado para especificar un sessionId, offset y count para ayudarle a paginar los resultados.

En archives devuelto es una matriz de Archive instancias. El sitio totalCount devuelto por la llamada de retorno es el número total de archivos que ha generado su App ID.

const filter = {
    sessionId: "2_MX2xMDB-flR1ZSBOb3YgMTkgMTE6MDk6NTggUFNUIDIwMTN-MC2zNzQxNzIxNX2"
    offset: 100,
    count: 50
}
try {
    const archives = await vonage.video.searchArchives(filter);
    console.log(`Successfully retrieved ${archives.count} archives`);
    for (let i = 0; i < archives.length; i++) {
        console.log(archives.items[i].id);
    }
} catch(error) {
    console.error("Error returning list of archives: ", error);
}

Tenga en cuenta que también puede crear una sesión archivada automáticamente, pasando en 'always' como el archiveMode cuando llame a la función createSession() (véase "Crear sesiones". arriba).

En el caso de los archivos compuestos, puede cambiar el diseño dinámicamente mediante la función updateArchiveLayout(archiveId, layout) método:

const layout = {
    type: "bestFit"
}
try {
    const archiveResponse = await vonage.video.updateArchiveLayout(archiveId,layout);
    console.log("Successfully updated archive layout:", archiveResponse);
} catch(error) {
    console.error("Error deleting archive: ", error);
}

Puede establecer la clase de diseño inicial para los flujos de un cliente estableciendo la clase layout cuando al crear el token para el cliente, utilizando la opción vonage.video.generateToken() método. Y puedes cambiar las clases de diseño para los flujos en una sesión llamando al método vonage.video.setStreamClassLists(sessionId, classListArray) método.

La configuración del diseño de los archivos compuestos es opcional. Por defecto, los archivos compuestos utilizan la disposición disposición "más adecuada" (véase Personalización del diseño de vídeo para composiciones archivos).

Para más información sobre el archivado, consulte el guía del desarrollador de archivado.

Trabajar con retransmisiones en directo

Sólo sesiones enrutadas admiten retransmisiones en directo.

Para iniciar un retransmisión en directo de una sesión de vídeo, llame al vonage.video.startBroadcast() método. Introduce tres parámetros: el ID de sesión para la sesión, las opciones para la emisión y una función de devolución de llamada:

const broadcastOptions = {
  outputs: {
    hls: {},
    rtmp: [
      {
        id: "foo",
        serverUrl: "rtmp://myfooserver/myfooapp",
        streamName: "myfoostream",
      },
      {
        id: "bar",
        serverUrl: "rtmp://mybarserver/mybarapp",
        streamName: "mybarstream",
      },
    ],
  },
  maxDuration: 5400,
  resolution: "640x480",
  layout: {
    type: "verticalPresentation",
  },
};

vonage.video.startBroadcast(sessionId, broadcastOptions)
  .then(broadcast => {
    console.log("Broadcast started: ", broadcast.id);
  })
  .catch(error => {
    console.log(error);
  })

Consulte la referencia de la API para obtener más información sobre options parámetro.

En caso de éxito, se pasa un objeto Broadcast a la función callback como segundo parámetro. El objeto Broadcast tiene propiedades que definen la emisión, entre las que se incluye una propiedad broadcastUrls que contiene las direcciones URL de los flujos de difusión. Consulte la referencia de la API para más detalles.

Llame al vonage.video.stopBroadcast() para detener una emisión en directo, introduzca el ID de emisión (el id del objeto Broadcast) como primer parámetro. El segundo es la función de devolución de llamada:

vonage.video.stopBroadcast(broadcastId)
  .then(broadcast => {
    console.log("Broadcast stopped: ", broadcast.id);
  })
  .catch(error => {
    console.log(error);
  })

También puede llamar al stop() del objeto Broadcast para detener una emisión.

Llame al vonage.video.getBroadcast() pasando un ID de emisión, para obtener un objeto Broadcast.

También puede obtener una lista de todas las difusiones que ha creado (hasta 1000) con su clave API. Para ello se realiza mediante la función vonage.video.searchBroadcasts(options) método. El parámetro options es un objeto opcional utilizado para especificar un offset, county sessionId para ayudarle a paginar los resultados. La llamada de retorno tiene una firma function(err, broadcasts, totalCount). En broadcasts devuelto por es una matriz de Broadcast instancias. El sitio totalCount devuelto por la llamada de retorno es el número total de emisiones que ha generado su App ID.

vonage.video.searchBroadcasts({ offset: 100, count: 50 })
  then(response) => {
    console.log(response.totalCount + " broadcasts");
    for (let i = 0; i < response.broadcasts.length; i++) {
      console.log(response.broadcasts[i].id);
    }
  })
  .catch(error => {
    console.log("error:", error);
  })

Para cambiar la disposición de la emisión, llame a la función vonage.video.updateArchiveLayout() método, pasando el ID de emisión y el diseño tipo.

Puede establecer la clase de diseño inicial para los flujos de un cliente estableciendo la clase layout cuando al crear el token para el cliente, utilizando la opción vonage.video.generateToken() método. Y puede cambiar las clases de diseño de los flujos en una sesión llamando al método vonage.video.setStreamClassLists(sessionId, classListArray) método.

La configuración del diseño de una emisión en directo es opcional. Por defecto, las emisiones en directo utilizan el diseño "más adecuado". -->

Envío de señales

Puede enviar una señal a todos los participantes de una sesión llamando a la función sendSignal(payload, sessionId, connectionId) método y establecer el connectionId a null:

const sessionId =
  "2_MX2xMDB-flR1ZSBOb3YgMTkgMTE6MDk6NTggUFNUIDIwMTN-MC2zNzQxNzIxNX2";

try {
    const signalResponse = await vonage.video.sendSignal({ type: "chat", data: "Hello" }, sessionId);
    console.log("Successfully sent signal:", signalResponse);
} catch(error) {
    console.error("Error sending signal: ", error);
}

O enviar una señal a un participante específico de la sesión llamando a la función sendSignal(payload, sessionId, connectionId) y configurando todos los parámetros, incluyendo connectionId:

const sessionId =
  "2_MX2xMDB-flR1ZSBOb3YgMTkgMTE6MDk6NTggUFNUIDIwMTN-MC2zNzQxNzIxNX2";
const connectionId = "02e80876-02ab-47cd-8084-6ddc8887afbc";
try {
    const signalResponse = await vonage.video.sendSignal({ type: "chat", data: "Hello" }, sessionId, connectionId);
    console.log("Successfully sent signal:", signalResponse);
} catch(error) {
    console.error("Error sending signal: ", error);
}

Es el equivalente en el lado del servidor a sendSignal() en los SDK de cliente. Véase guía del desarrollador de señalización .

Desconectar a los participantes

Puede desconectar a los participantes de una sesión utilizando el botón disconnectClient(sessionId, connectionId) método.

try {
    const disconnectResponse = await vonage.video.disconnectClient(sessionId, connectionId);
    console.log("Successfully disconnected client:", disconnectResponse);
} catch(error) {
    console.error("Error disconnecting client: ", error);
}

Obligar a los clientes de una sesión a silenciar el audio publicado

Puede forzar al editor de un flujo específico a dejar de publicar audio utilizando la opción muteStream(sessionId, streamId)método.

Puede forzar al editor de todos los flujos de una sesión (excepto una lista opcional de flujos) para que deje de publicar audio mediante la opción forceMuteAll() . A continuación, puede desactivar el estado mudo de la sesión llamando al método disableForceMute() método.

Obtener información sobre el flujo

Puede obtener información sobre un flujo activo en una sesión:

const sessionId =
  "2_MX6xMDB-fjE1MzE3NjQ0MTM2NzZ-cHVTcUIra3JUa0kxUlhsVU55cTBYL0Y1flB";
const streamId = "2a84cd30-3a33-917f-9150-49e454e01572";
try {
    const stream = await vonage.video.getStreamInfo(sessionId, streamId);
    console.log(stream.id); // '2a84cd30-3a33-917f-9150-49e454e01572'
    console.log(stream.videoType); // 'camera'
    console.log(stream.name); // 'Bob'
    console.log(stream.layoutClassList); // ['main']
} catch(error) {
    console.error("Error retrieving stream: ", error.message);
}

Pasar un ID de sesión y un ID de flujo al getStreamInfo() método. Una vez completado con éxito, el stream que contiene las propiedades del flujo.

try {
    const streams = await vonage.video.getStreamInfo(sessionId);
    console.log(`Successfully retrieved ${streams.count} streams`);
    for (let i = 0; i < streams.length; i++) {
        console.log(streams.items[i].id);
    }
} catch(error) {
    console.error("Error retrieving streams: ", error);
}

Requisitos

Necesitas un ID de Vonage App y una clave privada, que puedes obtener iniciando sesión en tu Cuenta API de Video de Vonage.

El SDK de Node requiere Node.js 6 o superior. Es posible que funcione en versiones anteriores, pero ya no se prueban.

Notas de publicación

Véase el Comunicados en GitHub para obtener más información sobre cada versión.

<script>
  const currentPage = 'node_sdk';
  $('#download, #samples, #github').click(function(event) {
    gaEvent(currentPage, 'top_banner: ' + event.currentTarget.id);
  });
</script>