SDK serveur .NET

La vidéo Vonage SDK .NET fournit des méthodes pour :

Installation

NuGet (recommandé) :

Recherchez "Vonage" dans votre gestionnaire de paquets, ou exécutez la commande suivante à l'aide de la commande Console du gestionnaire de paquets:

PM> Install-Package Vonage

Ou un terminal :

dotnet add package Vonage

Utilisation

Initialisation

Les paquets Vonage utilisent un JWT pour l'autorisation. Le SDK gère la génération de JWT en arrière-plan pour vous, mais vous aurez besoin d'un fichier ApplicationId et PrivateKey en tant qu'informations d'identification afin de générer le jeton.

Ces informations d'identification doivent être stockées dans les paramètres de votre projet. N'hésitez pas à jeter un coup d'œil à la section Configuration pour savoir comment procéder.

Ensuite, vous pouvez enregistrer toutes les dépendances pour le SDK .NET en utilisant l'extension suivante :

// For 'Scoped' lifecycle
builder.Services.AddVonageClientScoped(builder.Configuration);
// Foor 'Transient' lifecycle
builder.Services.AddVonageClientTransient(builder.Configuration);

Cela vous permet d'injecter n'importe quel client dans vos composants, comme :

public CustomerController(IVideoClient client) {}
// or
public CustomerController(VonageClient client) {}

Sinon, il est toujours possible d'instancier l'ensemble du client manuellement. Vous devrez disposer des deux éléments suivants ApplicationId et PrivateKey dans les variables, et créer un Credentials article.

using Vonage;
using Vonage.Request;

...
var credentials = Credentials.FromAppIdAndPrivateKeyPath(applicationId, privateKeyPath);
var client = new VonageClient(credentials).VideoClient;

Le client Video expose diverses fonctionnalités de nos API Video.

Comment traiter les résultats des vidéos

Chaque méthode renvoie la réponse sous la forme d'un fichier Result<T> Monade, où T est le type de réponse.

Il contient soit un état de réussite (T) si l'opération a réussi ou un état d'échec (IResultFailure) si quelque chose s'est mal passé. L'échec contient un message d'erreur et peut être converti en l'exception correspondante. Il peut représenter n'importe quel type de problème :

  • demande non valide
  • échec de l'authentification
  • échec de la demande
  • échec de la désérialisation des données
  • etc.

Vous pouvez utiliser .Match() pour fournir des méthodes pour les deux états, ou vous pouvez appeler .GetSuccessUnsafe pour obtenir la réponse et lever une exception si le processus a échoué. Il contient également d'autres méthodes pour manipuler, transformer et extraire le résultat sous-jacent.

Détails et explications sur le mode dépôt.

Création de sessions

