Unirse a una sesión

Instancie un objeto Session llamando a la función OT.initSession() con su ID de aplicación y el ID de sesión correspondiente:

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

En OT.initSession() devuelve un objeto Session, a través del cual se realizan las siguientes llamadas a la API.

Tenga en cuenta que llamar a la función OT.initSession() no crear una sesión; crea un objeto JavaScript Session, que representa una sesión existente. Puede crear una sesión utilizando el SDK del lado del servidor. Véase Crear una sesión.

Si el navegador del usuario no es compatible con WebRTC, la llamada a OT.initSession() hace que la página muestre un mensaje al usuario. Para comprobar la compatibilidad con WebRTC y evitar que se muestre este mensaje, puede llamar a la función OT.checkSystemRequirements() antes de llamar al método 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.
}

Instanciar un objeto Session.Builder llamando a la función Session.Builder() pasando el contexto apropiado de la aplicación de Android, el ID de tu aplicación de Vonage Video y un ID de sesión. Luego llama al constructor build() del objeto Session.Builder para crear un objeto Session:

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

Tenga en cuenta que llamar a la función Session.Builder.build() no crear una sesión de Vonage Video; crea el objeto Java Session, que representa una sesión existente de Vonage Video. Puedes crear una sesión de Vonage Video utilizando las bibliotecas del lado del servidor de Vonage Video. Consulta Cómo crear una sesión de Vonage Video.

Añade un objeto listener para los eventos básicos relacionados con la sesión llamando a la función setSessionListener(Session.SessionListener listener) del objeto Session:

mSession.setSessionListener(this);

Implementa los métodos de la interfaz Session.SessionListener en el objeto que especifiques como objeto receptor de eventos. Estos métodos son llamados cuando se producen eventos relacionados con la sesión.

Instanciar un objeto OTSession llamando a la función OTSession init(apiKey:sessionId:delegate:) con su ID de aplicación y el ID de sesión correspondiente:

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

Tenga en cuenta que llamar a la función OTSession init(apiKey: sessionId: delegate:) no crear una sesión de Vonage Video; crea el objeto Swift OTSession, que representa una sesión de Vonage Video existente. Puedes crear una sesión de Vonage Video utilizando las bibliotecas del lado del servidor de Vonage Video.

Véase Cómo crear una sesión de Vonage Video.

Aplicar los métodos del OTSessionDelegate en el objeto que especifiques como objeto delegado. Estos métodos se llaman cuando se producen eventos relacionados con la sesión.

Antes de conectarse a una sesión, instancie un objeto OTSession llamando a la función [OTSession initWithApiKey: sessionId: delegate:] con su ID de aplicación y el ID de sesión correspondiente:

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

Tenga en cuenta que llamar a la función [OTSession initWithApiKey:sessionId:delegate:] no crear una sesión de Vonage Video; crea el objeto Objective-C OTSession, que representa una sesión de Vonage Video existente. Puedes crear una sesión de Vonage Video utilizando las bibliotecas del lado del servidor de Vonage Video. Consulta Cómo crear una sesión de Vonage Video.

Implementa los métodos del protocolo OTSessionDelegate en el objeto que especifiques como objeto delegado. Estos métodos se llaman cuando se producen eventos relacionados con la sesión.

Instancie un objeto Session llamando a la función Session() pasando el contexto apropiado de la aplicación de Windows, el ID de tu aplicación y un ID de sesión de Vonage Video:

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

Tenga en cuenta que llamar a la función Session() no crear una sesión de Vonage Video; crea un objeto Session de C#, que representa una sesión de Vonage Video existente. Puedes crear una sesión de Vonage Video utilizando las bibliotecas del lado del servidor de Vonage Video. Consulta Cómo crear una sesión de Vonage Video.

Querrás añadir manejadores para los eventos básicos relacionados con la sesión:

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

Usted querrá implementar cada uno de los métodos de devolución de llamada. Por ejemplo, este método gestiona ConnectionCreated (que ocurre cuando el cliente se conecta a la sesión de Vonage Video):

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

Nota: La clase Session implementa la interfaz System.IDisposable. Asegúrese de llamar a la clase Dispose() del objeto Session para liberar sus recursos cuando ya no necesites el objeto (por ejemplo, cuando se cierra la aplicación o la ventana).

