S'abonner : Notions de base

Les <OTSession> envoie un streamCreated lorsqu'un nouveau flux (autre que le vôtre) est créé dans une session. Un flux est créé lorsqu'un client publie un flux dans la session. L'événement streamCreated est également déclenché pour chaque flux existant dans la session lors de la première connexion. L'objet d'événement streamCreated contient des informations sur le flux, notamment les données de connexion, le type de source vidéo ("caméra" ou "écran"), etc.

import OTSession from 'opentok-react-native';

<OTSession
  apiKey={apiKey}
  sessionId={sessionId}
  token={token}
  eventHandlers={{
    streamCreated: event => {
      console.log('Stream created -- stream ID:', event.streamId);
    },
  }}
/>

Une fois le nouveau flux détecté, abonnez-vous à lui comme décrit dans la section suivante.

L'objet Session envoie un streamCreated lorsqu'un nouveau flux (autre que le vôtre) est créé dans une session. Un flux est créé lorsqu'un client publie un flux vers la session. Les streamCreated est également déclenché pour chaque flux existant dans la session lors de la première connexion. Cet événement est défini par l'événement StreamEvent, qui possède un élément stream représentant le flux qui a été créé :

session.on("streamCreated", function (event) {
    console.log("New stream in the session: " + event.stream.streamId);
});
// Replace with a valid token:
session.connect(token);

Vous pouvez vous abonner à n'importe quel flux. Voir la section suivante.

Les onStreamReceived(Session session, Stream stream) de l'objet Session.SessionListener est appelée lorsqu'un flux publié par un autre client est créé dans une session. (Un flux est créé lorsqu'un client publie un flux dans la session ou si le flux existe lorsque vous vous connectez à la session).

@Override
public void onStreamReceived(Session session, Stream stream) {
    // There is a new stream.
    // You may want to subscribe to it.
}

Ajoutez un objet d'écoute pour cet événement en appelant la fonction setSessionListener(Session.SessionListener listener) de l'objet Session :

mSession.setSessionListener(this);

Les OTSessionDelegate session(_ session:streamCreated:) est envoyé lorsqu'un nouveau flux est créé dans une session. (Un flux est créé lorsqu'un client publie un flux vers la session). Le Objet OTStream possède des propriétés qui définissent le flux. Comparez les propriétés connection de l'objet OTStream avec la propriété connection de l'objet OTSession pour déterminer s'il s'agit d'un flux publié par votre client :

func session(_ session: OTSession, streamCreated stream: OTStream) {
    print("Session streamCreated: \(stream.streamId)")

    // See the declaration of subscribeToSelf above.
    if stream.connection.connectionId == session.connection.connectionId {
        // This is my own stream
    } else {
        // This is a stream from another client.
    }
}

Lorsque les flux quittent une session, le [OTSession session: streamDestroyed:] est envoyé. Lorsqu'un flux est abandonné, la vue de tout objet OTSubscriber pour le flux est supprimée de sa vue principale. Vérifiez que le flux n'est pas publié par votre propre client et supprimez sa vue de sa vue principale.

- (void)session:(OTSession*)session streamDestroyed:(OTStream *)stream
{
    NSLog(@"session streamDestroyed (%@)", stream.streamId);

    if ([subscriber.stream.streamId isEqualToString:stream.streamId])
    {
        [_subscriber.view removeFromSuperview];
        _subscriber = nil;
    }
}

Détection de la désactivation de la vidéo d'un abonné

Le délégué de l'abonné envoie le [OTSubscriberDelegate subscriberVideoDisabled:reason:] lorsque la vidéo de l'abonné est désactivée :

- (void)subscriberVideoDisabled:(OTSubscriber *)subscriber
                            reason:(OTSubscriberVideoEventReason)reason
{
    NSLog(@"subscriber video disabled.");
}

Les reason peut être défini comme l'une des constantes suivantes définies dans l'énumération OTSubscriberVideoEventReason :

