Participar de uma sessão

Instancie um objeto Session chamando o método OT.initSession() método com o ID do seu aplicativo e o ID da sessão correspondente:

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

O OT.initSession() O método retorna um objeto Session, por meio do qual são realizadas as chamadas subsequentes à API.

Observe que chamar o OT.initSession() o método não criar uma sessão; ele cria um objeto Session do JavaScript, que representa uma sessão existente. É possível criar uma sessão usando o SDK do lado do servidor. Consulte Criação de uma sessão.

Se o navegador do usuário não for compatível com WebRTC, a chamada para OT.initSession() faz com que a página exiba uma mensagem para o usuário. Para verificar se há suporte ao WebRTC e evitar que essa mensagem seja exibida, você pode chamar o OT.checkSystemRequirements() método antes de chamar 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.
}

Instancie um objeto Session.Builder chamando o método Session.Builder() construtor, passando o contexto apropriado do aplicativo Android, o ID do seu aplicativo Vonage Video e um ID de sessão. Em seguida, chame o build() método do objeto Session.Builder para criar um objeto Session:

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

Observe que chamar o Session.Builder.build() o método não criar uma sessão do Vonage Video; ela cria o objeto Java Session, que representa uma sessão existente do Vonage Video. Você cria uma sessão do Vonage Video usando as bibliotecas do lado do servidor do Vonage Video. Consulte Criando uma sessão do Vonage Video.

Adicione um objeto ouvinte para eventos básicos relacionados à sessão chamando o setSessionListener(Session.SessionListener listener) método do objeto Session:

mSession.setSessionListener(this);

Implemente os métodos da interface `Session.SessionListener` no objeto que você especificar como objeto ouvinte de eventos. Esses métodos são chamados quando ocorrem eventos relacionados à sessão.

Instancie um objeto OTSession chamando o método OTSession init(apiKey:sessionId:delegate:) método com o ID do seu aplicativo e o ID da sessão correspondente:

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

Observe que chamar o OTSession init(apiKey: sessionId: delegate:) o método não criar uma sessão do Vonage Video; ela cria o objeto Swift OTSession, que representa uma sessão existente do Vonage Video. Você cria uma sessão do Vonage Video usando as bibliotecas do lado do servidor do Vonage Video.

Veja Criando uma sessão do Vonage Video.

Implemente os métodos da OTSessionDelegate protocolo no objeto que você especificar como objeto delegado. Esses métodos são chamados quando ocorrem eventos relacionados à sessão.

Antes de se conectar a uma sessão, instancie um objeto OTSession chamando o método [OTSession initWithApiKey: sessionId: delegate:] método com o ID do seu aplicativo e o ID da sessão correspondente:

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

Observe que chamar o [OTSession initWithApiKey:sessionId:delegate:] o método não criar uma sessão do Vonage Video; ela cria o objeto OTSession em Objective-C, que representa uma sessão existente do Vonage Video. Você cria uma sessão do Vonage Video usando as bibliotecas do lado do servidor do Vonage Video. Consulte Criando uma sessão do Vonage Video.

Implemente os métodos do protocolo OTSessionDelegate no objeto que você especificar como objeto delegado. Esses métodos são chamados quando ocorrem eventos relacionados à sessão.

Instancie um objeto Session chamando o método Session() construtor, passando o contexto de aplicativo do Windows apropriado, o ID do seu aplicativo e um ID de sessão do Vonage Video:

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

Observe que chamar o Session() o construtor não criar uma sessão do Vonage Video; isso cria um objeto Session em C#, que representa uma sessão existente do Vonage Video. Você cria uma sessão do Vonage Video usando as bibliotecas do lado do servidor do Vonage Video. Consulte Criando uma sessão do Vonage Video.

É recomendável adicionar manipuladores para eventos básicos relacionados à sessão:

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

É recomendável implementar cada um dos métodos de retorno de chamada. Por exemplo, este método lida com ConnectionCreated evento (que ocorre quando o cliente se conecta à sessão do Vonage Video):

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