Crear una estructura de tipo otc_session_callbacksy punteros de función a los miembros de la función de devolución de llamada. Por ejemplo:

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;

Utiliza el user_data miembro de la otc_session_callbacks para establecer los datos a los que quieras hacer referencia en las funciones callback. En este ejemplo, lo establecemos como un puntero a un objeto string. Pero podría ser un puntero a una instancia de algún otro tipo que contenga información significativa.

Los demás miembros de la otc_session_callbacks son funciones de devolución de llamada que se llaman cuando ocurren eventos relacionados con la sesión de Vonage Video. El ejemplo anterior incluye llamadas de retorno para lo siguiente:

• on_connected\ -- Se llama cuando el otc_session_connect() (ver a continuación) conecta correctamente la instancia a una sesión de Vonage Video.
• on_stream_received -- Se llama cuando hay una nueva transmisión en la sesión de Vonage Video (cuando otro cliente publica una transmisión en la sesión).
• on_stream_dropped -- Se llama cuando el flujo de otro cliente se cae de la sesión de Vonage Video. Esto puede suceder cuando el cliente deja de publicar la transmisión o si se cae la conexión de red del cliente.
• on_disconnected -- Se llama cuando la aplicación se desconecta de la sesión de Vonage Video (ver a continuación).
• on_error -- Llamada cuando se produce un error en la conexión a la sesión. Esta función incluye parámetros para una cadena de error y un código de error que se define mediante el parámetro otc_session_error_code enum.

Todas las devoluciones de llamada no se realizarán en la aplicación ni en el hilo principal, sino en un hilo interno. La aplicación debe devolver la devolución de llamada lo antes posible para evitar el bloqueo del hilo interno.

Véase otc_session_callbacks en la referencia del SDK de Vonage Video para Linux para obtener detalles sobre cada una de las funciones de devolución de llamada.

Tras inicializar el otc_session_callbacks llame a la estructura otc_session_new() pasando la cadena de ID de la aplicación, la cadena de ID de la sesión de Vonage Video y un puntero al archivo otc_session_callbacks estructura:

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

En otc_session_new() devuelve un otc_session que representa una sesión de Vonage Video.

Para utilizar la configuración avanzada de la sesión, llame al otc_session_new_with_settings()en lugar del otc_session_new() función. Esta función toma un settings que es un puntero a un otc_session_settings que define la configuración avanzada. Por ejemplo, el siguiente código utiliza la estructura otc\_session_settings_new () para crear una instancia de otc_session_settings struct y llama a otc_session_settings_set_connection_events_suppressed(OTC_TRUE) para que el SDK suprima los eventos de conexión, para soportar grandes sesiones de vídeo interactivo. A continuación, pasa el otc_session_settings en la estructura otc_session_new_with_settings() función:

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

Además de otc_session_settings_set_connection_events_suppressed()las siguientes funciones te permiten establecer ajustes avanzados para una sesión:

• otc_session_settings_set_custom_ice_config() - Permite la configuración personalizada del servidor ICE. Esto forma parte del función TURN configurable.
• otc_session_settings_set_ip_whitelist() - Esto apoya la función de dirección IP permitida disponible como función adicional.
• otc_session_settings_set_proxy_url() - Establece una URL de proxy IP. Consulte la sección Guía del desarrollador del proxy IP.

Cuando agregas un componente OTSession, éste se conecta automáticamente a la sesión de la Video API de Vonage.

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

Sustituir your-application-ID, your-session-idy your-session-token con su Clave API, a ID de sesióny un ficha para la sesión.

Tenga en cuenta que se añade el OTPublisher y OTSubscriber componentes e hijos del OTSession componente.

Puede pasar un error y sessionConnected controladores de eventos en el OTSession componente. El manejador de eventos de error es llamado si el cliente falla al conectarse a la sesión. Y el sessionConnected cuando el cliente se conecta a la sesión:

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

Llame al connect() pasando un token y una función de finalización:

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

Se pasa un objeto de error al controlador de finalización de la acción connect cuando el cliente no consigue conectarse a la sesión. En caso contrario, no se pasa ningún objeto de error, lo que indica que el cliente se conectó correctamente a la sesión.

El objeto Session también envía un comando sessionConnected cuando el cliente se conecta a la sesión. Y el objeto OT envía un exception cuando se produce un error en la conexión. Sin embargo, es más sencillo comprobar el éxito de la conexión pasando un controlador de finalización al evento connect() como último parámetro.