• OTSubscriberVideoEventPublisherPropertyChanged - L'événement vidéo est dû à l'arrêt du flux vidéo par l'éditeur du flux.
• OTSubscriberVideoEventQualityChanged - L'événement vidéo a été causé par une modification de la qualité du flux vidéo. La qualité du flux peut changer en raison des conditions du réseau ou de l'utilisation de l'unité centrale de l'abonné ou de l'éditeur. Ce motif n'est utilisé que dans les sessions dont le mode média est défini sur "routé". (Voir Le routeur vidéo multimédia de Vonage et les modes médias.) Cette fonction du routeur vidéo multimédia de Vonage permet à un abonné d'interrompre le flux vidéo lorsque la qualité du flux vidéo se dégrade, et le message est envoyé. Lorsque les conditions s'améliorent, le flux vidéo reprend et le message est envoyé. [OTSubscriberKit subscriberVideoEnabled:reason:] est envoyé. Lorsque le flux vidéo est interrompu, l'abonné continue à recevoir le flux audio, s'il y en a un.
• OTSubscriberVideoEventSubscriberPropertyChanged - L'événement vidéo a été provoqué par une modification de l'adresse de l'abonné. OTSubscriberKit.subscribeToVideo propriété.

Si le flux vidéo reprend, le [OTSubscriberKit subscriberVideoEnabled:reason:] est envoyé.

Lorsque vous publiez un flux, vous pouvez éviter que sa vidéo soit désactivée en raison de la qualité du flux. Avant d'appeler la fonction [OTSession publish:error:] définir la méthode audioFallbackEnabled de l'objet Publisher (ou PublisherKit) à NO.

L'objet Session envoie un StreamReceived lorsqu'un flux publié par un autre client est créé dans une session. (Un flux est créé lorsqu'un client publie un flux à la session ou si le flux existe lorsque vous vous connectez à la session).

@Override
session.StreamReceived += Session_StreamReceived;

private void Session_StreamReceived(object sender, Session.StreamEventArgs e)
{
    Console.WriteLine("Session stream received");
}

Les on_stream_received de la fonction de rappel du otc_session_callbacks est appelée lorsqu'un flux publié par un autre client est créé dans une session. (Un flux est créé lorsqu'un client publie un flux à la session ou si le flux existe lorsque vous vous connectez à la session). Voir Instanciation d'une instance otc_session et rappels liés à la session.

Pour s'abonner à tous les flux de la session, ajoutez un objet OTSubscriber en tant que chile de l'objet OTSession :

<OTSession
  applicationId="the Application ID"
  sessionId="the session ID"
  token="the token">
  <OTSubscriber/>
</OTSession>

Une fois le client connecté à la session, l'objet OTSubscriber ajoute des vues pour les vidéos d'abonnés lorsque les flux d'autres clients deviennent disponibles dans la session.

L'objet OTSubscriber envoie un connected lorsqu'un abonné démarre avec succès la diffusion en continu. Il envoie un événement d'erreur s'il y a un problème de error abonnement. Définir un eventHandlers du composant OTSubscriber, et définir la propriété connected et error de cet objet à des fonctions de rappel :

<OTSubscriber
eventHandlers={{
  connected: () => {
    console.log('The subscriber started streaming.');
  },
  error: () => {
    console.log('The subscriber failed.');
  }
}}/>

Pour s'abonner à un flux, il suffit de passer l'objet Stream dans la fonction subscribe de l'objet Session :

session.subscribe(stream, replacementElementId);

Les subscribe() prend les paramètres suivants :

• stream-L'objet Stream.
• targetElement- (Facultatif) Définit l'élément DOM que la vidéo d'abonné remplace.
• properties- (Facultatif) Ensemble de propriétés permettant de personnaliser l'apparence de la vue Abonné dans la page HTML et de choisir de s'abonner ou non à l'audio et à la vidéo.

voir Personnaliser l'interface utilisateur

voir Réglage de l'audio et de la vidéo.

• completionHandler- (Facultatif) Une fonction qui est appelée de manière asynchrone lorsque l'appel à la fonction subscribe() se termine avec succès ou échoue. Si l'appel à la méthode subscribe() échoue, un objet d'erreur est transmis au gestionnaire d'achèvement. Cet objet a une valeur code et message qui décrivent l'erreur.

