SDK de Node para la Video API de Vonage

El SDK de Node proporciona métodos para:

Instalación mediante npm (recomendado):

NPM ayuda a gestionar las dependencias de los proyectos de Node. Para más información, consulta aquí: http://npmjs.org

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

npm install @vonage/server-sdk

Uso

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 El parámetro es un objeto opcional que se utiliza para especificar si la sesión utiliza el Media Router, para indicar una sugerencia de ubicación y para especificar si la sesión se archivará automáticamente o . El 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: Math.floor(Date.now() / 1000) + 24 * 60 * 60, // in 24 hours
    data: "name=Johnny",
    initialLayoutClassList: ["focus"]
}
const token = vonage.video.generateClientToken(sessionId, options);

Trabajar con archivos

Puedes iniciar la grabación de una sesión utilizando el 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.

Ten en cuenta que solo puedes 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 parámetro 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);
}

De forma predeterminada, todas las secuencias se graban en un único archivo (compuesto). Puedes grabar las diferentes secuencias de la sesión en archivos individuales (en lugar de en un único archivo compuesto) configurando el outputMode opción de 'individual' cuando llamas 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. El archive Lo que se devuelve en la función de llamada 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 archiveId, utiliza el getArchive(archiveId) método.

Puedes 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, puedes 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 hayas creado (hasta 1000) con tu ID de aplicación. Para ello, se utiliza la searchArchives(filter) método. El parámetro filter es un objeto opcional utilizado para especificar un sessionId, offset y count para ayudarte a navegar por los resultados.

El archives devuelto es una matriz de Archive casos. El 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 opción al llamar a la 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);
}

Puedes establecer la clase de diseño inicial para las transmisiones de un cliente configurando el 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 para desarrolladores sobre el archivado.

Trabajar con retransmisiones en directo

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

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

Si la operación se realiza correctamente, se pasa un objeto `Broadcast` a la función de llamada de retorno como segundo parámetro. El objeto `Broadcast` tiene propiedades que definen la difusión, entre ellas un 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() método del objeto Broadcast para detener una emisión.

Llame al vonage.video.getBroadcast() método, pasando un identificador 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 que se utiliza para especificar un offset, county sessionId para ayudarte a paginar los resultados. La función de llamada tiene la siguiente sintaxis: function(err, broadcasts, totalCount). En broadcasts Lo que devuelve la función de llamada es una matriz de Broadcast casos. El 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, pasándole el ID de difusión y el diseño tipo.

Puedes establecer la clase de diseño inicial para las transmisiones de un cliente configurando el 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 configuración el connectionId parámetro 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 bien, envía una señal a un participante concreto de la sesión llamando al 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);
}

Esto es el equivalente en el lado del servidor a la sendSignal() método en los SDK de cliente. Véase Guía para desarrolladores de señalización .

Desconexión de participantes

Puedes desconectar a los participantes de una sesión utilizando el 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);
}

Forzar 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() método. A continuación, puedes desactivar el estado de silencio de la sesión llamando al 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 aplicación de Vonage 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 página 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>