Llame al Session.connect(token) pasando un token válido:

mSession.connect(TOKEN);

En Session.SessionListener.onConnected(Session session) cuando el cliente se conecta a la sesión de Vonage Video.

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

En Session.SessionListener.onError(Session session, OpentokError error) cuando se produce un error en la conexión. Consulte la documentación de la enum OpentokException.ErrorCode para ver las descripciones de los valores del método code del objeto de error.

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

Llame al OTSession connect(withToken:error:) pasando el token del cliente:

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

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

En OTSessionDelegate sessionDidConnect(_:) se envía cuando el cliente se conecta a la sesión de Vonage Video.

En OTSessionDelegate session(_:didFailWithError:) se envía cuando se produce un error en la conexión.

Consulte la documentación de OTSessionErrorCode enum para las descripciones de los valores del code del objeto de error.

Supervisión del estado de la conexión (Swift)

Puede obtener el estado de la conexión comprobando el sessionConnectionStatus del objeto OTSession:

session.sessionConnectionStatus

Los valores válidos se definen en Enum OTSessionConnectionStatus.

Puede utilizar un observador clave-valor para controlar esta propiedad. Sin embargo, la propiedad OTSessionDelegate sessionDidConnect(_:) y OTSessionDelegate sessionDidDisconnect(_:) se envían al delegado de la sesión cuando ésta se conecta y desconecta.

Llame al [OTSession connectWithToken:error:] pasando el token del cliente:

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

En [OTSessionDelegate session:didConnect] se envía cuando el cliente se conecta a la sesión de Vonage Video.

En OTSessionDelegate session:didFailWithError:] se envía cuando se produce un error en la conexión. Consulte la documentación de OTSessionErrorCode enum para las descripciones de los valores del code del objeto de error.

Supervisión del estado de la conexión (Objetivo C)

Puede obtener el estado de la conexión comprobando el sessionConnectionStatus del objeto OTSession:

session.sessionConnectionStatus

Los valores válidos se definen en Enum OTSessionConnectionStatus.

Puede utilizar un observador clave-valor para controlar esta propiedad. Sin embargo, la propiedad [OTSessionDelegate sessionDidConnect:] y [OTSessionDelegate sessionDidDisconnect:] se envían al delegado de la sesión cuando ésta se conecta y desconecta.

Llame al Session.connect(token) pasando un token OpenTok válido:

session.Connect(TOKEN);

En Session.Connected se envía cuando el cliente se conecta a la sesión de OpenTok.

session.ConnectionCreated += Session_ConnectionCreated;

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

En Session.Error se envía cuando se produce un error en la conexión:

session.Error += Session_Error;

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

Consulte la documentación de OpenTok.ErrorCode para las descripciones de los valores de code del objeto de error.

Llame al otc_session_connect() función:

otc_session_connect(session, TOKEN);

Esta función conecta el cliente a la sesión de Vonage Video. Toma dos argumentos:

• En otc_session ejemplo de estructura.
• La cadena de token de Vonage Video.

Tras conectarse correctamente, el on_connected de la función otc_session_callbacks struct. En caso de error, el on_error de la función otc_session_callbacks struct.

El cliente se desconecta de la sesión cuando desmontas el OTSession componente.

Para desconectarse de una sesión, llame al botón disconnect() del objeto Session:

session.disconnect();

Para desconectarse de una sesión, llame al botón Session.disconnect() método.

mSession.disconnect();

Detección de desconexión (Android)

En Session.SessionListener.onDisconnected(Session session) cuando el cliente se desconecta de la sesión.

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

Si la conexión a la sesión se interrumpe debido a un error que se produce después de una conexión correcta, el icono Session.SessionListener.onError(Session session, OpentokError error) se llama antes del método Session.SessionListener.onDisconnected(Session session) método. El objeto OpentokError pasado al método Session.SessionListener.onError(Session session, OpentokError error) describe el motivo de la desconexión.

Para desconectarse de una sesión, llame al botón OTSession disconnect(_:) método.

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

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

Detección de desconexión (Swift)

En OTSessionDelegate sessionDidDisconnect(_:) al delegado de la sesión cuando ésta se desconecta.

