Rejoindre une session

Instanciez un objet Session en appelant la fonction OT.initSession() avec votre identifiant d'application et l'identifiant de session approprié :

// Replace with your application ID and session ID:
var session = OT.initSession(applicationId, sessionId);

Les OT.initSession() renvoie un objet Session, par l'intermédiaire duquel les appels ultérieurs à l'API sont effectués.

Notez que l'appel à la fonction OT.initSession() n'est pas créer une session ; il crée un objet Session JavaScript, qui représente une session existante. Vous pouvez créer une session à l'aide du SDK côté serveur. Voir Création d'une session.

Si le navigateur de l'utilisateur ne prend pas en charge WebRTC, l'appel à OT.initSession() la page affiche un message à l'intention de l'utilisateur. Pour vérifier la prise en charge de WebRTC et empêcher l'affichage de ce message, vous pouvez appeler la fonction OT.checkSystemRequirements() avant d'appeler la méthode OT.initSession():

if (OT.checkSystemRequirements() == 1) {
  var session = OT.initSession(applicationId, sessionId);
} else {
  // The client does not support WebRTC.
  // You can display your own message.
}

Instanciez un objet Session.Builder en appelant la fonction Session.Builder() en lui transmettant le contexte d'application Android approprié, l'ID de votre application Vonage Video et un ID de session. Appelez ensuite le constructeur build() de l'objet Session.Builder pour créer un objet Session :

mSession = new Session.Builder(context, APPLICATION_ID, SESSION_ID)
    .build();

Notez que l'appel à la fonction Session.Builder.build() n'est pas créer une session Vonage Video ; il crée l'objet Java Session, qui représente une session Vonage Video existante. Vous créez une session Vonage Video à l'aide des bibliothèques côté serveur de Vonage Video. Voir Créer une session vidéo Vonage.

Ajoutez un objet d'écoute pour les événements de base liés à la session en appelant la fonction setSessionListener(Session.SessionListener listener) de l'objet Session :

mSession.setSessionListener(this);

Implémentez les méthodes de l'interface Session.SessionListener dans l'objet que vous spécifiez en tant qu'objet d'écoute d'événements. Ces méthodes sont appelées lorsque des événements liés à la session se produisent.

Instanciez un objet OTSession en appelant la fonction OTSession init(apiKey:sessionId:delegate:) avec votre identifiant d'application et l'identifiant de session approprié :

// Replace kApplicationId with your application ID:
// Replace kSessionId with a session ID:
session = OTSession(apiKey: kApplicationId, sessionId: kSessionId, delegate: self)

Notez que l'appel à la fonction OTSession init(apiKey: sessionId: delegate:) n'est pas créer une session Vonage Video ; il crée l'objet Swift OTSession, qui représente une session Vonage Video existante. Vous créez une session Vonage Video à l'aide des bibliothèques côté serveur Vonage Video.

Voir Créer une session vidéo Vonage.

Mettre en œuvre les méthodes du OTSessionDelegate dans l'objet que vous spécifiez en tant qu'objet délégué. Ces méthodes sont appelées lorsque des événements liés à la session se produisent.

Avant de pouvoir vous connecter à une session, instanciez un objet OTSession en appelant la fonction [OTSession initWithApiKey: sessionId: delegate:] avec votre identifiant d'application et l'identifiant de session approprié :

// Replace kApplicationId with your application ID":
// Replace kSessionId with an OpenTok session ID:
session = [[OTSession alloc] initWithApiKey:kApplicationId
                                        sessionId:kSessionId
                                        delegate:self];

Notez que l'appel à la fonction [OTSession initWithApiKey:sessionId:delegate:] n'est pas créer une session Vonage Video ; il crée l'objet Objective-C OTSession, qui représente une session Vonage Video existante. Vous créez une session Vonage Video à l'aide des bibliothèques côté serveur de Vonage Video. Voir Créer une session vidéo Vonage.

Implémentez les méthodes du protocole OTSessionDelegate dans l'objet que vous spécifiez en tant qu'objet délégué. Ces méthodes sont appelées lorsque des événements liés à la session se produisent.

Instanciez un objet Session en appelant la fonction Session() en indiquant le contexte d'application Windows approprié, l'identifiant de votre application et l'identifiant de la session Vonage Video :

session = new Session(Context.Instance, APPLICATION_ID, SESSION_ID);

Notez que l'appel à la fonction Session() n'est pas créer une session Vonage Video ; il crée un objet Session C#, qui représente une session Vonage Video existante. Vous créez une session Vonage Video à l'aide des bibliothèques côté serveur de Vonage Video. Voir Créer une session vidéo Vonage.