Observação: A classe Session implementa a interface System.IDisposable. Certifique-se de chamar o Dispose() método do objeto Session para liberar seus recursos quando o objeto não for mais necessário (por exemplo, ao fechar o aplicativo ou a janela).

Crie uma estrutura do tipo otc_session_callbacks, e ponteiros de função para membros de função de retorno de chamada. Por exemplo:

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;

Use o user_data membro do otc_session_callbacks estrutura para definir dados aos quais você possa querer fazer referência nas funções de retorno de chamada. Neste exemplo, definimos isso como um ponteiro para um objeto de tipo string. Mas poderia ser um ponteiro para uma instância de algum outro tipo que contenha informações significativas.

Os demais membros do otc_session_callbacks A estrutura é composta por funções de retorno de chamada que são acionadas quando ocorrem eventos relacionados à sessão do Vonage Video. O exemplo anterior inclui funções de retorno de chamada para os seguintes itens:

• on_connected\ -- É chamado quando o otc_session_connect() A função (veja abaixo) conecta com sucesso a instância a uma sessão do Vonage Video.
• on_stream_received -- É chamado quando há um novo fluxo na sessão do Vonage Video (quando outro cliente publica um fluxo na sessão).
• on_stream_dropped -- É chamado quando o stream de outro cliente é removido da sessão do Vonage Video. Isso pode ocorrer quando o cliente interrompe a transmissão do stream ou se a conexão de rede do cliente for interrompida.
• on_disconnected -- É chamado quando o aplicativo se desconecta da sessão do Vonage Video (veja abaixo).
• on_error -- É chamada quando ocorre um erro ao se conectar à sessão. Essa função inclui parâmetros para uma string de erro e um código de erro definido pelo otc_session_error_code enum.

Todas as chamadas de retorno não serão executadas na thread do aplicativo ou na thread principal, mas em uma thread interna. O aplicativo deve retornar a chamada de retorno o mais rápido possível para evitar o bloqueio da thread interna.

Veja otc_session_callbacks Consulte a documentação de referência do SDK do Vonage Video para Linux para obter detalhes sobre cada uma das funções de retorno de chamada.

Após inicializar o otc_session_callbacks estrutura, chame o otc_session_new() função, passando a string do ID do seu aplicativo, a string do ID da sessão do Vonage Video e um ponteiro para o otc_session_callbacks estrutura:

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

O otc_session_new() A função retorna um otc_session estrutura, que representa uma sessão do Vonage Video.

Para usar configurações avançadas de sessão, chame a função otc_session_new_with_settings(), em vez do otc_session_new() função. Essa função recebe um settings parâmetro que é um ponteiro para um otc_session_settings estrutura que define as configurações avançadas. Por exemplo, o código a seguir utiliza o otc\_session_settings_new () função para instanciar um otc_session_settings estruturas e chamadas otc_session_settings_set_connection_events_suppressed(OTC_TRUE) para que o SDK suprime eventos de conexão, a fim de dar suporte a grandes sessões de vídeo interativas. Em seguida, ele passa o otc_session_settings struct na otc_session_new_with_settings() função:

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

Além de otc_session_settings_set_connection_events_suppressed(), as seguintes funções permitem definir configurações avançadas para uma sessão:

• otc_session_settings_set_custom_ice_config() — Permite a configuração personalizada do servidor ICE. Isso faz parte do recurso TURN configurável.
• otc_session_settings_set_ip_whitelist() — Isso corrobora a recurso de endereços IP permitidos disponível como um recurso adicional.
• otc_session_settings_set_proxy_url() — Define uma URL de proxy IP. Consulte o Guia do desenvolvedor do IP Proxy.

Ao adicionar um componente OTSession, ele se conecta automaticamente à sessão da Video API do Vonage.

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

Substituir your-application-ID, your-session-id, e your-session-token com o seu Chave de API, um ID da sessão, e um token para a sessão.

Observe que você deve adicionar o OTPublisher e OTSubscriber componentes e elementos filhos do OTSession componente.