Le code suivant s'abonne à tous les flux, autres que ceux publiés par votre client :

session.on("streamCreated", function(event) {
    session.subscribe(event.stream);
});

// Replace with your token:
session.connect(token, function (error) {
    if(error) {
        // failed to connect
    }
});

Les insertMode de la propriété properties du paramètre Session.subscribe() spécifie comment l'objet Publisher sera inséré dans le DOM HTML, par rapport à l'objet targetElement paramètre. Ce paramètre peut prendre l'une des valeurs suivantes :

• "replace" - L'objet Subscriber remplace le contenu de l'élément targetElement. Il s'agit de la valeur par défaut.
• "after" - L'objet Subscriber est un nouvel élément inséré après le targetElement dans le DOM HTML. (L'abonné et l'élément cible ont tous deux le même élément parent).
• "before" - L'objet Subscriber est un nouvel élément inséré avant le targetElement dans le DOM HTML. (L'abonné et l'élément cible ont tous deux le même élément parent).
• "append" - L'objet Subscriber est un nouvel élément ajouté en tant qu'enfant de l'élément cible. S'il existe d'autres éléments enfants, le Publisher est ajouté en tant que dernier élément enfant du targetElement.

Par exemple, le code suivant ajoute un nouvel objet Abonné en tant qu'enfant d'un objet subscriberContainer Élément DOM :

session.on('streamCreated', function(event) {
  var subscriberProperties = {insertMode: 'append'};
  var subscriber = session.subscribe(event.stream,
    'subscriberContainer',
    subscriberProperties,
    function (error) {
      if (error) {
        console.log(error);
      } else {
        console.log('Subscriber added.');
      }
  });
});

L'objet Abonné possède une fonction element qui correspond à l'élément HTML DOM qui le contient.

Pour s'abonner à un flux, il faut d'abord instancier un objet Subscriber.Builder en appelant la fonction Subscriber.Builder(Context context, Stream stream) . Il s'agit d'un constructeur. Transmettez le contexte de l'application Android pour l'abonné et l'objet Stream. Appelez le build() pour créer l'objet Subscriber. Appelez ensuite la méthode subscribe() de l'objet Session pour commencer à s'abonner au flux :

mSubscriber = new Subscriber.Builder(context, stream)
    .build();
mSession.subscribe(mSubscriber);

Les SubscriberKit.SubscriberListener.onConnected(SubscriberKit subscriber) est appelée lorsque l'application commence à recevoir le flux de l'abonné. À ce stade, vous pouvez ajouter la vue de l'abonné (renvoyée par la méthode getView() de l'objet Subscriber) en tant que sous-vue d'un objet android.view.ViewGroup pour l'afficher dans l'application :

@Override
public void onConnected(subscriber) {
    // mViewContainer is an Android View
    RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(
            getResources().getDisplayMetrics().widthPixels, getResources()
                    .getDisplayMetrics().heightPixels);
    mViewContainer.addView(mSubscriber.getView(), layoutParams);
}

Se désabonner d'un flux

Pour arrêter la lecture d'un flux auquel vous êtes abonné, appelez la fonction Session.unsubscribe(Subscriber subscriber) méthode :

mSession.unsubscribe(mSubscriber);

L'abonné est déconnecté et sa vue est supprimée de sa vue secondaire.

Pour s'abonner à un flux, il faut appeler la fonction OTSubscriber init(stream:delegate:) en lui passant un objet OTStream et un objet délégué pour recevoir les messages liés à l'abonné. Appelez ensuite la méthodeOTSession subscribe(_:error:) pour commencer à s'abonner au flux :

func session(_ session: OTSession, streamCreated stream: OTStream) {
    subscriber = OTSubscriber(stream: stream, delegate: self)
    var error: OTError?
    session.subscribe(subscriber!, error: &error)
    
    if error {
        print("subscribe failed with error: \(error)")
    }
}

Les OTSubscriberDelegate subscriberDidConnect(toStream:) est envoyé lorsque l'application commence à recevoir le flux de l'abonné. À ce stade, vous pouvez ajouter la vue de l'abonné (représentée par la balise OTSubscriber view ) à l'application :