Vous voudrez ajouter des gestionnaires pour les événements de base liés à la session :

session.Connected += Session_Connected;
session.Disconnected += Session_Disconnected;
session.Error += Session_Error;
session.ConnectionCreated += Session_ConnectionCreated;
session.StreamReceived += Session_StreamReceived;
session.StreamDropped += Session_StreamDropped;

Vous devrez mettre en œuvre chacune des méthodes de rappel. Par exemple, cette méthode gère ConnectionCreated (qui se produit lorsque le client se connecte à la session Vonage Video) :

private void Session_Connected(object sender, EventArgs e)
{
    Console.WriteLine("Session connected connection id:" + session.Connection.Id);
}

Remarque : La classe Session met en œuvre l'interface System.IDisposable. Veillez à appeler la fonction Dispose() de l'objet Session pour libérer leurs ressources lorsque vous n'avez plus besoin de l'objet (par exemple, lorsque l'application ou la fenêtre se ferme).

Créer une structure de type otc_session_callbackset des pointeurs de fonction vers les membres de la fonction de rappel. Par exemple :

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

static void on_session_connected(otc_session *session, void *user_data) {
    // You could publish a stream once you connect to the session.
}
    
static void on_session_stream_received(otc_session *session,
                                       void *user_data,
                                       const otc_stream *stream) {
    // You could call otc_subscriber_new() to subscribe to this stream
       // in response to this event.
}

static void on_session_stream_dropped(otc_session *session,
                                      void *user_data,
                                      const otc_stream *stream) {
    // If you have subscribed to this stream, you should
    // call otc_subscriber_delete() to delete the subscriber in response to this event.
    }
    
static void on_disconnected(otc_session *session, void *user_data) {
    // Handle the on_disconnected event.
}

static void on_session_error(otc_session *session,
                             void *user_data,
                             const char *error_string,
                             enum otc_session_error_code error) {
    // Handle the error.
}

struct otc_session_callbacks session_callbacks = {0};
session_callbacks.user_data = session_user_data;
session_callbacks.on_connected = on_session_connected;
session_callbacks.on_stream_received = on_session_stream_received;
session_callbacks.on_stream_dropped = on_session_stream_dropped;
session_callbacks.on_disconnected = on_session_disconnected;
session_callbacks.on_error = on_session_error;

Utiliser le user_data membre de la otc_session_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_session_callbacks sont des fonctions de rappel qui sont appelées lorsque des événements liés à la session Vonage Video se produisent. L'exemple précédent comprend des fonctions de rappel pour les éléments suivants :

• on_connected\ -- Appelé lorsque le otc_session_connect() (voir ci-dessous) connecte avec succès l'instance à une session Vonage Video.
• on_stream_received -- Appelé lorsqu'il y a un nouveau flux dans la session Vonage Video (lorsqu'un autre client publie un flux dans la session).
• on_stream_dropped -- Appelé lorsque le flux d'un autre client est supprimé de la session Vonage Video. Cela peut se produire lorsque le client cesse de publier le flux ou lorsque la connexion réseau du client est interrompue.
• on_disconnected -- Appelé lorsque l'application se déconnecte de la session Vonage Video (voir ci-dessous).
• on_error -- Appelée lorsqu'une erreur survient lors de la connexion à la session. Cette fonction inclut des paramètres pour une chaîne d'erreur et un code d'erreur défini par la directive otc_session_error_code enum.

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_session_callbacks dans la référence du SDK Linux de Vonage Video pour plus de détails sur chacune des fonctions de rappel.

Après avoir initialisé le otc_session_callbacks appeler la structure otc_session_new() en lui transmettant la chaîne d'identification de votre application, la chaîne d'identification de la session Vonage Video et un pointeur vers la fonction otc_session_callbacks structure :

otc_session *session = NULL;
session = otc_session_new(APPLICATION_ID, SESSION_ID, &session_callbacks);

Les otc_session_new() La fonction renvoie un otc_session qui représente une session Vonage Video.

Pour utiliser les paramètres avancés de la session, appelez le otc_session_new_with_settings()au lieu de la otc_session_new() fonction. Cette fonction prend un settings qui est un pointeur sur un otc_session_settings qui définit les paramètres avancés. Par exemple, le code suivant utilise la structure otc\_session_settings_new () afin d'instancier un otc_session_settings et appelle otc_session_settings_set_connection_events_suppressed(OTC_TRUE) pour que le SDK supprime les événements de connexion, afin de prendre en charge les sessions vidéo interactives de grande envergure. Il transmet ensuite le otc_session_settings dans la structure otc_session_new_with_settings() fonction :