Você pode passar um error e sessionConnected manipuladores de eventos no OTSession componente. O manipulador de eventos de erro é chamado caso o cliente não consiga se conectar à sessão. E o sessionConnected O manipulador de eventos é chamado quando o cliente se conecta à sessão:

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

Ligue para o connect() método, passando um token e uma função de manipulador de conclusão:

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

Um objeto de erro é passado para o manipulador de conclusão do connect evento que ocorre quando o cliente não consegue se conectar à sessão. Caso contrário, nenhum objeto de erro é passado, indicando que o cliente se conectou com sucesso à sessão.

O objeto Session também dispara um sessionConnected evento quando o cliente se conecta à sessão. E o objeto OT dispara um exception evento quando ocorre um erro na conexão. No entanto, é mais simples verificar se a conexão foi bem-sucedida passando um manipulador de conclusão para o connect() método, como último parâmetro.

Ligue para o Session.connect(token) método, passando um token válido:

mSession.connect(TOKEN);

O Session.SessionListener.onConnected(Session session) O método é chamado quando o cliente se conecta à sessão do Vonage Video.

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

O Session.SessionListener.onError(Session session, OpentokError error) O método é chamado quando ocorre um erro na conexão. Consulte a documentação da enumeração OpentokException.ErrorCode para obter descrições dos valores da code propriedade do objeto de erro.

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

Ligue para o OTSession connect(withToken:error:) método, passando o token do cliente:

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

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

O OTSessionDelegate sessionDidConnect(_:) A mensagem é enviada quando o cliente se conecta à sessão do Vonage Video.

O OTSessionDelegate session(_:didFailWithError:) é enviado quando ocorre um erro na conexão.

Consulte a documentação do Enumeração OTSessionErrorCode para obter descrições dos valores do code propriedade do objeto de erro.

Monitoramento do status da conexão (Swift)

Você pode verificar o status da conexão consultando o sessionConnectionStatus propriedade do objeto OTSession:

session.sessionConnectionStatus

Os valores válidos estão definidos no Enumeração OTSessionConnectionStatus.

Você pode usar um observador de chave-valor para monitorar essa propriedade. No entanto, o OTSessionDelegate sessionDidConnect(_:) e OTSessionDelegate sessionDidDisconnect(_:) As mensagens são enviadas ao delegado da sessão quando a sessão se conecta e se desconecta.

Ligue para o [OTSession connectWithToken:error:] método, passando o token do cliente:

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

O [OTSessionDelegate session:didConnect] A mensagem é enviada quando o cliente se conecta à sessão do Vonage Video.

O OTSessionDelegate session:didFailWithError:] é enviado quando ocorre um erro na conexão. Consulte a documentação do Enumeração OTSessionErrorCode para obter descrições dos valores do code propriedade do objeto de erro.

Monitoramento do status da conexão (Objective C)

Você pode verificar o status da conexão consultando o sessionConnectionStatus propriedade do objeto OTSession:

session.sessionConnectionStatus

Os valores válidos estão definidos no Enumeração OTSessionConnectionStatus.

Você pode usar um observador de chave-valor para monitorar essa propriedade. No entanto, o [OTSessionDelegate sessionDidConnect:] e [OTSessionDelegate sessionDidDisconnect:] As mensagens são enviadas ao delegado da sessão quando a sessão se conecta e se desconecta.

Ligue para o Session.connect(token) método, passando um token válido do OpenTok:

session.Connect(TOKEN);

O Session.Connected O evento é enviado quando o cliente se conecta à sessão do OpenTok.

session.ConnectionCreated += Session_ConnectionCreated;

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

O Session.Error O evento é enviado quando ocorre um erro na conexão:

session.Error += Session_Error;

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

Consulte a documentação do OpenTok.ErrorCode enum para descrições dos valores do code propriedade do objeto de erro.

Ligue para o otc_session_connect() função:

otc_session_connect(session, TOKEN);

Essa função conecta o cliente à sessão do Vonage Video. Ela recebe dois argumentos:

