Inscreva-se: Noções básicas

O <OTSession> o componente envia um streamCreated evento que ocorre quando um novo fluxo (que não seja o seu) é criado em uma sessão. Um fluxo é criado quando um cliente publica um fluxo na sessão. O streamCreated O evento também é disparado para cada stream existente na sessão quando você se conecta pela primeira vez. O objeto do evento streamCreated inclui detalhes sobre o stream, incluindo dados de conexão, tipo de fonte de vídeo (“câmera” ou “tela”) e muito mais.

import OTSession from 'opentok-react-native';

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

Assim que detectar o novo fluxo, inscreva-se nele conforme descrito na próxima seção.

O objeto Session despacha um streamCreated evento que ocorre quando um novo fluxo (que não seja o seu) é criado em uma sessão. Um fluxo é criado quando um cliente publica um fluxo para a sessão. O streamCreated O evento também é disparado para cada stream existente na sessão quando você se conecta pela primeira vez. Esse evento é definido pela classe `StreamEvent`, que possui um stream propriedade, que representa o fluxo que foi criado:

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

Você pode se inscrever em qualquer canal. Consulte a próxima seção.

O onStreamReceived(Session session, Stream stream) O método do objeto `Session.SessionListener` é chamado quando um fluxo publicado por outro cliente é criado em uma sessão. (Um fluxo é criado quando um cliente publica um fluxo na sessão ou se o fluxo já existir no momento em que você se conecta à sessão.)

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

Adicione um objeto ouvinte para este evento chamando o setSessionListener(Session.SessionListener listener) método do objeto Session:

mSession.setSessionListener(this);

O OTSessionDelegate session(_ session:streamCreated:) A mensagem é enviada quando um novo fluxo é criado em uma sessão. (Um fluxo é criado quando um cliente publica um fluxo para a sessão.) O Objeto OTStream possui propriedades que definem o fluxo. Compare o connection propriedade do objeto OTStream com o connection propriedade do objeto OTSession para determinar se o fluxo é aquele publicado pelo seu cliente:

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

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

Quando os streams saem de uma sessão, o [OTSession session: streamDestroyed:] A mensagem é enviada. Quando um stream é descartado, a visualização de qualquer objeto OTSubscriber associado a esse stream é removida de sua superview. Verifique se o stream não foi publicado pelo seu próprio cliente e remova sua visualização da superview.

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

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

Detectar quando o vídeo de um assinante está desativado

O representante do assinante envia o [OTSubscriberDelegate subscriberVideoDisabled:reason:] mensagem exibida quando o vídeo do assinante está desativado:

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

O reason O parâmetro pode ser definido como uma das seguintes constantes definidas na enumeração OTSubscriberVideoEventReason:

• OTSubscriberVideoEventPublisherPropertyChanged — O problema com o vídeo ocorreu porque o autor da transmissão interrompeu a transmissão.
• OTSubscriberVideoEventQualityChanged — O problema no vídeo foi causado por uma alteração na qualidade do fluxo de vídeo. A qualidade do fluxo pode variar devido às condições da rede ou ao uso da CPU, tanto no lado do assinante quanto no do emissor. Esse motivo é utilizado apenas em sessões cujo modo de mídia esteja definido como “roteado”. (Consulte O Roteador de Mídia de Vídeo da Vonage e os modos de mídia.) Esse recurso do Vonage Video Media Router faz com que o assinante interrompa a transmissão de vídeo quando a qualidade do sinal se deteriora, e a mensagem é enviada. Quando as condições melhoram, a transmissão de vídeo é retomada, e o [OTSubscriberKit subscriberVideoEnabled:reason:] A mensagem é enviada. Quando o fluxo de vídeo é interrompido, o assinante continua recebendo o fluxo de áudio, caso haja um.
• OTSubscriberVideoEventSubscriberPropertyChanged — O problema com o vídeo foi causado por uma alteração na conta deste assinante OTSubscriberKit.subscribeToVideo propriedade.

Se a transmissão de vídeo for retomada, o [OTSubscriberKit subscriberVideoEnabled:reason:] A mensagem é enviada.

Ao publicar uma transmissão, você pode evitar que o vídeo seja desativado devido à qualidade da transmissão. Antes de chamar a função [OTSession publish:error:] método, defina o audioFallbackEnabled propriedade do objeto Publisher (ou do objeto PublisherKit) para NO.

O objeto Session envia um StreamReceived evento que ocorre quando um fluxo publicado por outro cliente é criado em uma sessão. (Um fluxo é criado quando um cliente publica um fluxo para a sessão ou se o fluxo já existe quando você se conecta à sessão.)

@Override
session.StreamReceived += Session_StreamReceived;

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