// Populate the session_callbacks struct, as in the previous example. Then...

otc_session_settings *session_settings = otc_session_settings_new();
otc_session_settings_set_connection_events_suppressed(session_settings, OTC_TRUE);
otc_session *session = otc_session_new_with_settings(APPLICATION_ID,
                                                     SESSION_ID,
                                                     &session_callbacks,
                                                     session_settings);

En plus de otc_session_settings_set_connection_events_suppressed()Les fonctions suivantes permettent de définir des paramètres avancés pour une session :

• otc_session_settings_set_custom_ice_config() - Permet la configuration personnalisée du serveur ICE. Cela fait partie de la configuration du serveur ICE. fonction TURN configurable.
• otc_session_settings_set_ip_whitelist() - Cela permet de soutenir l'initiative fonction d'adresse IP autorisée disponible en tant que fonction complémentaire.
• otc_session_settings_set_proxy_url() - Définit une URL de proxy IP. Voir la page Guide du développeur IP Proxy.

Lorsque vous ajoutez un composant OTSession, il se connecte automatiquement à la session API Video de Vonage.

<OTSession
  applicationId="your-application-ID"
  sessionId="your-session-id"
  token="your-session-token"
>
  <OTPublisher/>
  <OTSubscriber/>
</OTSession>

Remplacer your-application-ID, your-session-idet your-session-token avec votre Clé API, a ID de la sessionet un jeton pour la session.

Notez que vous ajoutez le OTPublisher et OTSubscriber et les enfants du OTSession de la composante.

Vous pouvez passer un error et sessionConnected dans les gestionnaires d'événements de la OTSession composant. Le gestionnaire d'événements d'erreur est appelé si le client ne parvient pas à se connecter à la session. Et le gestionnaire d'événement sessionConnected est appelé lorsque le client se connecte à la session :

<OTSession
  applicationId="your-application-ID"
  sessionId="your-session-id"
  token="your-session-token"
  eventHandlers={{
    error: event => {
        console.log('error', event);
      },
    sessionConnected: event => {
      console.log('session connected', event);
    },
  }}
>
  <OTPublisher style={{ width: 100, height: 100 }}/>
  <OTSubscriber style={{ width: 100, height: 100 }} />
</OTSession>

Appeler le connect() en transmettant un jeton et une fonction de gestion de l'achèvement :

var session = OT.initSession(appID, sessionId);
session.connect(token, function(error) {
  if (error) {
    console.log("Error connecting: ", error.name, error.message);
  } else {
    console.log("Connected to the session.");
  }
});

Un objet d'erreur est transmis au gestionnaire d'achèvement de la fonction connect lorsque le client ne parvient pas à se connecter à la session. Dans le cas contraire, aucun objet d'erreur n'est transmis, ce qui indique que le client s'est connecté avec succès à la session.

L'objet Session envoie également un sessionConnected lorsque le client se connecte à la session. Et l'objet OT envoie un exception en cas d'erreur de connexion. Cependant, il est plus simple de vérifier le succès de la connexion en passant un gestionnaire d'achèvement dans l'événement connect() comme dernier paramètre.

Appeler le Session.connect(token) en transmettant un jeton valide :

mSession.connect(TOKEN);

Les Session.SessionListener.onConnected(Session session) est appelée lorsque le client se connecte à la session Vonage Video.

@Override
protected void onConnected(Session session)
  // This client has connected to the session.
}

Les Session.SessionListener.onError(Session session, OpentokError error) est appelée en cas d'erreur de connexion. Voir la documentation de l'enum OpentokException.ErrorCode pour la description des valeurs de l'enum code de l'objet d'erreur.

@Override
public void onError(Session session, OpentokError error) {
  Log.i(LOGTAG, "Exception: " + error.getMessage());
}

Appeler le OTSession connect(withToken:error:) en transmettant le jeton au client :

var error: OTError?
session.connect(withToken: token, error: &error)

if let error = error {
    print("connect failed with error: \(error)")
}

Les OTSessionDelegate sessionDidConnect(_:) est envoyé lorsque le client se connecte à la session Vonage Video.

Les OTSessionDelegate session(_:didFailWithError:) est envoyé en cas d'erreur de connexion.

Voir la documentation de l'outil OTSessionErrorCode enum pour la description des valeurs du code de l'objet d'erreur.

Surveillance de l'état de la connexion (Swift)