• O otc_session instância da estrutura.
• A sequência de caracteres do token de vídeo da Vonage.

Após estabelecer a conexão com sucesso, o on_connected função de retorno de chamada do otc_session_callbacks A estrutura é chamada. Em caso de erro, a on_error função de retorno de chamada do otc_session_callbacks a estrutura é chamada.

O cliente se desconecta da sessão quando você desmonta o OTSession componente.

Para se desconectar de uma sessão, ligue para o disconnect() método do objeto Session:

session.disconnect();

Para se desconectar de uma sessão, ligue para o Session.disconnect() método.

mSession.disconnect();

Como detectar quando a conexão foi interrompida (Android)

O Session.SessionListener.onDisconnected(Session session) O método é chamado quando o cliente se desconecta da sessão.

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

Se a conexão com a sessão for interrompida devido a um erro que ocorra após uma conexão bem-sucedida, o Session.SessionListener.onError(Session session, OpentokError error) O método é chamado antes do Session.SessionListener.onDisconnected(Session session) método. O objeto OpentokError passado para o Session.SessionListener.onError(Session session, OpentokError error) O método descreve o motivo do desligamento.

Para se desconectar de uma sessão, ligue para o OTSession disconnect(_:) método.

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

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

Como detectar quando a conexão foi interrompida (Swift)

O OTSessionDelegate sessionDidDisconnect(_:) A mensagem é enviada ao delegado da sessão quando a sessão é desconectada.

Observe que as sessões são desconectadas automaticamente quando o aplicativo é suspenso.

Se a conexão com a sessão for interrompida devido a um erro que ocorra após uma conexão bem-sucedida, o OTSessionDelegate session(_:didFailWithError:) a mensagem é enviada antes do OTSessionDelegate sessionDidDisconnect(_:) mensagem.

O OTSessionErrorCode A enum define o code propriedade do objeto OTError passado para o OTSessionDelegate session(_:didFailWithError:) mensagem, que descreve o motivo do desligamento.

Para se desconectar de uma sessão, ligue para o [OTSession disconnect:] método.

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

Detectando quando a conexão foi interrompida (Objective-C)

O [OTSessionDelegate sessionDidDisconnect:] A mensagem é enviada ao delegado da sessão quando a sessão é desconectada.

Observe que as sessões são desconectadas automaticamente quando o aplicativo é suspenso.

Se a conexão com a sessão for interrompida devido a um erro que ocorra após uma conexão bem-sucedida, o [OTSessionDelegate session:DidFailWithError:] a mensagem é enviada antes do [OTSessionDelegate sessionDidDisconnect:] mensagem. A enumeração OTSessionErrorCode define o code propriedade do objeto OTError passado para o [OTSessionDelegate session:DidFailWithError:] mensagem, que descreve o motivo do desligamento.

Para se desconectar de uma sessão, ligue para o Session.Disconnect() método:

session.Disconnect();

Como detectar quando a conexão foi interrompida (Windows)

O Session.Disconnected A mensagem é enviada quando o cliente se desconecta da sessão do Vonage Video.

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

Se a conexão com a sessão for interrompida devido a um erro que ocorra após uma conexão bem-sucedida, o Session.Error o evento é enviado antes do Session.Disconnected evento. O ErrorEventArgs objeto passado para o Session.Error O manipulador de eventos define o motivo pelo qual a conexão foi interrompida.

Para se desconectar de uma sessão, ligue para o otc_session_disconnect() função:

otc_session_disconnect(session);

Se você não for se reconectar à sessão, deve ligar para o otc_session_delete() e otc_destroy() funções:

otc_session_delete(session);
session = NULL;

otc_destroy();

Como detectar quando a conexão foi interrompida (Linux)

Quando o cliente se desconecta da sessão do OpenTok, o on_disconnected função de retorno de chamada do otc_session_callbacks a estrutura é chamada.