O on_stream_received função de retorno de chamada do otc_session_callbacks A função `struct` é chamada quando um fluxo publicado por outro cliente é criado em uma sessão. (Um fluxo é criado quando um cliente publica um fluxo para a sessão ou se o fluxo já existe quando você se conecta à sessão.) Consulte Criação de uma instância de `otc_session` e callbacks relacionados à sessão.

Para se inscrever em todos os fluxos da sessão, adicione um objeto OTSubscriber como filho do objeto OTSession:

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

Depois que o cliente se conecta à sessão, o objeto OTSubscriber adiciona visualizações para os vídeos dos assinantes quando as transmissões de outros clientes ficam disponíveis na sessão.

O objeto OTSubscriber dispara um connected evento que ocorre quando um assinante inicia a transmissão com sucesso. Ele dispara um evento de erro se houver um error assinar. Defina um eventHandlers propriedade do componente OTSubscriber e defina o connected e error propriedades desse objeto para as funções de retorno de chamada:

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

Cancelar inscrição

Para interromper a reprodução de uma transmissão da qual você é assinante:

session.unsubscribe(subscriber);

Para se inscrever em um stream, passe o objeto Stream para o subscribe método do objeto Session:

session.subscribe(stream, replacementElementId);

O subscribe() O método recebe os seguintes parâmetros:

• stream—O objeto Stream.
• targetElement— (Opcional) Define o elemento DOM que o vídeo do Assinante substitui.
• properties— (Opcional) Um conjunto de propriedades que personalizam a aparência da visualização do Assinante na página HTML e definem se o áudio e o vídeo devem ser reproduzidos

veja Personalização da interface do usuário

veja Ajustando o áudio e o vídeo.

• completionHandler— (Opcional) Uma função que é chamada de forma assíncrona quando a chamada para o subscribe() o método é executado com sucesso ou falha. Se a chamada para o subscribe() Se o método falhar, o manipulador de conclusão recebe um objeto de erro. Esse objeto possui um code e message propriedades que descrevem o erro.

O código a seguir assina todos os fluxos, exceto aqueles publicados pelo seu cliente:

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

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

O insertMode propriedade do properties parâmetro do Session.subscribe() O método especifica como o objeto Publisher será inserido no DOM HTML, em relação ao targetElement parâmetro. É possível definir esse parâmetro com um dos seguintes valores:

• "replace" — O objeto `Subscriber` substitui o conteúdo do `targetElement`. Esse é o comportamento padrão.
• "after" — O objeto `Subscriber` é um novo elemento inserido após o `targetElement` no DOM HTML. (Tanto o `Subscriber` quanto o `targetElement` têm o mesmo elemento pai.)
• "before" — O objeto `Subscriber` é um novo elemento inserido antes do `targetElement` no DOM HTML. (Tanto o `Subscriber` quanto o `targetElement` têm o mesmo elemento pai.)
• "append" — O objeto Subscriber é um novo elemento adicionado como filho do targetElement. Se houver outros elementos filhos, o Publisher é anexado como o último elemento filho do targetElement.

Por exemplo, o código a seguir adiciona um novo objeto Subscriber como filho de um subscriberContainer Elemento DOM:

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

O objeto `Subscriber` possui um element propriedade, que é definida como o elemento DOM HTML que a contém.

Cancelar inscrição (JavaScript)

Para interromper a reprodução de uma transmissão da qual você é assinante:

session.unsubscribe(subscriber);

Para assinar um stream, primeiro instancie um objeto `Subscriber.Builder` chamando o método Subscriber.Builder(Context context, Stream stream) construtor. Passe o contexto do aplicativo Android para o Subscriber e o objeto Stream. Chame o build() método para criar o objeto Subscriber. Em seguida, chame o subscribe() método do objeto Session para começar a se inscrever no fluxo:

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

O SubscriberKit.SubscriberListener.onConnected(SubscriberKit subscriber) O método é chamado quando o aplicativo começa a receber o fluxo do assinante. Nesse momento, você pode adicionar a visualização do assinante (retornada pelo getView() método do objeto Subscriber) como uma subvisualização de um objeto android.view.ViewGroup para exibi-lo no aplicativo:

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

Cancelar a inscrição em um stream

Para interromper a reprodução de uma transmissão da qual você é assinante, chame a função Session.unsubscribe(Subscriber subscriber) método:

mSession.unsubscribe(mSubscriber);

O Assinante é desconectado, e sua visualização é removida de sua supervisação.

Para se inscrever em um stream, chame a função OTSubscriber init(stream:delegate:) método, passando um objeto OTStream e um objeto delegado para receber mensagens relacionadas aos assinantes. Em seguida, chame oOTSession subscribe(_:error:) método para começar a assinar o feed:

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

