Suscríbase: Conceptos básicos

En <OTSession> envía un streamCreated cuando se crea un nuevo flujo (que no sea el suyo) en una sesión. Un flujo se crea cuando un cliente publica un flujo en la sesión. La dirección streamCreated también se envía para cada flujo existente en la sesión cuando se conecta por primera vez. El objeto de evento streamCreated incluye detalles sobre el flujo, incluidos los datos de conexión, el tipo de fuente de vídeo ('cámara' o 'pantalla'), etc.

import OTSession from 'opentok-react-native';

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

Una vez detectado el nuevo flujo, suscríbase a él como se describe en la siguiente sección.

El objeto Session envía un streamCreated cuando se crea un nuevo flujo (que no sea el suyo) en una sesión. Un flujo se crea cuando un cliente publica un flujo a la sesión. La dirección streamCreated para cada flujo existente en la sesión cuando se conecta por primera vez. Este evento está definido por el StreamEvent, que tiene un atributo stream que representa el flujo creado:

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

Puede suscribirse a cualquier flujo. Consulte la sección siguiente.

En onStreamReceived(Session session, Stream stream) del objeto Session.SessionListener es llamado cuando un flujo publicado por otro cliente es creado en una sesión. (Un flujo se crea cuando un cliente publica un flujo en la sesión o si el flujo existe cuando se conecta a la sesión).

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

Añade un objeto listener para este evento llamando a la función setSessionListener(Session.SessionListener listener) del objeto Session:

mSession.setSessionListener(this);

En OTSessionDelegate session(_ session:streamCreated:) se envía cuando se crea un nuevo flujo en una sesión. (Un flujo se crea cuando un cliente publica a la sesión). El sitio Objeto OTStream tiene propiedades que definen el flujo. Compare las propiedades connection del objeto OTStream con la propiedad connection del objeto OTSession para determinar si el flujo es uno que su cliente publicó:

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

Cuando los flujos abandonan una sesión, el [OTSession session: streamDestroyed:] se envía el mensaje. Cuando se abandona un flujo, la vista de cualquier objeto OTSubscriber para el flujo se elimina de su supervista. Compruebe si el flujo no está publicado por su propio cliente, y elimine su vista de su supervista.