O OTSession o objeto despacha um connectionCreated evento que ocorre quando um novo cliente (exceto o seu próprio) se conecta à sessão. O objeto OTSession dispara um connectionDestroyed evento que ocorre quando outros clientes saem da sessão. Esses eventos são definidos pelo ConnectionEvent classe, que possui um connection objeto, que é um objeto Connection para a conexão (criada ou encerrada) relacionada ao 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}
>
    {/* ... */}

O objeto Session despacha um connectionCreated evento quando um novo cliente (incluindo o seu próprio) se conecta à sessão. O objeto Session dispara um connectionDestroyed evento quando outros clientes saem da sessão. Esses eventos são definidos pela classe ConnectionEvent, que possui um connection objeto, que é um objeto Connection para a conexão (criada ou encerrada) relacionada ao 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.');
  }
});

Quando você estiver conectado a uma sessão, o Session.ConnectionListener.onConnectionCreated(Session session, Connection connection) O método é chamado quando um novo cliente (que não seja o seu) se conecta à sessão.

O Session.ConnectionListener.onConnectionDestroyed(Session session, Connection connection) O método é chamado quando um cliente (que não seja o seu) sai da sessão. O objeto Connection passado para o método define a conexão que saiu da sessão.

Adicione um objeto ouvinte para esses eventos de conexão chamando a função setConnectionListener(Session.ConnectionListener listener) método do 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
}

O OTSessionDelegate session(_: connectionCreated:) uma mensagem é enviada ao delegado da sessão quando outro cliente se conecta à sessão (e para cada cliente conectado à sessão quando você se conecta).

O OTSessionDelegate session(_: connectionDestroyed:) uma mensagem é enviada ao delegado da sessão quando outro cliente se desconecta da sessão.

O [OTSessionDelegate session:connectionCreated:] uma mensagem é enviada ao delegado da sessão quando outro cliente se conecta à sessão (e para cada cliente conectado à sessão quando você se conecta).

O [OTSessionDelegate session:connectionDestroyed:] uma mensagem é enviada ao delegado da sessão quando outro cliente se desconecta da sessão.

Quando você estiver conectado a uma sessão, o Session.ConnectionCreated O evento é disparado quando um novo cliente (que não seja o seu) se conecta à sessão. O ConnectionEventArgs O objeto passado ao ouvinte de eventos define a conexão que saiu da sessão:

session.ConnectionCreated += Session_ConnectionCreated;

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

O Session.ConnectionDropped O evento é disparado quando um cliente (que não seja o seu) sai da sessão. O ConnectionEventArgs O objeto passado ao ouvinte de eventos define a conexão que saiu da sessão.

session.ConnectionCreated += Session_ConnectionDropped;

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

Depois de se conectar a uma sessão, o on_connection_created função de retorno de chamada do otc_session_callbacks A função `struct` é chamada quando um novo cliente (que não seja o seu) se conecta à sessão. A connection O parâmetro dessa função é um ponteiro para uma instância de um otc_connection estrutura correspondente ao cliente que está se conectando à sessão.

O on_connection_dropped função de retorno de chamada do otc_session_callbacks A função `struct` é chamada quando um cliente (que não seja o seu) se desconecta da sessão. A connection O parâmetro dessa função é um ponteiro para o otc_connection estrutura correspondente ao cliente que se desconecta da sessão.

Quando seu cliente se desconecta de uma sessão, o OTSession o componente envia um 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>

Quando seu cliente se desconecta de uma sessão, o objeto Session dispara um 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);

O reason A propriedade do evento é uma string que descreve o motivo pelo qual a sessão foi desconectada. Por exemplo, o exemplo anterior avisa o usuário caso ele tenha sido desconectado devido ao término da conexão de rede.

Para mais detalhes, consulte Event de Desconexão de Sessão.

Os clientes tentarão se reconectar automaticamente a uma sessão da qual tenham se desconectado inesperadamente (por exemplo, devido a uma queda na conectividade de rede). Você não precisa adicionar nenhum código para que os clientes se reconectem automaticamente, a menos que queira responder aos eventos disparados quando o cliente se desconectar e se reconectar.