O OTSubscriberDelegate subscriberDidConnect(toStream:) A mensagem é enviada quando o aplicativo começa a receber o fluxo do assinante. Nesse momento, você pode adicionar a visualização do assinante (representada pelo OTSubscriber view propriedade) ao aplicativo:

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

Cancelar a inscrição em um stream

Para interromper a reprodução de uma transmissão da qual você é assinante, chame a função OTSession unsubscribe(_:error:) método:

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

O assinante foi desconectado. Em seguida, remova sua visualização da supervisualização:

subscriber.view?.removeFromSuperview()

Para se inscrever em um stream, chame a função [OTSubscriber initWithStream:] método, passando um objeto OTStream e um objeto delegado para receber mensagens relacionadas aos assinantes. Em seguida, chame o[OTSession subscribe:error] método para começar a assinar o feed:

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

O [OTSubscriberDelegate subscriberDidConnectToStream:] A mensagem é enviada quando o aplicativo começa a receber o fluxo do assinante. Nesse momento, você pode adicionar a visualização do assinante (representada pelo OTSubscriber.view propriedade) ao aplicativo:

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

Cancelar a inscrição em um stream

Para interromper a reprodução de uma transmissão da qual você é assinante, chame a função [OTSession unsubscribe:error:] método:

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

O assinante foi desconectado. Em seguida, remova sua visualização da supervisualização:

[subscriber.view removeFromSuperview:];

Para se inscrever em um stream, primeiro instancie um objeto `Subscriber` chamando o método Subscriber(context, stream, renderer) construtor. Passe o contexto do aplicativo do Windows para o Assinante, o objeto Stream e um renderizador de vídeo.

O OpenTok.IVideoRenderer A interface define o renderizador de vídeo. A OpenTok.VideoRenderer A classe, incluída no SDK do Vonage Video para Windows, renderiza vídeo em um controle do Windows Presentation Framework. O objeto VideoRenderer é uma subclasse de System.Windows.Controls.Control.

Você pode adicionar esse elemento à sua hierarquia de visualização. Ou pode criar seu próprio renderizador de vídeo personalizado que implemente o OpenTok.IVideoRenderer interface.

Ligue para o subscribe() método do objeto Session para começar a se inscrever no fluxo:

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

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

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

O objeto Subscriber envia um Error caso ocorra um erro ao assinar o fluxo. Verifique o ErrorCode propriedade dos argumentos passados ao evento para ver detalhes sobre o motivo da falha na assinatura. (O OpenTok.ErrorCode definições de enumeração ErrorCode valores.)

O objeto Subscriber envia um Connected evento que ocorre quando o aplicativo começa a receber o fluxo do assinante.

Observação: A classe OpenTok.Subscriber implementa a interface System.IDisposable. Certifique-se de chamar o Dispose() método do objeto Subscriber para liberar seus recursos quando o objeto não for mais necessário (por exemplo, quando o Subscriber interrompe a transmissão de vídeo ou quando o aplicativo ou a janela está sendo fechado).

Você pode criar um driver de áudio personalizado para ser utilizado por todos os editores e assinantes.

Cancelar a inscrição em um stream

Para interromper a reprodução de uma transmissão da qual você é assinante, chame a função Session.Unsubscribe(subscriber) método:

session.Unsubscribe(subscriber);

O Assinante é desconectado, e sua visualização é removida de sua supervisação.

O on_stream_received A função de retorno de chamada (consulte a seção anterior) inclui um stream parâmetro, que é um ponteiro para um otc_stream estrutura que representa o novo fluxo. Para se inscrever no fluxo, instancie um otc_subscriber_callbacks Por exemplo, defina algumas funções de retorno de chamada para eventos relacionados aos assinantes e, em seguida, chame o otc_subscriber_new() função que recebe como parâmetro o otc_stream e otc_subscriber_callbacks instâncias

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

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

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

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

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

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

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

Use o user_data membro do otc_subscriber_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_subscriber_callbacks A estrutura é composta por funções de retorno de chamada que são invocadas quando ocorrem eventos relacionados ao assinante:

• on_connected — É chamado quando o assinante se conecta ao fluxo de áudio e vídeo.
• on_render_frame — É chamado sempre que o assinante estiver pronto para renderizar um novo quadro de vídeo.
• on_error — É chamado quando ocorre um erro do assinante.

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

Cancelar a inscrição em um stream

Para interromper a reprodução de uma transmissão da qual você é assinante, chame a função otc_session_unsubscribe() função, passando o otc_session e otc_subscriber instâncias:

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

Ligue para o otc_subscriber_delete() função para liberar a instância do assinante, incluindo todos os recursos de hardware e da interface do usuário vinculados a ela.