Pour créer une session vidéo Vonage, appelez le numéro de téléphone du client. VideoClient.SessionClient.CreateSessionAsync(CreateSessionRequest)méthode. Vous pouvez utiliser un default avec toutes les valeurs par défaut, ou créez-en une personnalisée en utilisant la commande .Build() méthode.

  • location : Une adresse IPv4 utilisée comme indice de localisation. (par défaut : string.empty)
  • MediaMode : Spécifie si la session utilisera la fonction Routeur vidéo multimédia de Vonage) (MediaMode.ROUTED) ou tenter de transmettre les flux directement entre les clients (MediaMode.RELAYED, par défaut). Une session routée est nécessaire pour certaines fonctions de Vonage Video (comme l'archivage).
  • ArchiveMode : Spécifie si la session sera automatiquement archivée (ArchiveMode.ALWAYS) ou non (ArchiveMode.MANUAL, par défaut). (ArchiveMode.ALWAYS) ou non (ArchiveMode.MANUAL, par défaut)

La valeur de retour est un Result<CreateSessionResponse> objet.

// Create a session that will attempt to transmit streams directly between clients 
Result<CreateSessionRequest> request = CreateSessionRequest.Default;
// Or create a custom request
Result<CreateSessionRequest> request = CreateSessionRequest.Build()
    .WithLocation("192.168.1.1")
    .WithMediaMode(MediaMode.Routed)
    .WithArchiveMode(ArchiveMode.Always)
    .Create();
    
// Send the request to the API
Result<CreateSessionResponse> response = await client.SessionClient.CreateSessionAsync(request);

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 GenerateToken méthode.

var generator = services.GetRequiredService<IVideoTokenGenerator>(); 
var credentials = ...
var claims = TokenAdditionalClaims.Parse(sessionId); 

var token = generator.GenerateToken(credentials, claims)

Travailler avec les archives

Vous ne pouvez archiver que les sessions qui utilisent le routeur vidéo de Vonage (sessions dont le mode média est réglé sur routé).

Création d'une archive

Vous pouvez démarrer l'enregistrement d'une session vidéo Vonage en utilisant VideoClient.ArchiveClient.CreateArchiveAsync(CreateSessionRequest) méthode. La valeur de retour est un Result<CreateArchiveRequest> objet.

Notez que vous ne pouvez lancer une archive que sur une session à laquelle des clients sont connectés.

// Creates an archive with default values.
Result<CreateArchiveRequest> request = CreateArchiveRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .Create();
// Or use any optional value on the builder.    
Result<CreateArchiveRequest> request =  CreateArchiveRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithName("Archive Name")
    .WithRenderResolution(RenderResolution.FullHighDefinitionLandscape)
    .WithArchiveLayout(new Layout(LayoutType.BestFit, string.Empty, LayoutType.Pip))
    .WithOutputMode(OutputMode.Composed)
    .WithStreamMode(StreamMode.Auto)
    .DisableAudio()
    .DisableVideo()
    .Create();

// Send the request to the API
Result<Archive> response = await client.ArchiveClient.CreateArchiveAsync(request);

Voici toutes les méthodes que vous pouvez utiliser sur le constructeur :

  • WithName permet d'ajouter un nom à l'archive (à utiliser pour l'identification).
  • DisableVideo permet de désactiver l'enregistrement vidéo.
  • DisableAudio permet de désactiver l'enregistrement audio.
  • WithResolution permet de définir la résolution de l'enregistrement. Veuillez noter que vous ne pouvez pas spécifier la resolution lorsque vous réglez le outputMode au paramètre OutputMode.INDIVIDUAL.
  • WithOutputMode permet de définir le mode de sortie du flux. Par défaut, tous les flux sont enregistrés dans un seul fichier ( composé). Vous pouvez enregistrer les différents flux de la session dans des fichiers individuels (au lieu d'un seul fichier composé). ) en indiquant OutputMode.INDIVIDUAL.
  • WithStreamMode permet d'indiquer si les flux sont sélectionnés automatiquement ou manuellement.

Arrêt d'une archive

Vous pouvez arrêter l'enregistrement d'une archive commencée à l'aide de la fonction l'outil VideoClient.ArchiveClient.StopArchiveAsync(StopArchiveRequest) méthode.

Result<StopArchiveRequest> request = StopArchiveRequest.Build()
    .WithApplicationId(applicationId)
    .WithArchiveId(archiveId)
    .Create();
Result<Archive> response = await client.ArchiveClient.StopArchiveAsync(request);

Récupération d'une archive

Vous pouvez récupérer un Archiveavec toutes ses informations, en utilisant le VideoClient.ArchiveClient.GetArchiveAsync(GetArchiveRequest) méthode.

var request = GetArchiveRequest.Build()
    .WithApplicationId(applicationId)
    .WithArchiveId(archiveId)
    .Create();
Result<Archive> response = await client.ArchiveClient.GetArchiveAsync(request);

Suppression d'une archive

Vous pouvez supprimer une archive à l'aide de la fonction VideoClient.ArchiveClient.DeleteArchiveAsync(DeleteArchiveRequest) méthode.

var request = DeleteArchiveRequest.Build()
    .WithApplicationId(applicationId)
    .WithArchiveId(archiveId)
    .Create();
Result<Unit> response = await client.ArchiveClient.DeleteArchiveAsync(request);

Récupération de toutes les archives

Vous pouvez obtenir une liste de toutes les archives que vous avez créées, jusqu'à 1000 archives, à l'aide de la fonction l'outil VideoClient.ArchiveClient.GetArchivesAsync(GetArchivesRequest) méthode.

Cette demande prend en charge la pagination à l'aide de WithCount et WithOffset sur le constructeur.

// Get a list with the first 1000 archives
var request = GetArchivesRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .Create();
// Get the first 50 archives
var request = GetArchivesRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithCount(50)
    .Create();
// Get the next 50 archives
var request = GetArchivesRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithCount(50)
    .WithOffset(50)
    .Create();
    
Result<GetArchivesResponse> response = await client.ArchiveClient.GetArchivesAsync(request);

Travailler avec des flux

Récupération d'un flux

Vous pouvez récupérer un Streamavec toutes ses informations, en utilisant le VideoClient.SessionClient.GetStreamAsync(GetStreamRequest) méthode.

var request = GetStreamRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithStreamId(streamId)
        .Create();
Result<GetStreamResponse> response = await client.SessionClient.GetStreamAsync(request);

Récupération de tous les flux

Vous pouvez récupérer tous les flux d'une session à l'aide de la fonction VideoClient.SessionClient.GetStreamsAsync(GetStreamsRequest) méthode.

var request = GetStreamsRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .Create();
Result<GetStreamsResponse> response = await client.SessionClient.GetStreamsAsync(request);

Forcer la déconnexion

Votre serveur d'application peut déconnecter un client d'une session Vonage Video à l'aide de l'aide de l'option VideoClient.ModerationClient.DisconnectConnectionAsync(DisconnectConnectionRequest) méthode.

var request = DisconnectConnectionRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithConnectionId(connectionId)
        .Create();
Result<Unit> response = await client.ModerationClient.DisconnectConnectionAsync(request);

Envoi de signaux

Une fois qu'une session est créée, vous pouvez envoyer des signaux à tous les participants à la session ou à une connexion spécifique.

Les Content est une instance de SignalContentoù vous pouvez définir type et data.

  • type (chaîne) : La chaîne de caractères du signal. Vous pouvez envoyer un maximum de 128 caractères. suivants sont autorisés : A-Z, a-z, Numbers (0-9), '-', '_' et '~'.
  • data (chaîne) : Chaîne de données pour le signal. Vous pouvez envoyer un maximum de 8 ko.
// Send a signal to a specific connection
var request = SendSignalRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithConnectionId(connectionId)
    .WithContent(new SignalContent("type", "data"))
    .Create();
Result<Unit> response = await client.SignalingClient.SendSignalAsync(request);

// Send a signal to all connections in a session
var request = SendSignalsRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithContent(new SignalContent("type", "data"))
    .Create();
Result<Unit> response = await client.SignalingClient.SendSignalsAsync(request);

Travailler avec des émissions en direct

Lancer une émission

Vous pouvez lancer une diffusion en direct d'une session vidéo Vonage à l'aide des éléments suivants le VonageClient.BroadcastClient.StartBroadcastsAsync(StartBroadcastRequest) méthode.

var request = StartBroadcastRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithLayout(new Layout(LayoutType.BestFit, string.Empty, LayoutType.HorizontalPresentation))
    .WithOutputs(new StartBroadcastRequest.BroadcastOutput())
    .Create();
Result<Broadcast> response = await client.BroadcastClient.StartBroadcastsAsync(request);

Arrêt d'une diffusion

Vous pouvez arrêter une diffusion à l'aide de la touche VonageClient.BroadcastClient.StopBroadcastsAsync(StopBroadcastRequest) méthode.

var request = StopBroadcastRequest.Build()
    .WithApplicationId(applicationId)
    .WithBroadcastId(broadcastId)
    .Create();
Result<Broadcast> response = await client.BroadcastClient.StopBroadcastAsync(request);

Voir également la documentation relative à l'option VonageClient.BroadcastClient.StopBroadcastsAsync(StopBroadcastRequest) et VonageClient.BroadcastClient.GetBroadcastsAsync(GetBroadcastRequest) des méthodes.

Récupération d'une émission

Vous pouvez récupérer une diffusion à l'aide de la fonction VonageClient.BroadcastClient.StopBroadcastsAsync(StopBroadcastRequest) méthode.

var request = GetBroadcastRequest.Build()
    .WithApplicationId(applicationId)
    .WithBroadcastId(broadcastId)
    .Create();
Result<Broadcast> response = await client.BroadcastClient.GetBroadcastAsync(request);

Récupération des émissions

Vous pouvez récupérer toutes les diffusions à l'aide de la fonction VonageClient.BroadcastClient.StopBroadcastsAsync(StopBroadcastRequest) méthode. Cette méthode prend également en charge la pagination.

var request = GetBroadcastsRequest.Build()
    .WithApplicationId(applicationId)
    .WithSessionId(sessionId)
    .WithCount(50)
    .WithOffset(50)
    .Create();
Result<GetBroadcastsResponse> response = await client.BroadcastClient.GetBroadcastsAsync(request);

SIP

Lancer un appel SIP

Vous pouvez connecter une plateforme SIP à une session Vonage Video en utilisant le VonageClient.SipClient.InitiateCallAsync(InitiateCallRequest) méthode.

var request = InitiateCallRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithToken(token)
        .WithSipUri(sipUri)
        .Create();
Result<InitiateCallResponse> response = await client.SipClient.InitiateCallAsync(request);

Jouer un son

Vous pouvez envoyer des chiffres DTMF à tous les participants d'une session vidéo Vonage active ou à un client spécifique connecté à cette session. session.

// Send digits to all participants in the session
var request = PlayToneIntoCallRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithDigits(digits)
        .Create();
Result<Unit> response = await client.SipClient.PlayToneIntoCallAsync(request);

// Send digits to a specific connection
var request = PlayToneIntoConnectionRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithConnectionId(connectionId)
        .WithDigits(digits)
        .Create();
Result<Unit> response = await client.SipClient.PlayToneIntoConnectionAsync(request);

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

Vous pouvez forcer l'éditeur à cesser de publier de l'audio, pour un flux spécifique ou pour tous les flux d'une session.

// Mute all streams in a session, and mark the session as "muted"
var request = MuteStreamsRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithConfiguration(new MuteStreamsRequest.MuteStreamsConfiguration(true, Array.Empty<string>()))
        .Create();
Result<MuteStreamsResponse> response = await client.ModerationClient.MuteStreamsAsync(request);

// Mute a specific stream
var request = MuteStreamRequest.Build()
        .WithApplicationId(applicationId)
        .WithSessionId(sessionId)
        .WithStreamId(streamId)
        .Create();
Result<MuteStreamResponse> response = await client.ModerationClient.MuteStreamAsync(request);

Exigences

Vous avez besoin d'une application avec Video activées. Les ApplicationId et le PrivateKey sera nécessaire pour l'authentification.

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

Le SDK .NET de Vonage cible netstandard2.0qui est compatible avec avec tous les cadres pris en charge.

Notes de mise à jour

Voir le .NET SDK changelog pour plus de détails sur chaque version.