Cómo unirse a una sesión

Crea una instancia del 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);

El OT.initSession() El método devuelve un objeto Session, a través del cual se realizan las llamadas posteriores a la API.

Ten en cuenta que al llamar a la función OT.initSession() El método no crear una sesión; crea un objeto de sesión de JavaScript, que representa una sesión existente. Puedes crear una sesión utilizando el SDK del lado del servidor. Consulta Crear una sesión.

Si el navegador del usuario no es compatible con WebRTC, la llamada a OT.initSession() lo que hace que la página muestre un mensaje al usuario. Para comprobar si se admite WebRTC y evitar que aparezca este mensaje, puedes 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.
}

Crea 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() método del objeto Session.Builder para crear un objeto Session:

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

Ten en cuenta que al llamar a la función Session.Builder.build() El método 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 de escucha 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.

Crea una instancia de 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)

Ten en cuenta que al llamar a la función OTSession init(apiKey: sessionId: delegate:) El método no crear una sesión de Vonage Video; crea el objeto Swift OTSession, que representa una sesión de Vonage Video ya existente. Para crear una sesión de Vonage Video, hay que utilizar las bibliotecas de Vonage Video del lado del servidor.

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

Implementa los métodos de la OTSessionDelegate protocolo en el objeto que especifiques como objeto delegado. Estos métodos se invocan 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];

Ten en cuenta que al llamar a la función [OTSession initWithApiKey:sessionId:delegate:] El método 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.

Crea una instancia del 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);

Ten en cuenta que al llamar a la función Session() El constructor 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;

Te interesará 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úrate de llamar a la 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_callbacks, y punteros a funciones que apuntan a miembros de 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 estructura para establecer los datos a los que quizá quieras hacer referencia en las funciones de llamada de retorno. En este ejemplo, la configuramos como un puntero a un objeto de cadena. Pero podría ser un puntero a una instancia de cualquier otro tipo que contenga información relevante.

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 invoca cuando el otc_session_connect() La función (véase más abajo) 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 activa cuando se interrumpe la transmisión de otro cliente en la sesión de Vonage Video. Esto puede ocurrir cuando el cliente deja de publicar la transmisión o si se interrumpe su conexión a la red.
• on_disconnected -- Se llama cuando la aplicación se desconecta de la sesión de Vonage Video (ver a continuación).
• on_error -- Se invoca cuando se produce un error al conectarse a la sesión. Esta función incluye parámetros para una cadena de error y un código de error definido por el otc_session_error_code enum.

Ninguna de las llamadas de retorno se realizará en el hilo de la aplicación ni en el hilo principal, sino en un hilo interno. La aplicación debe devolver la llamada de retorno lo antes posible para evitar bloquear el 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() función, pasando como parámetros la cadena del ID de tu aplicación, la cadena del ID de sesión de Vonage Video y un puntero a la otc_session_callbacks estructura:

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

El otc_session_new() La función 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 parámetro 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 () función para crear una instancia de un 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 struct en el 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 configurar opciones avanzadas 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 funcionalidad 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.

Puedes 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 El controlador de eventos se activa 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 del connect evento que se produce 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 ha conectado 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 evento cuando se produce un error al conectarse. Sin embargo, resulta más sencillo comprobar si la conexión se ha realizado correctamente pasando un controlador de finalización al connect() método, como último parámetro.

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

mSession.connect(TOKEN);

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

El 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 propiedad 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)")
}

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

El OTSessionDelegate session(_:didFailWithError:) se envía cuando se produce un error al conectarse.

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

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

Puedes consultar el estado de la conexión comprobando el sessionConnectionStatus del objeto OTSession:

session.sessionConnectionStatus

Los valores válidos se definen en Enumeración 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);
}

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

El OTSessionDelegate session:didFailWithError:] se envía cuando se produce un error al conectarse. Consulta la documentación de la OTSessionErrorCode enum para las descripciones de los valores del code propiedad del objeto de error.

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

Puedes consultar el estado de la conexión comprobando el sessionConnectionStatus del objeto OTSession:

session.sessionConnectionStatus

Los valores válidos se definen en Enumeración 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);

El Session.Connected El evento 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);
}

El 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 propiedad del objeto de error.

Llame al otc_session_connect() función:

otc_session_connect(session, TOKEN);

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

• El otc_session instancia de estructura.
• La cadena de token de Vonage Video.

Una vez establecida la conexión, el on_connected función de devolución de llamada de la otc_session_callbacks struct. En caso de error, el on_error función de devolución de llamada de la otc_session_callbacks struct.

El cliente se desconecta de la sesión al desmontar el OTSession componente.

Para desconectarte de una sesión, llama al disconnect() del objeto Session:

session.disconnect();

Para desconectarte de una sesión, llama al Session.disconnect() método.

mSession.disconnect();

Detección de desconexión (Android)

El Session.SessionListener.onDisconnected(Session session) El método se invoca 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 tras una conexión correcta, el Session.SessionListener.onError(Session session, OpentokError error) El método se invoca antes de la Session.SessionListener.onDisconnected(Session session) método. El objeto OpentokError pasado al método Session.SessionListener.onError(Session session, OpentokError error) El método describe el motivo de la desconexión.

