SDK du nœud de l'API Video de Vonage

Le SDK Node fournit des méthodes pour :

Générer sessions et jetons
Travailler avec les archives
Travailler avec diffusion en direct
Envoi de signaux aux clients connectés à une session

Installation à l'aide de npm (recommandé) :

NPM aide à gérer les dépendances pour les projets de nœuds. Plus d'informations ici : http://npmjs.org

Exécutez cette commande pour installer le paquetage et l'ajouter à votre fichier package.json:

npm install @vonage/server-sdk

Utilisation

Initialisation

Importez le module pour obtenir une fonction de construction pour un objet vidéo, puis appelez-la avec new pour instancier un objet vidéo avec votre propre identifiant d'application et votre clé privée.

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

Création de sessions

Pour créer une session, utilisez la fonction createSession(properties) méthode. La méthode properties est un objet facultatif utilisé pour spécifier si la session utilise le routeur multimédia, pour spécifier un indice de localisation et pour spécifier si la session sera automatique. Media Router, pour spécifier un indice d'emplacement et pour indiquer si la session sera automatiquement archivée ou non. archivée ou non. session est une instance de session. Les objets session ont une valeur sessionId qui est qu'il est utile d'enregistrer dans une mémoire persistante (telle qu'une base de données).

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

Générer des jetons

Une fois qu'une session est créée, vous pouvez commencer à générer des jetons que les clients utiliseront pour se connecter à la session. Vous pouvez générer un jeton en appelant la fonction generateClientToken(sessionId) méthode.

Pour le contrôle de la mise en page dans les archives et les diffusions, la liste initiale des classes de mise en page des flux publiés à partir des connexions utilisant ce jeton peut également être définie. à partir de connexions utilisant ce jeton.

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

Travailler avec les archives

Vous pouvez lancer l'enregistrement d'une session à l'aide de la touche startArchive(sessionId, options) méthode. La méthode options est un objet facultatif utilisé pour définir le nom de l'archive. l'archive. Le paramètre archive renvoyée est une instance de Archive.

Notez que vous ne pouvez lancer une archive que sur une session dont les clients sont connectés. clients connectés.

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

Vous pouvez également désactiver l'enregistrement audio ou vidéo en réglant le paramètre hasAudio ou hasVideo propriété de la options au paramètre 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);
}

Par défaut, tous les flux sont enregistrés dans un seul fichier (composé). Vous pouvez enregistrer les différents de la session sur des fichiers individuels (au lieu d'un seul fichier composé) en définissant le paramètre outputMode à l'option 'individual' lorsque vous appelez le startArchive() méthode :

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

Vous pouvez arrêter l'enregistrement d'une archive commencée à l'aide de la touche stopArchive(archiveId) méthode. La méthode archive renvoyée dans le callback est une instance 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);
}

Pour obtenir un Archive (et toutes les informations la concernant) à partir d'une instance de archiveId, utiliser le getArchive(archiveId) méthode.

Vous pouvez consulter les propriétés de l'archive pour plus de détails.

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

Pour supprimer une archive, vous pouvez appeler le deleteArchive(archiveId) méthode.

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

Vous pouvez également obtenir une liste de toutes les archives que vous avez créées (jusqu'à 1000) avec votre App ID. Cela se fait à l'aide de la fonction searchArchives(filter) méthode. Le paramètre filter est un est un objet optionnel utilisé pour spécifier un sessionId, offset et count pour vous aider à parcourir les résultats.

Les archives est un tableau de Archive instances. Les totalCount renvoyée par le callback est le nombre total d'archives générées par votre 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);
}

Notez que vous pouvez également créer une session automatiquement archivée, en passant le paramètre 'always' en tant que archiveMode lorsque vous appelez l'option createSession() (voir "Création de sessions," ci-dessus).

Pour les archives composées, vous pouvez modifier la mise en page de manière dynamique, en utilisant la fonction updateArchiveLayout(archiveId, layout) méthode :

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

Vous pouvez définir la classe de mise en page initiale pour les flux d'un client en définissant la propriété layout lorsque lorsque vous créez le jeton pour le client, à l'aide de l'option vonage.video.generateToken() et vous pouvez modifier les classes de présentation pour les flux dans une session en appelant la méthode Vous pouvez également modifier les classes de présentation pour les flux d'une session en appelant la méthode vonage.video.setStreamClassLists(sessionId, classListArray) méthode.

La définition de la mise en page des archives composées est facultative. Par défaut, les archives composées utilisent la mise en page "best fit" (voir Personnalisation de la mise en page vidéo pour les composées).