Quando a conexão é interrompida e o cliente tenta se reconectar, o OTSession o objeto despacha um sessionReconnecting evento. Quando a conexão for restabelecida, o Session o objeto despacha um sessionReconnected. Se o cliente não conseguir restabelecer a conexão, ele se desconecta da sessão, e o objeto Session aciona o sessionDisconnected.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão:

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

Quando seu cliente se desconecta temporariamente de uma sessão, os objetos Subscriber nos clientes inscritos em um fluxo publicado por você disparam eventos quando o fluxo publicado é interrompido e quando (e se) ele for retomado automaticamente. Para obter mais informações, consulte Reconexão automática.

Para ver um código de exemplo que demonstra o uso desses eventos, consulte o opentok-reconexão repositório no GitHub.

Quando a conexão é interrompida e o cliente tenta se reconectar, o objeto Session dispara um reconnecting evento. Quando a conexão é restabelecida, o objeto Session dispara um reconnected evento. Se o cliente não conseguir restabelecer a conexão, ele se desconecta da sessão, e o objeto Session aciona o sessionDisconnected evento.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão:

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

Quando seu cliente se desconecta temporariamente de uma sessão, os objetos Subscriber nos clientes inscritos em um fluxo publicado por você disparam eventos quando o fluxo publicado é interrompido e quando (e se) ele for retomado automaticamente.

Para obter mais informações, consulte Reconexão automática no guia do desenvolvedor “Inscrição em streams”.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso. Você pode definir o retryAfterReconnect propriedade para false nas opções que você passa para o Session.signal() método para evitar que os sinais fiquem na fila enquanto você estiver desconectado.

Para obter mais informações, consulte Impedir que sinais sejam enviados durante a reconexão automática.

Quando a conexão é interrompida e o cliente tenta se reconectar, o Session.ReconnectionListener.onReconnecting(Session session) método é chamado. Quando a conexão é restabelecida, o Session.ReconnectionListener.onReconnected(Session session) o método é chamado.

Se o cliente não conseguir restabelecer a conexão, ele se desconectará da sessão do Vonage Video, e o Session.SessionListener.onDisconnected(Session session) o método é chamado.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão:

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

Quando seu cliente se desconecta temporariamente de uma sessão, os métodos nas implementações da interface `SubscriberKit.StreamListener` nos clientes inscritos em um fluxo publicado por você são chamados quando o fluxo publicado é interrompido e quando (e se) ele for retomado automaticamente.

Para obter mais informações, consulte o Detecção de quando os fluxos saem de uma sessão e reconexão etapa do Inscreva-se nos canais tutorial.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso. Você pode usar o Session.sendSignal(String type, String data, Connection connection, boolean retryAfterReconnect) método e definir o retryAfterReconnect parâmetro para false para evitar que os sinais fiquem na fila enquanto você estiver desconectado.

Para obter mais informações, consulte Impedir que sinais sejam enviados durante a reconexão automática.

Quando a conexão é interrompida e o cliente tenta se reconectar, o OTSessionDelegate sessionDidBeginReconnecting(_:) A mensagem é enviada ao delegado do objeto OTSession. Quando a conexão é restabelecida, o OTSessionDelegate sessionDidReconnect(_:) a mensagem é enviada. Se o cliente não conseguir restabelecer a conexão, o OTSessionDelegate sessionDidDisconnect(_:) A mensagem é enviada.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão.

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

Quando seu cliente se desconecta temporariamente de uma sessão, os objetos `OKSubscriberKitDelegate` nos clientes inscritos em um fluxo publicado por você enviam mensagens quando o fluxo publicado é interrompido e quando (e se) ele for retomado automaticamente.

Para obter mais informações, consulte o Detecção de quando os fluxos saem de uma sessão e reconexão etapa do Inscreva-se nos canais tutorial.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso. Você pode usar o OTSession signal(withType: string:connection:retryAfterReconnect:error:) método para evitar que os sinais fiquem na fila enquanto você estiver desconectado.

Para obter mais informações, consulte Tutorial sobre sinalização.

