Vonage Video API Node SDK

Das Node SDK bietet Methoden für:

Erzeugen von Sitzungen und Token
Arbeit mit Archiven
Arbeiten mit Live-Streaming-Übertragungen
Senden von Signalen an Clients, die mit einer Sitzung verbunden sind

Installation mit npm (empfohlen):

NPM hilft bei der Verwaltung von Abhängigkeiten für Node-Projekte. Mehr Informationen finden Sie hier: http://npmjs.org

Führen Sie diesen Befehl aus, um das Paket zu installieren und es zu Ihrem package.json:

npm install @vonage/server-sdk

Verwendung

Initialisierung

Importieren Sie das Modul, um eine Konstruktorfunktion für ein Videoobjekt zu erhalten, und rufen Sie sie dann mit new auf ein Videoobjekt mit Ihrer eigenen App-ID und Ihrem privaten Schlüssel zu erstellen.

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

Sitzungen erstellen

Um eine Sitzung zu erstellen, verwenden Sie die createSession(properties) Methode. Die Website properties ist ein optionales Objekt, mit dem angegeben werden kann, ob die Sitzung den Media Router verwendet wird, um einen Hinweis auf den Speicherort zu geben, und um anzugeben, ob die Sitzung automatisch archiviert wird oder . session zurückgegeben wird, ist eine Instanz von Session. Sitzungsobjekte haben eine sessionId Eigenschaft, die es die in einem dauerhaften Speicher (z. B. einer Datenbank) gespeichert werden sollen.

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

Token generieren

Sobald eine Sitzung erstellt ist, können Sie damit beginnen, Token zu erzeugen, die die Clients bei der Verbindung mit der Sitzung verwenden können. Sie können ein Token erzeugen, indem Sie die Funktion generateClientToken(sessionId) Methode.

Für die Layoutkontrolle in Archiven und Broadcasts kann die anfängliche Layoutklassenliste von Streams, die von Verbindungen, die dieses Token verwenden, ebenfalls festgelegt werden.

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

Arbeit mit Archiven

Sie können die Aufzeichnung einer Sitzung mit der Taste startArchive(sessionId, options) Methode. Die Website options ist ein optionales Objekt, das zum Festlegen des Namens des Archivs festzulegen. Der archive zurückgegeben wird, ist eine Instanz von Archive.

Beachten Sie, dass Sie ein Archiv nur in einer Sitzung mit verbundenen Clients starten können.

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

Sie können die Audio- oder Videoaufzeichnung auch deaktivieren, indem Sie die Option hasAudio oder hasVideo Eigenschaft der der options Parameter zu 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);
}

Standardmäßig werden alle Streams in einer einzigen (zusammengesetzten) Datei aufgezeichnet. Sie können die verschiedenen Streams in der Sitzung in einzelnen Dateien (statt in einer einzigen zusammengesetzten Datei) aufzeichnen, indem Sie den Parameter outputMode Option zu 'individual' wenn Sie die startArchive() Methode:

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

Sie können die Aufzeichnung eines gestarteten Archivs mit der Taste stopArchive(archiveId) Methode. Die Website archive die im Rückruf zurückgegeben wird, ist eine Instanz von Archive.

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

Um eine Archive Instanz (und alle Informationen darüber) aus einer archiveIdverwenden Sie die getArchive(archiveId) Methode.

Sie können die Eigenschaften des Archivs überprüfen, um weitere Einzelheiten zu erfahren.

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

Um ein Archiv zu löschen, können Sie die Funktion deleteArchive(archiveId) Methode.

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

Sie können auch eine Liste aller Archive erhalten, die Sie mit Ihrer App-ID erstellt haben (bis zu 1000). Dies geschieht mit der Funktion searchArchives(filter) Methode. Der Parameter filter ist ein optionales Objekt, das zur Angabe einer sessionId, offset und count um Ihnen das Durchblättern der Ergebnisse zu erleichtern.

Die archives zurückgegeben wird, ist ein Array aus Archive Instanzen. Die totalCount die vom Rückruf zurückgegeben wird, ist die Gesamtzahl der Archive, die Ihre App-ID erzeugt hat.

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

Beachten Sie, dass Sie auch eine automatisch archivierte Sitzung erstellen können, indem Sie in 'always' als die archiveMode wenn Sie die Option createSession() Methode (siehe "Sitzungen erstellen". oben).

Für zusammengesetzte Archive können Sie das Layout dynamisch ändern, indem Sie die updateArchiveLayout(archiveId, layout) Methode:

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

Sie können die anfängliche Layoutklasse für die Streams eines Clients festlegen, indem Sie die layout Option, wenn Sie das Token für den Client erstellen, indem Sie die vonage.video.generateToken() Methode. Und Sie können die Layoutklassen für Streams in einer Sitzung ändern, indem Sie die Methode vonage.video.setStreamClassLists(sessionId, classListArray) Methode.

Die Festlegung des Layouts von zusammengestellten Archiven ist optional. Standardmäßig verwenden zusammengestellte Archive das "best fit" Layout (siehe Anpassen des Videolayouts für zusammengesetzte Archive).