Pour plus d'informations sur l'archivage, voir la page guide du développeur pour l'archivage.

Travailler avec des émissions en direct

Seulement sessions acheminées prendre en charge les diffusions en direct.

Pour démarrer un diffusion en direct d'une session vidéo, appeler la fonction vonage.video.startBroadcast() méthode. Elle comporte trois paramètres : l'identifiant de la session, les options de diffusion et une fonction de rappel :

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

Voir la référence de l'API pour plus de détails sur la fonction options paramètre.

En cas de succès, un objet Broadcast est transmis à la fonction de rappel en tant que deuxième paramètre. L'objet Broadcast possède des propriétés qui définissent la diffusion, y compris un paramètre broadcastUrls qui contient les URL des flux de diffusion. Voir la référence de l'API pour plus de détails.

Appeler le vonage.video.stopBroadcast() pour arrêter une diffusion en continu en direct, passez l'identifiant de la diffusion (l'ID de la diffusion). (l'identifiant de la diffusion). id de l'objet Broadcast) comme premier paramètre. Le second est la fonction de rappel :

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

Vous pouvez également appeler le stop() de l'objet Broadcast pour arrêter une diffusion.

Appeler le vonage.video.getBroadcast() en indiquant l'ID de la diffusion, pour obtenir un objet de diffusion.

Vous pouvez également obtenir une liste de toutes les diffusions que vous avez créées (jusqu'à 1000) avec votre clé API. Cette opération s'effectue à l'aide de la à l'aide de la fonction vonage.video.searchBroadcasts(options) méthode. Le paramètre options est un est un objet optionnel utilisé pour spécifier un offset, countet sessionId pour vous aider à paginer dans les résultats. Le callback a une signature function(err, broadcasts, totalCount). Les broadcasts renvoyée par le rappel est un tableau de Broadcast instances. Les totalCount renvoyée par le callback est le nombre total de diffusions générées par votre 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);
  })

Pour modifier l'agencement de la diffusion, appelez l'option vonage.video.updateArchiveLayout() méthode, en transmettant l'ID de diffusion et le modèle type.

Vous pouvez définir la classe de mise en page initiale pour les flux d'un client en définissant la propriété layout lorsque lorsque vous créez le jeton pour le client, à l'aide de l'option vonage.video.generateToken() méthode. Et vous pouvez modifier les classes de présentation pour les flux d'une session en appelant la méthode vonage.video.setStreamClassLists(sessionId, classListArray) méthode.

La définition de la mise en page d'une diffusion en continu en direct est facultative. Par défaut, les diffusions en continu utilisent la mise en page "la mieux adaptée". -->

Envoi de signaux

Vous pouvez envoyer un signal à tous les participants d'une session en appelant la fonction sendSignal(payload, sessionId, connectionId) et de définir la connectionId au paramètre 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);
}

Vous pouvez également envoyer un signal à un participant spécifique de la session en appelant la fonction sendSignal(payload, sessionId, connectionId) et de définir tous les paramètres, y compris 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);
}

C'est l'équivalent côté serveur de la fonction sendSignal() dans les SDK clients. Voir guide du développeur de signaux .

Déconnexion des participants

Vous pouvez déconnecter les participants d'une session à l'aide de la fonction disconnectClient(sessionId, connectionId) méthode.

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

Forcer les clients d'une session à couper le son publié

Vous pouvez forcer l'éditeur d'un flux spécifique à cesser de publier de l'audio à l'aide de la commande muteStream(sessionId, streamId)méthode.

Vous pouvez forcer l'éditeur de tous les flux d'une session (à l'exception d'une liste optionnelle de flux) à cesser de publier de l'audio à l'aide de la commande forceMuteAll() et de la méthode de la sourdine. Vous pouvez ensuite désactiver la mise en sourdine de la session en appelant la méthode disableForceMute() méthode.

Obtenir des informations sur les flux

Vous pouvez obtenir des informations sur un flux actif dans une session :

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

Transmettre un identifiant de session et un identifiant de flux à la fonction getStreamInfo() méthode. En cas de réussite, le stream contenant les propriétés du flux.

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

Exigences

Vous avez besoin d'un identifiant et d'une clé privée Vonage App, que vous pouvez obtenir en vous connectant à votre compte Compte Video API de Vonage.

Le SDK Node nécessite Node.js 6 ou une version plus récente. Il peut fonctionner avec des versions plus anciennes, mais celles-ci ne sont plus testées.

Notes de mise à jour

Voir le Communiqués sur GitHub pour plus de détails sur chaque version.

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