Vous pouvez obtenir l'état de la connexion en vérifiant le fichier sessionConnectionStatus de l'objet OTSession :

session.sessionConnectionStatus

Les valeurs valides sont définies dans le OTSessionConnectionStatus enum.

Vous pouvez utiliser un observateur clé-valeur pour contrôler cette propriété. Cependant, l'observateur OTSessionDelegate sessionDidConnect(_:) et OTSessionDelegate sessionDidDisconnect(_:) sont envoyés au délégué de la session lorsque la session se connecte et se déconnecte.

Appeler le [OTSession connectWithToken:error:] en transmettant le jeton au client :

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

Les [OTSessionDelegate session:didConnect] est envoyé lorsque le client se connecte à la session Vonage Video.

Les OTSessionDelegate session:didFailWithError:] est envoyé en cas d'erreur de connexion. Voir la documentation de l'outil OTSessionErrorCode enum pour la description des valeurs du code de l'objet d'erreur.

Contrôle de l'état de la connexion (Objectif C)

Vous pouvez obtenir l'état de la connexion en vérifiant le fichier sessionConnectionStatus de l'objet OTSession :

session.sessionConnectionStatus

Les valeurs valides sont définies dans le OTSessionConnectionStatus enum.

Vous pouvez utiliser un observateur clé-valeur pour contrôler cette propriété. Cependant, l'observateur [OTSessionDelegate sessionDidConnect:] et [OTSessionDelegate sessionDidDisconnect:] sont envoyés au délégué de la session lorsque la session se connecte et se déconnecte.

Appeler le Session.connect(token) en transmettant un jeton OpenTok valide :

session.Connect(TOKEN);

Les Session.Connected est envoyé lorsque le client se connecte à la session OpenTok.

session.ConnectionCreated += Session_ConnectionCreated;

private void Session_Connected(object sender, EventArgs e)
{
    Console.WriteLine("Session connected connection id:" + session.Connection.Id);
}

Les Session.Error est envoyé en cas d'erreur de connexion :

session.Error += Session_Error;

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

Voir la documentation de l'outil OpenTok.ErrorCode pour la description des valeurs de l'enum code de l'objet d'erreur.

Appeler le otc_session_connect() fonction :

otc_session_connect(session, TOKEN);

Cette fonction connecte le client à la session vidéo Vonage. Elle prend deux arguments :

• Les otc_session exemple de structure.
• La chaîne de jetons Vonage Video.

Une fois la connexion réussie, le on_connected de la fonction de rappel du otc_session_callbacks est appelée. En cas d'erreur, la on_error de la fonction de rappel du otc_session_callbacks struct est appelé.

Le client se déconnecte de la session lorsque vous démontez le fichier OTSession de la composante.

Pour se déconnecter d'une session, appelez le disconnect() de l'objet Session :

session.disconnect();

Pour se déconnecter d'une session, appelez le Session.disconnect() méthode.

mSession.disconnect();

Détection de la déconnexion (Android)

Les Session.SessionListener.onDisconnected(Session session) est appelée lorsque le client se déconnecte de la session.

@Override
public void onDisconnected(session) {
  // This client has disconnected to the session.
}

Si la connexion à la session est interrompue en raison d'une erreur survenant après une connexion réussie, le message Session.SessionListener.onError(Session session, OpentokError error) est appelée avant la méthode Session.SessionListener.onDisconnected(Session session) méthode. L'objet OpentokError transmis à la méthode Session.SessionListener.onError(Session session, OpentokError error) décrit la raison de la déconnexion.

Pour se déconnecter d'une session, appelez le OTSession disconnect(_:) méthode.

var error: OTError?
session.disconnect(&error)

if let error = error {
    print("disconnect failed with error: \(error)")
}

Détection de la déconnexion (Swift)

Les OTSessionDelegate sessionDidDisconnect(_:) est envoyé au délégué de la session lorsque celle-ci se déconnecte.

Notez que les sessions se déconnectent automatiquement lorsque l'application est suspendue.

Si la connexion à la session est interrompue en raison d'une erreur survenant après une connexion réussie, le message OTSessionDelegate session(_:didFailWithError:) est envoyé avant le message OTSessionDelegate sessionDidDisconnect(_:) message.

Les OTSessionErrorCode définit l'enum code de l'objet OTError transmis à la fonction OTSessionDelegate session(_:didFailWithError:) et décrit la raison de la déconnexion.

Pour se déconnecter d'une session, appelez le [OTSession disconnect:] méthode.

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

Détection de la déconnexion (Objectif C)