Para desconectarte de una sesión, llama al OTSession disconnect(_:) método.

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

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

Detectar cuándo te has desconectado (Swift)

El 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 tras una conexión correcta, el OTSessionDelegate session(_:didFailWithError:) se envía antes del OTSessionDelegate sessionDidDisconnect(_:) mensaje.

El OTSessionErrorCode define los parámetros code propiedad del objeto OTError pasado al OTSessionDelegate session(_:didFailWithError:) y describe el motivo de la desconexión.

Para desconectarte de una sesión, llama al [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)

El [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 tras una conexión correcta, el [OTSessionDelegate session:DidFailWithError:] se envía antes del [OTSessionDelegate sessionDidDisconnect:] mensaje. El enum OTSessionErrorCode define el código code propiedad del objeto OTError pasado al [OTSessionDelegate session:DidFailWithError:] y describe el motivo de la desconexión.

Para desconectarte de una sesión, llama al Session.Disconnect() método:

session.Disconnect();

Detección de desconexión (Windows)

El 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 tras una conexión correcta, el Session.Error El evento se envía antes del Session.Disconnected evento. En ErrorEventArgs objeto pasado a la Session.Error define la razón por la que se ha caído la conexión.

Para desconectarte de una sesión, llama al 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 función de devolución de llamada de la otc_session_callbacks struct.

El OTSession El objeto 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 evento cuando un nuevo cliente (incluido el propio) se conecta a la sesión. El objeto Session envía un connectionDestroyed evento cuando otros clientes abandonan la sesión. Estos eventos están definidos por la clase ConnectionEvent, que tiene un 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) El método se invoca cuando un nuevo cliente (que no sea el tuyo) se conecta a la sesión.

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

El 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).

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

El [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).

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

El Session.ConnectionDropped se envía cuando un cliente (que no sea el suyo) abandona la sesión. La dirección ConnectionEventArgs El objeto pasado al detector 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 función de devolución de llamada de la 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.

El on_connection_dropped función de devolución de llamada de la otc_session_callbacks struct se llama cuando un cliente (que no sea el propio) se desconecta de la sesión. La estructura connection El parámetro de esa función es un puntero a la otc_connection struct correspondiente al cliente que se desconecta de la sesión.

Cuando el cliente se desconecta de una sesión, el OTSession El componente 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);

El reason La propiedad del evento es una cadena de caracteres que describe el motivo por el que se ha desconectado la sesión. Por ejemplo, el ejemplo anterior avisa al usuario de si se ha desconectado debido a que se ha interrumpido la conexión de red.

Para más información, consulta 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 El objeto envía un sessionReconnecting evento. Cuando se restablece la conexión, el Session El objeto 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 sucesos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario que indiquen 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 repositorio 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 sessionDisconnected evento.

En respuesta a estos sucesos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario que indiquen 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 para desarrolladores «Suscribirse 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() Método para evitar que las señales se acumulen en la cola mientras estás desconectado.

Para más información, consulte Evitar que se envíen 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) se llama el método. Cuando se restablece la conexión, el Session.ReconnectionListener.onReconnected(Session session) se llama al método.

Si el cliente no puede restablecer la conexión, 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 sucesos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario que indiquen 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 tu cliente se desconecta temporalmente de una sesión, se invocan los métodos de las implementaciones de la interfaz `SubscriberKit.StreamListener` en los clientes suscritos a un flujo que tú publicas, tanto cuando se interrumpe el flujo publicado como 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 parámetro a false para evitar que las señales se pongan en cola mientras estás desconectado.

Para más información, consulte Evitar que se envíen 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:) Método para evitar que las señales se acumulen en la 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 tu cliente se desconecta temporalmente de una sesión, los objetos `OKSubscriberKitDelegate` de los clientes suscritos a un flujo que tú publicas envían mensajes cuando el flujo publicado se interrumpe y cuando (y si) se reanuda automáticamente. Para obtener más información, consulta 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 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 Evitar que se envíen 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 el evento. Si el cliente no puede restablecer la conexión, se desconecta de la sesión de Vonage Video, y el Session.Disconnected se envía el evento.

En respuesta a estos sucesos, tu aplicación puede (opcionalmente) mostrar notificaciones en la interfaz de usuario que indiquen 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 parámetro a false para evitar que las señales se pongan en cola mientras usted está desconectado. Para más información, consulte Evitar que se envíen 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 función de devolución de llamada de la otc_session_callbacks Se llama a la estructura. Cuando se restablece la conexión, la on_reconnected función de devolución de llamada de la 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 función de devolución de llamada de la 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 función de devolución de llamada de la otc_subscriber_callbacks de un abonado a un flujo publicado por ese cliente. La dirección on_reconnected función de devolución de llamada de la otc_subscriber_callbacks La estructura del suscriptor 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() función o el otc_session_send_signal_to_connection_with_options () función y configura el retryAfterReconnect miembro a false en el otc_signal_options que pasas a la función.

Para más información, consulte Evitar que se envíen señales durante la reconexión automática.