func subscriberDidConnect(toStream subscriber: OTSubscriberKit) {
    if let subscriberView = self.subscriber?.view {
        subscriberView.frame = CGRect(x: 0, y: 300, width: 400, height: 300)
        self.view.addSubview(subscriberView)
    }
}

Se désabonner d'un flux

Pour arrêter la lecture d'un flux auquel vous êtes abonné, appelez la fonction OTSession unsubscribe(_:error:) méthode :

var error: OTError?
session.unsubscribe(subscriber, error: &error)
if (error) {
    print("unsubscribe failed with error: \(error)")
}

L'abonné est déconnecté. Ensuite, il faut retirer sa vue de sa vue principale :

subscriber.view?.removeFromSuperview()

Pour s'abonner à un flux, il faut appeler la fonction [OTSubscriber initWithStream:] en lui passant un objet OTStream et un objet délégué pour recevoir les messages liés à l'abonné. Appelez ensuite la méthode[OTSession subscribe:error] pour commencer à s'abonner au flux :

- (void)session:(OTSession*)session streamCreated:(OTStream*)stream
{
    subscriber = [[OTSubscriber alloc] initWithStream:stream delegate:self];
    OTError* error = nil;
    [session subscribe:subscriber error:&error]
    if (error) {
      NSLog(@"subscribe failed with error: (%@)", error);
    }
}

Les [OTSubscriberDelegate subscriberDidConnectToStream:] est envoyé lorsque l'application commence à recevoir le flux de l'abonné. À ce stade, vous pouvez ajouter la vue de l'abonné (représentée par la balise OTSubscriber.view ) à l'application :

- (void)subscriberDidConnectToStream:(OTSubscriber*)subscriber
{
    [subscriber.view setFrame:CGRectMake(0, 300, 400, 300)];
    [self.view addSubview:subscriber.view];
}

Se désabonner d'un flux

Pour arrêter la lecture d'un flux auquel vous êtes abonné, appelez la fonction [OTSession unsubscribe:error:] méthode :

OTError* error = nil;
[session unsubscribe:_subscriber error:&error]
if (error) {
  NSLog(@"unsubscribe failed with error: (%@)", error);
}

L'abonné est déconnecté. Ensuite, il faut retirer sa vue de sa vue principale :

[subscriber.view removeFromSuperview:];

Pour s'abonner à un flux, il faut d'abord instancier un objet Subscriber en appelant la fonction Subscriber(context, stream, renderer) . Il s'agit d'un constructeur. Indiquez le contexte de l'application Windows pour l'abonné, l'objet Stream et un moteur de rendu vidéo.

Les OpenTok.IVideoRenderer définit le moteur de rendu vidéo. L'interface OpenTok.VideoRenderer incluse dans le SDK Windows de Vonage Video, rend la vidéo dans un contrôle Windows Presentation Framework. L'objet VideoRenderer est une sous-classe de System.Windows.Controls.Control.

Vous pouvez ajouter cet élément à votre hiérarchie de vues. Vous pouvez également créer votre propre moteur de rendu vidéo personnalisé qui implémente la méthode OpenTok.IVideoRenderer l'interface.

Appeler le subscribe() de l'objet Session pour commencer à s'abonner au flux :

VideoRenderer videoRenderer = new VideoRenderer();
// Add the video renderer to the application's view hierarchy.

Subscriber subscriber = new Subscriber(Context.Instance, stream, renderer);
subscriber.Error += Subscriber_Error;
session.subscribe(subscriber);

private void Session_Error(object sender, Subscriber.ErrorEventArgs e)
{
    Console.WriteLine("Subscriber error:" + e.ErrorCode);
}