Les [OTSessionDelegate sessionDidDisconnect:] est envoyé au délégué de la session lorsque celle-ci se déconnecte.

Notez que les sessions se déconnectent automatiquement lorsque l'application est suspendue.

Si la connexion à la session est interrompue en raison d'une erreur survenant après une connexion réussie, le message [OTSessionDelegate session:DidFailWithError:] est envoyé avant le message [OTSessionDelegate sessionDidDisconnect:] message. L'enum OTSessionErrorCode définit le type de message d'erreur. code de l'objet OTError transmis à la fonction [OTSessionDelegate session:DidFailWithError:] et décrit la raison de la déconnexion.

Pour se déconnecter d'une session, appelez le Session.Disconnect() méthode :

session.Disconnect();

Détection de la déconnexion (Windows)

Les Session.Disconnected est envoyé lorsque le client se déconnecte de la session Vonage Video.

private void Session_Disconnected(object sender, EventArgs e)
{
    Console.WriteLine("Session disconnected");
}

Si la connexion à la session est interrompue en raison d'une erreur survenant après une connexion réussie, le message Session.Error est envoyé avant l'événement Session.Disconnected événement. L'événement ErrorEventArgs passé dans l'objet Session.Error définissent la raison pour laquelle la connexion a été interrompue.

Pour se déconnecter d'une session, appelez le otc_session_disconnect() fonction :

otc_session_disconnect(session);

Si vous n'avez pas l'intention de vous reconnecter à la session, vous devez appeler la fonction otc_session_delete() et otc_destroy() fonctions :

otc_session_delete(session);
session = NULL;

otc_destroy();

Détection de la déconnexion (Linux)

Lorsque le client se déconnecte de la session OpenTok, la fonction on_disconnected de la fonction de rappel du otc_session_callbacks struct est appelé.

Les OTSession envoie un connectionCreated lorsqu'un nouveau client (à l'exception du vôtre) se connecte à la session. L'objet OTSession envoie un connectionDestroyed lorsque d'autres clients quittent la session. Ces événements sont définis par la directive ConnectionEvent qui dispose d'une classe connection qui est un objet Connexion pour la connexion (créée ou détruite) liée à l'événement :

let this.connectionCount = 0;
const this.sessionEventHandlers = {
  connectionCreated: function (event) {
    connectionCount++;
    if (event.connection.connectionId != session.connection.connectionId) {
      console.log('Another client connected. ' + connectionCount + ' total.');
    }
  },
  connectionDestroyed: function connectionDestroyedHandler(event) {
    connectionCount--;
    console.log('A client disconnected. ' + connectionCount + ' total.');
  }
  sessionConnected: function (event) {
    // include your own client's connection in the count
    connectionCount++;
  },
};

// reference later in JSX:

<OTSession
  applicationId={this.apiKey}
  sessionId={this.sessionId}
  token={this.token}
  eventHandlers={this.sessionEventHandlers}
>
    {/* ... */}

L'objet Session envoie un connectionCreated lorsqu'un nouveau client (y compris le vôtre) se connecte à la session. L'objet Session envoie un connectionDestroyed lorsque d'autres clients quittent la session. Ces événements sont définis par la classe ConnectionEvent, qui possède une fonction connection qui est un objet Connexion pour la connexion (créée ou détruite) liée à l'événement :

var connectionCount;
session.on({
  connectionCreated: function (event) {
    connectionCount++;
    if (event.connection.connectionId != session.connection.connectionId) {
      console.log('Another client connected. ' + connectionCount + ' total.');
    }
  },
  connectionDestroyed: function connectionDestroyedHandler(event) {
    connectionCount--;
    console.log('A client disconnected. ' + connectionCount + ' total.');
  }
});
session.connect(token, function (error) {
  if (error) {
    console.log("Failed to connect.");
  } else {
    console.log('You have connected to the session.');
  }
});

Lorsque vous êtes connecté à une session, la fenêtre Session.ConnectionListener.onConnectionCreated(Session session, Connection connection) est appelée lorsqu'un nouveau client (autre que le vôtre) se connecte à la session.

Les Session.ConnectionListener.onConnectionDestroyed(Session session, Connection connection) est appelée lorsqu'un client (autre que le vôtre) quitte la session. L'objet Connection passé dans la méthode définit la connexion qui a quitté la session.

Ajoutez un objet d'écoute pour ces événements de connexion en appelant la fonction setConnectionListener(Session.ConnectionListener listener) de l'objet Session :

mSession.setSessionListener(this);