- (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 cuando el vídeo de un abonado está desactivado

El delegado del abonado envía el [OTSubscriberDelegate subscriberVideoDisabled:reason:] cuando el vídeo del abonado está desactivado:

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

En reason se puede establecer en una de las siguientes constantes definidas en el enum OTSubscriberVideoEventReason:

• OTSubscriberVideoEventPublisherPropertyChanged - El evento de vídeo fue causado por el editor de la secuencia de detener el flujo de vídeo.
• OTSubscriberVideoEventQualityChanged - El evento de vídeo ha sido causado por un cambio en la calidad del flujo de vídeo. La calidad del flujo puede cambiar debido a las condiciones de la red o al uso de la CPU por parte del suscriptor o del editor. Esta razón sólo se utiliza en sesiones que tienen el modo de medios configurado como "enrutado". (Véase El enrutador de medios de video de Vonage y los modos de medios.) Esta función del enrutador de medios de video de Vonage hace que el suscriptor abandone el flujo de video cuando la calidad del flujo de video se degrada, y se envía el mensaje. Cuando las condiciones mejoran, el flujo de video se reanuda y se envía el mensaje. [OTSubscriberKit subscriberVideoEnabled:reason:] se envía el mensaje. Cuando se interrumpe el flujo de vídeo, el abonado sigue recibiendo el flujo de audio, si lo hay.
• OTSubscriberVideoEventSubscriberPropertyChanged - El evento de vídeo ha sido causado por un cambio en el abonado OTSubscriberKit.subscribeToVideo propiedad.

Si el flujo de vídeo se reanuda, el [OTSubscriberKit subscriberVideoEnabled:reason:] se envía el mensaje.

Cuando publique un flujo, puede evitar que se desactive su vídeo debido a la calidad del flujo. Antes de llamar a la función [OTSession publish:error:] establezca el método audioFallbackEnabled del objeto Publisher (o del objeto PublisherKit) a NO.

El objeto Session envía un StreamReceived cuando se crea en una sesión un flujo publicado por otro cliente. (Un flujo se crea cuando un cliente publica un flujo a la sesión o si el flujo existe cuando se conecta a la sesión).

@Override
session.StreamReceived += Session_StreamReceived;

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

En on_stream_received de la función otc_session_callbacks es llamada cuando un flujo publicado por otro cliente es creado en una sesión. (Un flujo se crea cuando un cliente publica un flujo a la sesión o si el flujo existe cuando se conecta a la sesión). Véase Instanciación de una instancia otc_session y callbacks relacionados con la sesión.

Para suscribirse a todos los flujos de la sesión, añada un objeto OTSubscriber como chile del objeto OTSession:

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

Una vez que el cliente se conecta a la sesión, el objeto OTSubscriber añade vistas para los vídeos de los suscriptores cuando las secuencias de otros clientes están disponibles en la sesión.

El objeto OTSubscriber envía un comando connected cuando un abonado inicia correctamente la transmisión. Envía un evento de error si hay un error suscribiendo. Establecer un eventHandlers prop del componente OTSubscriber, y establezca la propiedad connected y error de ese objeto a funciones de devolución de llamada:

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

Para suscribirse a un flujo, pase el objeto Stream a la función subscribe del objeto Session:

session.subscribe(stream, replacementElementId);

En subscribe() recibe los siguientes parámetros:

• stream-El objeto Stream.
• targetElement- (Opcional) Define el elemento DOM al que sustituye el vídeo de abonado.
• properties- (Opcional) Conjunto de propiedades que personalizan el aspecto de la vista Suscriptor en la página HTML y seleccionan si se suscribe a audio y vídeo.

véase Personalizar la interfaz de usuario

véase Ajuste de audio y vídeo.

• completionHandler- (Opcional) Una función que se llama de forma asíncrona cuando la llamada a la función subscribe() se completa con éxito o falla. Si la llamada al método subscribe() falla, el controlador de finalización recibe un objeto de error. Este objeto tiene un code y message que describen el error.

El siguiente código se suscribe a todos los flujos, salvo los publicados por su cliente:

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

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

En insertMode propiedad del properties del Session.subscribe() especifica cómo se insertará el objeto Publisher en el DOM HTML, en relación con el método targetElement parámetro. Puede establecer este parámetro en uno de los siguientes valores:

• "replace" - El objeto Subscriber sustituye el contenido del targetElement. Este es el valor predeterminado.
• "after" - El objeto Subscriber es un nuevo elemento insertado después del targetElement en el DOM HTML. (Tanto el Subscriber como el targetElement tienen el mismo elemento padre).
• "before" - El objeto Subscriber es un nuevo elemento insertado antes del targetElement en el DOM HTML. (Tanto el Subscriber como el targetElement tienen el mismo elemento padre).
• "append" - El objeto Subscriber es un nuevo elemento que se añade como hijo del targetElement. Si hay otros elementos hijos, el Publisher se añade como último elemento hijo del targetElement.

Por ejemplo, el siguiente código añade un nuevo objeto Subscriber como hijo de un objeto 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.');
      }
  });
});

El objeto Suscriptor tiene un element que se establece en el elemento HTML DOM que lo contiene.

Para suscribirse a un flujo, instancie primero un objeto Subscriber.Builder llamando a la función Subscriber.Builder(Context context, Stream stream) constructor. Introduzca el contexto de la aplicación Android para el suscriptor y el objeto Stream. Llame al build() para crear el objeto Suscriptor. A continuación, llame al método subscribe() del objeto Session para iniciar la suscripción al flujo:

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

En SubscriberKit.SubscriberListener.onConnected(SubscriberKit subscriber) cuando la aplicación empieza a recibir el flujo del suscriptor. En este punto, puedes añadir la vista del suscriptor (devuelta por el método getView() del objeto Subscriber) como una subvista de un objeto android.view.ViewGroup para mostrarla en la aplicación:

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

Darse de baja de un flujo

Para detener la reproducción de un flujo al que esté suscrito, llame al botón Session.unsubscribe(Subscriber subscriber) método:

mSession.unsubscribe(mSubscriber);

El Suscriptor se desconecta, y su vista se elimina de su supervista.

Para suscribirse a un flujo, llame a la función OTSubscriber init(stream:delegate:) pasando un objeto OTStream y un objeto delegado para recibir mensajes relacionados con el suscriptor. A continuación, llame al métodoOTSession subscribe(_:error:) para iniciar la suscripción al flujo:

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