L'objet Abonné envoie un Error s'il y a une erreur dans l'abonnement au flux. Vérifier l'événement ErrorCode des arguments transmis à l'événement pour connaître les détails de l'échec de la souscription. (La propriété OpenTok.ErrorCode L'enum définit ErrorCode valeurs.)

L'objet Abonné envoie un Connected lorsque l'application commence à recevoir le flux de l'abonné.

Remarque : La classe OpenTok.Subscriber implémente l'interface System.IDisposable. Veillez à appeler la classe Dispose() de l'objet Subscriber pour libérer ses ressources lorsque vous n'avez plus besoin de l'objet (par exemple, lorsque l'Subscriber arrête la diffusion de vidéos ou lorsque l'application ou la fenêtre se ferme).

Vous pouvez créer un pilote audio personnalisé à utiliser par tous les éditeurs et abonnés.

Se désabonner d'un flux

Pour arrêter la lecture d'un flux auquel vous êtes abonné, appelez la fonction Session.Unsubscribe(subscriber) méthode :

session.unsubscribe(subscriber);

L'abonné est déconnecté et sa vue est supprimée de sa vue secondaire.

Les on_stream_received (voir la section précédente) comprend une fonction de rappel de type stream qui est un pointeur sur un otc_stream représentant le nouveau flux. Pour s'abonner au flux, instanciez une structure otc_subscriber_callbacks définir des fonctions de rappel pour les événements liés à l'abonné, puis appeler l'instance otc_subscriber_new() en passant par la fonction otc_stream et otc_subscriber_callbacks instances

char *user_data = strdup("Session user data");

static void on_subscriber_connected(otc_subscriber *subscriber,
                                    void *user_data,
                                    const otc_stream *stream) {
  // Called when the subscriber connects to the stream.
}

static void on_render_frame(otc_subscriber *subscriber,
                            void *user_data,
                            const otc_video_frame *frame) {
  // Called when the subscriber is ready to render a new video frame
}

static void on_error(otc_subscriber *subscriber,
                      void *user_data) {
  // Called when there is an error.
}

struct otc_subscriber_callbacks subscriber_callbacks = {0};
subscriber_callbacks.user_data = user_data;
subscriber_callbacks.on_connected = on_subscriber_connected;
subscriber_callbacks.on_render_frame = on_subscriber_render_frame;
subscriber_callbacks.on_error = on_subscriber_error;

otc_subscriber *subscriber = otc_subscriber_new(stream,
                                                &subscriber_callbacks);
if (subscriber == NULL) {
  printf("Could not create OpenTok subscriber successfully");
  return;
}

if (otc_session_subscribe(session, subscriber) != OTC_SUCCESS) {
  printf("Could not subscribe successfully.");
}

Utiliser le user_data membre de la otc_subscriber_callbacks pour définir les données que vous souhaitez référencer dans les fonctions de rappel. Dans cet exemple, nous l'avons défini comme un pointeur sur un objet de type chaîne de caractères. Mais il pourrait s'agir d'un pointeur sur une instance d'un autre type contenant des informations significatives.

Les autres membres de la otc_subscriber_callbacks sont des fonctions de rappel qui sont invoquées lorsque des événements liés à l'abonné se produisent :

• on_connected - Appelé lorsque l'abonné se connecte au flux audio-vidéo.
• on_render_frame - Appelé chaque fois que l'abonné est prêt à restituer une nouvelle image vidéo.
• on_error - Appelé lorsqu'une erreur d'abonné se produit.

Tous les rappels ne seront pas effectués sur l'application ou le thread principal, mais sur un thread interne. L'application doit renvoyer le rappel le plus rapidement possible afin d'éviter de bloquer le thread interne.

Voir otc_subscriber_callbacks dans la référence du SDK Linux de Vonage Video pour plus de détails sur chacune des fonctions de rappel.

Se désabonner d'un flux

Pour arrêter la lecture d'un flux auquel vous êtes abonné, appelez la fonction otc_session_unsubscribe() en passant la fonction otc_session et otc_subscriber instances :

if (session.unsubscribe(session, subscriber) ==  OTC_SUCCESS) {
  printf("Unsubscribed from the stream successfully.");
  otc_subscriber_delete(subscriber);
} else {
  printf("Could not unsubscribe successfully.");
};

Appeler le otc_subscriber_delete() pour libérer l'instance d'abonné, y compris toutes les ressources matérielles et d'interface utilisateur qui lui sont liées.