Quando a conexão é interrompida e o cliente tenta se reconectar, o [OTSessionDelegate sessionDidBeginReconnecting:] A mensagem é enviada ao delegado do objeto OTSession. Quando a conexão é restabelecida, o [OTSessionDelegate sessionDidReconnect:] a mensagem é enviada. Se o cliente não conseguir restabelecer a conexão, o [OTSessionDelegate sessionDidDisconnect:] A mensagem é enviada.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão.

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

Quando seu cliente se desconecta temporariamente de uma sessão, os objetos `OKSubscriberKitDelegate` nos clientes inscritos em um fluxo publicado por você enviam mensagens quando o fluxo publicado é interrompido e quando (e se) ele for retomado automaticamente. Para obter mais informações, consulte o Detecção de quando os fluxos saem de uma sessão e reconexão etapa do Inscreva-se nos canais tutorial.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso. Você pode usar o [OTSession signalWithType:string:connection:retryAfterReconnect:error:] método para evitar que os sinais fiquem na fila enquanto você estiver desconectado. Para obter mais informações, consulte Impedir que sinais sejam enviados durante a reconexão automática.

Quando a conexão é interrompida e o cliente tenta se reconectar, o Session.ReconnectionStart evento é enviado. Quando a conexão é restabelecida, o Session.ReconnectionSuccess o evento é enviado. Se o cliente não conseguir restabelecer a conexão, ele se desconecta da sessão do Vonage Video, e o Session.Disconnected o evento é enviado.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão:

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

Quando seu cliente se desconecta temporariamente de uma sessão, os objetos `Subscriber` nos clientes inscritos no fluxo enviam Subscriber.StreamDisconnected e Subscriber.StreamDisconnected eventos que ocorrem quando sua transmissão publicada é interrompida e quando (e se) ela é retomada automaticamente. Para obter mais informações, consulte o Detecção de quando os fluxos saem de uma sessão e reconexão etapa do Inscreva-se nos canais tutorial.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso. Você pode usar o Session.SendSignal(type, signal, connection, retryAfterReconnect) método e definir o retryAfterReconnect parâmetro para false para evitar que os sinais fiquem em fila enquanto você estiver desconectado. Para obter mais informações, consulte Impedir que sinais sejam enviados durante a reconexão automática.

Quando a conexão é interrompida e o cliente tenta se reconectar, o on_reconnection_started função de retorno de chamada do otc_session_callbacks struct é chamada. Quando a conexão é restabelecida, a on_reconnected função de retorno de chamada do otc_session_callbacks a estrutura é chamada.

Se o cliente não conseguir restabelecer a conexão, ele se desconecta da sessão do OpenTok, e o on_disconnected função de retorno de chamada do otc_session_callbacks a estrutura é chamada.

Em resposta a esses eventos, seu aplicativo pode (opcionalmente) exibir notificações na interface do usuário indicando os estados de desconexão temporária, reconexão e desconexão.

Quando outro cliente se desconecta temporariamente de uma sessão, o on_disconnected função de retorno de chamada do otc_subscriber_callbacks é chamada a estrutura para um assinante de um fluxo publicado por esse cliente. A on_reconnected função de retorno de chamada do otc_subscriber_callbacks A estrutura do assinante é chamada quando (e se) o cliente se reconectar e o fluxo for retomado automaticamente.

Para obter mais informações, consulte o Detecção de quando os fluxos saem de uma sessão e reconexão etapa do Inscreva-se nos canais tutorial.

Por padrão, quaisquer sinais que você enviar enquanto seu cliente estiver temporariamente desconectado de uma sessão são colocados em fila e enviados quando (e se) você se reconectar com sucesso.

Para evitar que os sinais fiquem em fila enquanto você estiver desconectado, você pode usar o otc_session_send_signal_with_options() função ou o otc_session_send_signal_to_connection_with_options () função e definir o retryAfterReconnect membro de false no otc_signal_options que você passa para a função.

Para obter mais informações, consulte Impedir que sinais sejam enviados durante a reconexão automática.