En OTSubscriberDelegate subscriberDidConnect(toStream:) se envía cuando la aplicación empieza a recibir el flujo del abonado. En este punto, puedes añadir la vista del suscriptor (representada por el icono OTSubscriber view ) a la aplicación:

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

Darse de baja de un flujo

Para detener la reproducción de un flujo al que esté suscrito, llame al botón OTSession unsubscribe(_:error:) método:

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

El abonado está desconectado. A continuación, elimine su vista de su supervista:

subscriber.view?.removeFromSuperview()

Para suscribirse a un flujo, llame a la función [OTSubscriber initWithStream:] pasando un objeto OTStream y un objeto delegado para recibir mensajes relacionados con el suscriptor. A continuación, llame al método[OTSession subscribe:error] para iniciar la suscripción al flujo:

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

En [OTSubscriberDelegate subscriberDidConnectToStream:] se envía cuando la aplicación empieza a recibir el flujo del abonado. En este punto, puedes añadir la vista del suscriptor (representada por el icono OTSubscriber.view ) a la aplicación:

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

Darse de baja de un flujo

Para detener la reproducción de un flujo al que esté suscrito, llame al botón [OTSession unsubscribe:error:] método:

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

El abonado está desconectado. A continuación, elimine su vista de su supervista:

[subscriber.view removeFromSuperview:];

Para suscribirse a un flujo, instancie primero un objeto Subscriber llamando a la función Subscriber(context, stream, renderer) constructor. Introduzca el contexto de la aplicación Windows para el suscriptor, el objeto Stream y un renderizador de vídeo.

En OpenTok.IVideoRenderer define el renderizador de vídeo. El sitio OpenTok.VideoRenderer incluida en Vonage Video Windows SDK, renderiza vídeo en un control de Windows Presentation Framework. El objeto VideoRenderer es una subclase de System.Windows.Controls.Control.

Puedes añadir este elemento a tu jerarquía de vistas. O puede crear su propio renderizador de vídeo personalizado que implemente la función OpenTok.IVideoRenderer interfaz.

Llame al subscribe() del objeto Session para iniciar la suscripción al flujo:

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

El objeto Suscriptor envía un Error si se produce un error al suscribirse al flujo. Compruebe el ErrorCode de los argumentos pasados al evento para ver los detalles de por qué falló la suscripción. (La propiedad OpenTok.ErrorCode enum define ErrorCode valores).

El objeto Suscriptor envía un Connected cuando la aplicación empieza a recibir el flujo del suscriptor.

Nota: La clase OpenTok.Subscriber implementa la interfaz System.IDisposable. Asegúrese de llamar a la clase Dispose() del objeto Subscriber para liberar sus recursos cuando ya no necesite el objeto (por ejemplo, cuando el Subscriber deja de transmitir vídeo o cuando se cierra la aplicación o la ventana).

Puede crear un controlador de audio personalizado para uso de todos los editores y abonados.

Darse de baja de un flujo

Para detener la reproducción de un flujo al que esté suscrito, llame al botón Session.Unsubscribe(subscriber) método:

session.unsubscribe(subscriber);

El Suscriptor se desconecta, y su vista se elimina de su supervista.

En on_stream_received (véase la sección anterior) incluye una función de devolución de llamada stream que es un puntero a un otc_stream que representa el nuevo flujo. Para suscribirse al flujo, instancie una estructura otc_subscriber_callbacks establecer algunas funciones de devolución de llamada para los eventos relacionados con el suscriptor y, a continuación, llamar a la función otc_subscriber_new() introduciendo la variable otc_stream y otc_subscriber_callbacks instancias

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

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

Los demás miembros de la otc_subscriber_callbacks son funciones de devolución de llamada que se invocan cuando se producen eventos relacionados con el abonado:

• on_connected - Se activa cuando el abonado se conecta al flujo de audio-vídeo.
• on_render_frame - Llamada cada vez que el suscriptor está listo para renderizar un nuevo fotograma de vídeo.
• on_error - Llamada cuando se produce un error de abonado.

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

Véase otc_subscriber_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.

Darse de baja de un flujo

Para detener la reproducción de un flujo al que esté suscrito, llame al botón otc_session_unsubscribe() pasando la función otc_session y otc_subscriber instancias:

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

Llame al otc_subscriber_delete() para liberar la instancia del suscriptor, incluidos todos los recursos de hardware y de interfaz de usuario vinculados a ella.