Ten en cuenta que las sesiones se desconectan automáticamente cuando se suspende la aplicación.

Si la conexión a la sesión se interrumpe debido a un error que se produce después de una conexión correcta, el icono OTSessionDelegate session(_:didFailWithError:) se envía antes del OTSessionDelegate sessionDidDisconnect(_:) mensaje.

En OTSessionErrorCode define los parámetros code del objeto OTError introducido en el campo OTSessionDelegate session(_:didFailWithError:) y describe el motivo de la desconexión.

Para desconectarse de una sesión, llame al botón [OTSession disconnect:] método.

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

Detección de desconexión (Objective C)

En [OTSessionDelegate sessionDidDisconnect:] al delegado de la sesión cuando ésta se desconecta.

Ten en cuenta que las sesiones se desconectan automáticamente cuando se suspende la aplicación.

Si la conexión a la sesión se interrumpe debido a un error que se produce después de una conexión correcta, el icono [OTSessionDelegate session:DidFailWithError:] se envía antes del [OTSessionDelegate sessionDidDisconnect:] mensaje. El enum OTSessionErrorCode define el código code del objeto OTError introducido en el campo [OTSessionDelegate session:DidFailWithError:] y describe el motivo de la desconexión.

Para desconectarse de una sesión, llame al botón Session.Disconnect() método:

session.Disconnect();

Detección de desconexión (Windows)

En Session.Disconnected se envía cuando el cliente se desconecta de la sesión de Vonage Video.

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

Si la conexión a la sesión se interrumpe debido a un error que se produce después de una conexión correcta, el icono Session.Error se envía antes del evento Session.Disconnected evento. En ErrorEventArgs que se pasa al objeto Session.Error define la razón por la que se ha caído la conexión.

Para desconectarse de una sesión, llame al botón otc_session_disconnect() función:

otc_session_disconnect(session);

Si no va a volver a conectarse a la sesión, debe llamar a la función otc_session_delete() y otc_destroy() funciones:

otc_session_delete(session);
session = NULL;

otc_destroy();

Detección de desconexión (Linux)

Cuando el cliente se desconecta de la sesión OpenTok, el on_disconnected de la función otc_session_callbacks struct.

En OTSession envía un connectionCreated cuando un nuevo cliente (excluido el suyo) se conecta a la sesión. El objeto OTSession envía un evento connectionDestroyed cuando otros clientes abandonan la sesión. Estos eventos están definidos por la directiva ConnectionEvent que tiene una clase connection que es un objeto Connection para la conexión (creada o destruida) relacionada con el evento:

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}
>
    {/* ... */}

El objeto Session envía un connectionCreated cuando un nuevo cliente (incluido el suyo) se conecta a la sesión. El objeto Session envía un evento connectionDestroyed cuando otros clientes abandonan la sesión. Estos eventos están definidos por la clase ConnectionEvent, que tiene una función connection que es un objeto Connection para la conexión (creada o destruida) relacionada con el evento:

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

Cuando esté conectado a una sesión, el Session.ConnectionListener.onConnectionCreated(Session session, Connection connection) es llamado cuando un nuevo cliente (que no sea el suyo) se conecta a la sesión.

En Session.ConnectionListener.onConnectionDestroyed(Session session, Connection connection) es llamado cuando un cliente (que no sea el suyo) abandona la sesión. El objeto Connection pasado al método define el sombrero de conexión que ha abandonado la sesión.

Añada un objeto receptor para estos eventos de conexión llamando a la función setConnectionListener(Session.ConnectionListener listener) del objeto 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
}

En OTSessionDelegate session(_: connectionCreated:) se envía al delegado de la sesión cuando otro cliente se conecta a la sesión (y para cada cliente conectado a la sesión cuando usted se conecta).

En OTSessionDelegate session(_: connectionDestroyed:) al delegado de sesión cuando otro cliente se desconecta de la sesión.

En [OTSessionDelegate session:connectionCreated:] se envía al delegado de la sesión cuando otro cliente se conecta a la sesión (y para cada cliente conectado a la sesión cuando usted se conecta).

En [OTSessionDelegate session:connectionDestroyed:] al delegado de sesión cuando otro cliente se desconecta de la sesión.