@Override
public void onConnectionCreated(Session session, Connection connection)
{
  // New client connected to the session
}

@Override
public void onConnectionDestroyed(Session session, Connection connection)
{
  // A client disconnected from the session
}

Les OTSessionDelegate session(_: connectionCreated:) est envoyé au délégué de la session lorsqu'un autre client se connecte à la session (et pour chaque client connecté à la session lorsque vous vous connectez).

Les OTSessionDelegate session(_: connectionDestroyed:) est envoyé au délégué de la session lorsqu'un autre client se déconnecte de la session.

Les [OTSessionDelegate session:connectionCreated:] est envoyé au délégué de la session lorsqu'un autre client se connecte à la session (et pour chaque client connecté à la session lorsque vous vous connectez).

Les [OTSessionDelegate session:connectionDestroyed:] est envoyé au délégué de la session lorsqu'un autre client se déconnecte de la session.

Lorsque vous êtes connecté à une session, la fenêtre Session.ConnectionCreated est envoyé lorsqu'un nouveau client (autre que le vôtre) se connecte à la session. L'événement ConnectionEventArgs transmis à l'auditeur d'événements définit la connexion qui a quitté la session :

session.ConnectionCreated += Session_ConnectionCreated;

private void Session_ConnectionCreated(object sender, EventArgs e)
{
    // Another client connected to the session.
}

Les Session.ConnectionDropped est envoyé lorsqu'un client (autre que le vôtre) quitte la session. L'événement ConnectionEventArgs transmis à l'auditeur d'événements définit la connexion qui a quitté la session.

session.ConnectionCreated += Session_ConnectionDropped;

private void Session_ConnectionDropped(object sender, EventArgs e)
{
    // Another client disconnected from the session.
}

Une fois que vous vous êtes connecté à une session, la fenêtre on_connection_created de la fonction de rappel du otc_session_callbacks est appelée lorsqu'un nouveau client (autre que le vôtre) se connecte à la session. La connection de cette fonction est un pointeur sur une instance d'une fonction otc_connection struct correspondant au client qui se connecte à la session.

Les on_connection_dropped de la fonction de rappel du otc_session_callbacks struct est appelé lorsqu'un client (autre que le vôtre) se déconnecte de la session. La connection de cette fonction est un pointeur sur le fichier otc_connection struct correspondant à la déconnexion du client de la session.

Lorsque votre client se déconnecte d'une session, la fonction OTSession envoie un sessionDisconnected événement :

<OTSession
  applicationId="your-api-key"
  sessionId="your-session-id"
  token="your-session-token"
  eventHandlers={{
    sessionDisconnected: event => {
        console.log('disconnected', event);
      },
    connected: event => {
      console.log('subscriber connected', event);
    },
  }}
>
  <OTPublisher style={{ width: 100, height: 100 }}/>
  <OTSubscriber style={{ width: 100, height: 100 }} />
</OTSession>

Lorsque votre client se déconnecte d'une session, l'objet Session envoie un message de type sessionDisconnected événement :

session.on("sessionDisconnected", function (event) {
  // The event is defined by the SessionDisconnectEvent class
  if (event.reason == "networkDisconnected") {
    alert("Your network connection terminated.")
  }
});
session.connect(token);

Les reason de l'événement est une chaîne de caractères qui décrit la raison de la déconnexion de la session. Par exemple, l'exemple précédent notifie l'utilisateur s'il a été déconnecté en raison de la fin de la connexion réseau.

Pour plus de détails, voir SessionDisconnectEvent.

Les clients tenteront de se reconnecter automatiquement à une session qu'ils déconnectent de manière inattendue (par exemple, en raison d'une perte de connectivité réseau). Il n'est pas nécessaire d'ajouter du code pour que les clients se reconnectent automatiquement, à moins que vous ne souhaitiez répondre aux événements envoyés lorsque votre client se déconnecte et se reconnecte.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction OTSession envoie un sessionReconnecting événement. Lorsque la connexion est rétablie, le Session envoie un sessionReconnected. Si le client ne peut pas rétablir la connexion, il se déconnecte de la session et l'objet Session envoie la commande sessionDisconnected.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion :

<OTSession
  applicationId={this.apiKey}
  sessionId={this.sessionId}
  token={this.token}
  eventHandlers={{
    sessionReconnecting: event => {
      // Display a user interface notification.
    },
    sessionReconnected: event => {
      // Adjust user interface.
    },
    sessionDisconnected: event => {
      // Adjust user interface.
    },
  }
>
    {/* ... */}

Lorsque votre client se déconnecte temporairement d'une session, les objets Subscriber des clients souscrivant à un flux que vous publiez envoient des événements lorsque votre flux publié tombe et lorsque (et si) il reprend automatiquement. Pour plus d'informations, voir Reconnexion automatique.

Pour un exemple de code démontrant l'utilisation de ces événements, voir la section opentok-reconnexion sur GitHub.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, l'objet Session envoie un message de type reconnecting . Lorsque la connexion est rétablie, l'objet Session envoie un événement reconnected . Si le client ne peut pas rétablir la connexion, il se déconnecte de la session et l'objet Session envoie l'événement sessionDisconnected événement.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion :

session.on(
  sessionReconnecting: function() {
    // Display a user interface notification.
  },
  sessionReconnected: function() {
    // Adjust user interface.
  },
  sessionDisconnected: function() {
    // Adjust user interface.
  }
);

Lorsque votre client se déconnecte temporairement d'une session, les objets Subscriber des clients souscrivant à un flux que vous publiez envoient des événements lorsque votre flux publié tombe et lorsque (et si) il reprend automatiquement.

Pour plus d'informations, voir Reconnexion automatique dans le guide du développeur "S'abonner à des flux".

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès. Vous pouvez définir l'option retryAfterReconnect à la propriété false dans les options que vous passez dans le Session.signal() pour éviter que des signaux ne soient mis en file d'attente pendant que vous êtes déconnecté.

Pour plus d'informations, voir Empêcher l'envoi de signaux lors d'une reconnexion automatique.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction Session.ReconnectionListener.onReconnecting(Session session) est appelée. Lorsque la connexion est rétablie, la méthode Session.ReconnectionListener.onReconnected(Session session) est appelée.

Si le client ne peut pas rétablir la connexion, il se déconnecte de la session Vonage Video, et le Session.SessionListener.onDisconnected(Session session) est appelée.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion :

// In the implementation of the Session.ReconnectionListener interface
@Override
public void onReconnecting(session) {
  // Display a user interface notification.
}

public void onReconnected(session) {
  // Adjust user interface.
}

// In the implementation of the Session.SessionListener interface
@Override
public void onDisconnected(session) {
  // Adjust user interface.
}

Lorsque votre client se déconnecte temporairement d'une session, les méthodes des implémentations de l'interface SubscriberKit.StreamListener des clients souscrivant à un flux que vous publiez sont appelées lorsque votre flux publié tombe et lorsque (et si) il reprend automatiquement.

Pour plus d'informations, voir le Détection du moment où les flux quittent une session et reconnexion dans l'étape S'abonner aux flux tutoriel.

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès. Vous pouvez utiliser la fonction Session.sendSignal(String type, String data, Connection connection, boolean retryAfterReconnect) et définir la méthode retryAfterReconnect au paramètre false pour éviter que des signaux soient mis en file d'attente pendant que vous êtes déconnecté.

Pour plus d'informations, voir Empêcher l'envoi de signaux lors d'une reconnexion automatique.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction OTSessionDelegate sessionDidBeginReconnecting(_:) est envoyé au délégué de l'objet OTSession. Lorsque la connexion est rétablie, le message OTSessionDelegate sessionDidReconnect(_:) est envoyé. Si le client ne peut pas rétablir la connexion, le message OTSessionDelegate sessionDidDisconnect(_:) est envoyé.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion.

// OTSession delegate callbacks:
func sessionDidBeginReconnecting(_ session:OTSession) {
    // Display a user interface notification.
}

func sessionDidReconnect(_ session: OTSession) {
    // Adjust user interface.
}

func sessionDidDisconnect(_ session: OTSession) {
    // Adjust user interface.
}

Lorsque votre client se déconnecte temporairement d'une session, les objets OKSubscriberKitDelegate des clients abonnés à un flux que vous publiez envoient des messages lorsque votre flux publié tombe et lorsque (et si) il reprend automatiquement.

Pour plus d'informations, voir le Détection du moment où les flux quittent une session et reconnexion dans l'étape S'abonner aux flux tutoriel.

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès. Vous pouvez utiliser la fonction OTSession signal(withType: string:connection:retryAfterReconnect:error:) pour éviter que des signaux ne soient mis en file d'attente pendant que vous êtes déconnecté.

Pour plus d'informations, voir Tutoriel sur la signalisation.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction [OTSessionDelegate sessionDidBeginReconnecting:] est envoyé au délégué de l'objet OTSession. Lorsque la connexion est rétablie, le message [OTSessionDelegate sessionDidReconnect:] est envoyé. Si le client ne peut pas rétablir la connexion, le message [OTSessionDelegate sessionDidDisconnect:] est envoyé.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion.

// OTSession delegate callbacks:
- (void)sessionDidBeginReconnecting:(OTSession*)session
{
  // Display a user interface notification.
}

- (void)sessionDidReconnect:(OTSession*)session
{
  // Adjust user interface.
}

- (void)sessionDidDisconnect:(OTSession*)session
{
  // Adjust user interface.
}

Lorsque votre client se déconnecte temporairement d'une session, les objets OKSubscriberKitDelegate des clients abonnés à un flux que vous publiez envoient des messages lorsque votre flux publié tombe et lorsque (et si) il reprend automatiquement. Pour plus d'informations, voir les objets Détection du moment où les flux quittent une session et reconnexion dans l'étape S'abonner aux flux tutoriel.

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès. Vous pouvez utiliser la fonction [OTSession signalWithType:string:connection:retryAfterReconnect:error:] pour éviter que des signaux ne soient mis en file d'attente pendant que vous êtes déconnecté. Pour plus d'informations, voir Empêcher l'envoi de signaux lors d'une reconnexion automatique.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction Session.ReconnectionStart est envoyé. Lorsque la connexion est rétablie, l'événement Session.ReconnectionSuccess est envoyé. Si le client ne peut pas rétablir la connexion, il se déconnecte de la session Vonage Video et l'événement Session.Disconnected est envoyé.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion :

session.ReconnectionStart = Session_ReconnectionStart;
session.ReconnectionSuccess = Session_ReconnectionSuccess;
session.Disconnected = Session_Disconnected;

private void Session_ReconnectionStart(object sender, EventArgs e)
{
    // Display a user interface notification.
}

private void Session_ReconnectionSuccess(object sender, EventArgs e)
{
    // Adjust user interface.
}


private void Session_Disconnected(object sender, EventArgs e)
{
    // Adjust user interface.
}

Lorsque votre client se déconnecte temporairement d'une session, les objets Subscriber des clients souscrivant au flux envoient des Subscriber.StreamDisconnected et Subscriber.StreamDisconnected lorsque votre flux publié tombe et quand (et si) il reprend automatiquement. Pour plus d'informations, voir la page Détection du moment où les flux quittent une session et reconnexion dans l'étape S'abonner aux flux tutoriel.

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès. Vous pouvez utiliser la fonction Session.SendSignal(type, signal, connection, retryAfterReconnect) et définir la méthode retryAfterReconnect au paramètre false pour éviter que des signaux soient mis en file d'attente pendant que vous êtes déconnecté. Pour plus d'informations, voir Empêcher l'envoi de signaux lors d'une reconnexion automatique.

Lorsque la connexion est interrompue et que le client tente de se reconnecter, la fonction on_reconnection_started de la fonction de rappel du otc_session_callbacks est appelée. Lorsque la connexion est rétablie, la structure on_reconnected de la fonction de rappel du otc_session_callbacks struct est appelé.

Si le client ne peut pas rétablir la connexion, il se déconnecte de la session OpenTok et l'option on_disconnected de la fonction de rappel du otc_session_callbacks struct est appelé.

En réponse à ces événements, votre application peut (éventuellement) afficher des notifications d'interface utilisateur indiquant les états de déconnexion temporaire, de reconnexion et de déconnexion.

Lorsqu'un autre client se déconnecte temporairement d'une session, le on_disconnected de la fonction de rappel du otc_subscriber_callbacks pour un abonné à un flux publié par ce client est appelé. La structure on_reconnected de la fonction de rappel du otc_subscriber_callbacks struct pour l'abonné est invoqué lorsque (et si) le client se reconnecte et que le flux reprend automatiquement.

Pour plus d'informations, voir le Détection du moment où les flux quittent une session et reconnexion dans l'étape S'abonner aux flux tutoriel.

Par défaut, tous les signaux que vous envoyez lorsque votre client est temporairement déconnecté d'une session sont mis en file d'attente et envoyés lorsque (et si) vous vous reconnectez avec succès.

Pour éviter que des signaux soient mis en file d'attente pendant que vous êtes déconnecté, vous pouvez utiliser l'option otc_session_send_signal_with_options() ou la fonction otc_session_send_signal_to_connection_with_options () et définir la fonction retryAfterReconnect au membre false dans le otc_signal_options que vous transmettez à la fonction.

Pour plus d'informations, voir Empêcher l'envoi de signaux lors d'une reconnexion automatique.