Weitere Informationen zur Archivierung finden Sie in der Leitfaden für Archivierungsentwickler.

Arbeiten mit Live-Streaming-Übertragungen

Nur weitergeleitete Sitzungen Live-Streaming-Übertragungen unterstützen.

Zum Starten einer Live-Streaming-Übertragung einer Video-Session, rufen Sie die vonage.video.startBroadcast() Methode. Übergeben Sie drei Parameter: die Sitzungs-ID für die Sitzung, Optionen für die Übertragung und eine Callback-Funktion:

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

Siehe die API-Referenz für Details über die options Parameter.

Bei Erfolg wird ein Broadcast-Objekt als zweiter Parameter an die Callback-Funktion übergeben. Das Broadcast-Objekt hat Eigenschaften, die den Broadcast definieren, einschließlich einer broadcastUrls Eigenschaft, die URLs für die Broadcast-Streams enthält. Siehe die API-Referenz für Details.

Rufen Sie die vonage.video.stopBroadcast() Methode, um eine Live-Streaming-Übertragung zu stoppen, geben Sie die Broadcast-ID (die id Eigenschaft des Broadcast-Objekts) als ersten Parameter. Der zweite Parameter ist die Rückruffunktion:

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

Sie können auch die stop() Methode des Broadcast-Objekts, um einen Broadcast zu stoppen.

Rufen Sie die vonage.video.getBroadcast() Methode und geben Sie eine Broadcast-ID ein, um ein Broadcast-Objekt zu erhalten.

Sie können auch eine Liste aller Sendungen abrufen, die Sie mit Ihrem API-Schlüssel erstellt haben (bis zu 1000). Dies geschieht erfolgt über die vonage.video.searchBroadcasts(options) Methode. Der Parameter options ist ein optionales Objekt, das zur Angabe einer offset, countund sessionId um Ihnen das Paginieren durch die Ergebnisse zu erleichtern. Der Callback hat eine Signatur function(err, broadcasts, totalCount). Die broadcasts zurückgegeben von der Rückruf ist ein Array von Broadcast Instanzen. Die totalCount die vom Callback zurückgegeben wird, ist die Gesamtzahl der Sendungen, die Ihre App-ID erzeugt hat.

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

Um das Broadcast-Layout zu ändern, rufen Sie die Funktion vonage.video.updateArchiveLayout() Methode, Übergabe der Broadcast-ID und des Layout Typ.

Sie können die anfängliche Layoutklasse für die Streams eines Clients festlegen, indem Sie die layout Option, wenn Sie das Token für den Client erstellen, indem Sie die vonage.video.generateToken() Methode. Und Sie können die Layoutklassen für Streams in einer Sitzung ändern, indem Sie die vonage.video.setStreamClassLists(sessionId, classListArray) Methode.

Die Einstellung des Layouts einer Live-Streaming-Übertragung ist optional. Standardmäßig wird bei Live-Streaming-Übertragungen das Layout "best fit". -->

Senden von Signalen

Sie können ein Signal an alle Teilnehmer einer Sitzung senden, indem Sie die Funktion sendSignal(payload, sessionId, connectionId) Methode und Einstellung die connectionId Parameter zu 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);
}

Oder senden Sie ein Signal an einen bestimmten Teilnehmer der Sitzung, indem Sie die Funktion sendSignal(payload, sessionId, connectionId) Methode und Einstellung aller Parameter, einschließlich 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);
}

Dies ist das serverseitige Äquivalent zum sendSignal() Methode in den Client-SDKs. Siehe Leitfaden für Signalisierungsentwickler .

Trennen von Teilnehmern

Sie können Teilnehmer von einer Sitzung trennen, indem Sie die disconnectClient(sessionId, connectionId) Methode.

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

Erzwingen, dass Clients in einer Sitzung das veröffentlichte Audio stummschalten

Sie können den Herausgeber eines bestimmten Streams zwingen, die Veröffentlichung von Audio zu beenden, indem Sie die muteStream(sessionId, streamId)Methode.

Sie können den Herausgeber aller Streams in einer Sitzung (mit Ausnahme einer optionalen Liste von Streams) zwingen die Veröffentlichung von Audio zu beenden, indem Sie die forceMuteAll() Methode. Sie können dann den Stummschaltungsstatus der Sitzung deaktivieren, indem Sie die Methode disableForceMute() Methode.

Stream-Informationen abrufen

Sie können Informationen über einen aktiven Stream in einer Sitzung abrufen:

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

Übergeben Sie eine Sitzungs-ID und eine Stream-ID an die getStreamInfo() Methode. Nach erfolgreichem Abschluss wird die stream Objekt, das die Eigenschaften des Streams enthält.

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

Anforderungen

Sie benötigen eine Vonage App ID und einen privaten Schlüssel, die Sie erhalten, indem Sie sich bei Ihrem Vonage Video API-Konto.

Das Node SDK erfordert Node.js 6 oder höher. Es kann mit älteren Versionen funktionieren, aber sie werden nicht mehr getestet.

Anmerkungen zur Veröffentlichung

Siehe die Veröffentlichungen Seite auf GitHub für Details zu jeder Version.

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