Cuando esté conectado a una sesión, el Session.ConnectionCreated se envía cuando un nuevo cliente (distinto del suyo) se conecta a la sesión. La dirección ConnectionEventArgs que se pasa al receptor de eventos define el sombrero de conexión que ha abandonado la sesión:

session.ConnectionCreated += Session_ConnectionCreated;

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

En Session.ConnectionDropped se envía cuando un cliente (que no sea el suyo) abandona la sesión. La dirección ConnectionEventArgs pasado al receptor de eventos define la conexión que ha abandonado la sesión.

session.ConnectionCreated += Session_ConnectionDropped;

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

Una vez que se haya conectado a una sesión, el on_connection_created de la función otc_session_callbacks se llama cuando un nuevo cliente (que no sea el suyo) se conecta a la sesión. La estructura connection de esa función es un puntero a una instancia de una función otc_connection struct correspondiente al cliente que se conecta a la sesión.

En on_connection_dropped de la función otc_session_callbacks struct se llama cuando un cliente (que no sea el propio) se desconecta de la sesión. La estructura connection de esa función es un puntero al archivo otc_connection struct correspondiente al cliente que se desconecta de la sesión.

Cuando el cliente se desconecta de una sesión, el OTSession envía un sessionDisconnected evento:

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

Cuando el cliente se desconecta de una sesión, el objeto Session envía un comando sessionDisconnected evento:

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

En reason del evento es una cadena que describe por qué se desconectó la sesión. Por ejemplo, el ejemplo anterior notifica al usuario si se desconectó debido a que la conexión de red terminó.

Para más información, consulte SessionDisconnectEvent.

Los clientes intentarán reconectarse automáticamente a una sesión que desconecten inesperadamente (por ejemplo, debido a una caída en la conectividad de la red). No es necesario añadir ningún código para que los clientes se vuelvan a conectar automáticamente, a menos que desee responder a los eventos enviados cuando su cliente se desconecta y se vuelve a conectar.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función OTSession envía un sessionReconnecting evento. Cuando se restablece la conexión, el Session envía un sessionReconnected. Si el cliente no puede restablecer la conexión, se desconecta de la sesión y el objeto Session envía el comando sessionDisconnected.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión:

<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.
    },
  }
>
    {/* ... */}

Cuando su cliente se desconecta temporalmente de una sesión, los objetos Subscriber de los clientes suscritos a un flujo que usted publica envían eventos cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente. Para más información, consulte Reconexión automática.

Para ver ejemplos de código que demuestran el uso de estos eventos, consulte la sección opentok-reconnection en GitHub.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, el objeto Session envía un comando reconnecting evento. Cuando se restablece la conexión, el objeto Session envía un evento reconnected evento. Si el cliente no puede restablecer la conexión, se desconecta de la sesión y el objeto Session envía el evento sessionDisconnected evento.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión:

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

Cuando su cliente se desconecta temporalmente de una sesión, los objetos Subscriber en los clientes suscritos a un flujo que usted publica envían eventos cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente.

Para más información, consulte Reconexión automática en la guía del desarrollador "Suscripción a flujos".

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito. Puede configurar la opción retryAfterReconnect propiedad a false en las opciones que introduzca en el campo Session.signal() para evitar que las señales se pongan en cola mientras estás desconectado.

Para más información, consulte Impedir el envío de señales durante la reconexión automática.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función Session.ReconnectionListener.onReconnecting(Session session) . Cuando se restablece la conexión, el método Session.ReconnectionListener.onReconnected(Session session) se llama al método.

Si el cliente no puede restablecer la conexión, el cliente se desconecta de la sesión de Vonage Video y el Session.SessionListener.onDisconnected(Session session) se llama al método.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión:

// 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.
}

Cuando su cliente se desconecta temporalmente de una sesión, los métodos de las implementaciones de la interfaz SubscriberKit.StreamListener en clientes suscritos a un flujo que usted publica son llamados cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente.

Para más información, consulte el Detección de cuándo los flujos abandonan una sesión y reconexión paso en el Suscribirse a los flujos tutorial.

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito. Puede utilizar la función Session.sendSignal(String type, String data, Connection connection, boolean retryAfterReconnect) y establecer el método retryAfterReconnect a false para evitar que las señales se pongan en cola mientras estás desconectado.

Para más información, consulte Impedir el envío de señales durante la reconexión automática.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función OTSessionDelegate sessionDidBeginReconnecting(_:) al delegado del objeto OTSession. Cuando se restablece la conexión, el OTSessionDelegate sessionDidReconnect(_:) se envía el mensaje. Si el cliente no puede restablecer la conexión, el OTSessionDelegate sessionDidDisconnect(_:) se envía el mensaje.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión.

// 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.
}

Cuando su cliente se desconecta temporalmente de una sesión, los objetos OKSubscriberKitDelegate en clientes suscritos a un flujo que usted publica envían mensajes cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente.

Para más información, consulte el Detección de cuándo los flujos abandonan una sesión y reconexión paso en el Suscribirse a los flujos tutorial.

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito. Puede utilizar la función OTSession signal(withType: string:connection:retryAfterReconnect:error:) para evitar que las señales se pongan en cola mientras estás desconectado.

Para más información, consulte Tutorial de señalización.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función [OTSessionDelegate sessionDidBeginReconnecting:] al delegado del objeto OTSession. Cuando se restablece la conexión, el [OTSessionDelegate sessionDidReconnect:] se envía el mensaje. Si el cliente no puede restablecer la conexión, el [OTSessionDelegate sessionDidDisconnect:] se envía el mensaje.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión.

// 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.
}

Cuando su cliente se desconecta temporalmente de una sesión, los objetos OKSubscriberKitDelegate en clientes suscritos a un flujo que usted publica envían mensajes cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente. Para más información, consulte la sección Detección de cuándo los flujos abandonan una sesión y reconexión paso en el Suscribirse a los flujos tutorial.

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito. Puede utilizar la función [OTSession signalWithType:string:connection:retryAfterReconnect:error:] para evitar que las señales se pongan en cola mientras usted está desconectado. Para obtener más información, consulte Impedir el envío de señales durante la reconexión automática.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función Session.ReconnectionStart se envía el evento. Cuando se restablece la conexión, el Session.ReconnectionSuccess se envía. Si el cliente no puede restablecer la conexión, el cliente se desconecta de la sesión de Vonage Video, y el Session.Disconnected se envía el evento.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión:

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.
}

Cuando el cliente se desconecta temporalmente de una sesión, los objetos Subscriber de los clientes suscritos al flujo envían Subscriber.StreamDisconnected y Subscriber.StreamDisconnected cuando su flujo publicado cae y cuando (y si) se reanuda automáticamente. Para más información, consulte la sección Detección de cuándo los flujos abandonan una sesión y reconexión paso en el Suscribirse a los flujos tutorial.

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito. Puede utilizar la función Session.SendSignal(type, signal, connection, retryAfterReconnect) y establecer el método retryAfterReconnect a false para evitar que las señales se pongan en cola mientras usted está desconectado. Para más información, consulte Impedir el envío de señales durante la reconexión automática.

Cuando se interrumpe la conexión y el cliente intenta volver a conectarse, la función on_reconnection_started de la función otc_session_callbacks struct. Cuando se restablece la conexión, la estructura on_reconnected de la función otc_session_callbacks struct.

Si el cliente no puede restablecer la conexión, el cliente se desconecta de la sesión de OpenTok, y el on_disconnected de la función otc_session_callbacks struct.

En respuesta a estos eventos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario indicando los estados de desconexión temporal, reconexión y desconexión.

Cuando otro cliente se desconecta temporalmente de una sesión, el on_disconnected de la función otc_subscriber_callbacks de un abonado a un flujo publicado por ese cliente. La dirección on_reconnected de la función otc_subscriber_callbacks para el abonado se invoca cuando (y si) el cliente se vuelve a conectar y el flujo se reanuda automáticamente.

Para más información, consulte el Detección de cuándo los flujos abandonan una sesión y reconexión paso en el Suscribirse a los flujos tutorial.

Por defecto, cualquier señal que envíe mientras su cliente está temporalmente desconectado de una sesión se pone en cola y se envía cuando (y si) se reconecta con éxito.

Para evitar que las señales se pongan en cola mientras está desconectado, puede utilizar la opción otc_session_send_signal_with_options() o la función otc_session_send_signal_to_connection_with_options () y establezca el valor retryAfterReconnect miembro a false en el otc_signal_options que pasas a la función.

Para más información, consulte Impedir el envío de señales durante la reconexión automática.