Suscríbase: Conceptos básicos

El <OTSession> El componente envía un streamCreated Evento que se produce cuando se crea un nuevo flujo (distinto del propio) en una sesión. Se crea un flujo cuando un cliente publica un flujo en la sesión. El 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 evento que se produce cuando se crea un nuevo flujo (que no sea el tuyo) en una sesión. Se crea un flujo cuando un cliente publica un flujo a la sesión. El 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 propiedad, que representa el flujo que se ha 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.

El onStreamReceived(Session session, Stream stream) El método del objeto `Session.SessionListener` se invoca cuando se crea en una sesión un flujo publicado por otro cliente. (Un flujo se crea cuando un cliente publica un flujo en la sesión o si el flujo ya existe en el momento de conectarse 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 de escucha para este evento llamando a la función setSessionListener(Session.SessionListener listener) del objeto Session:

mSession.setSessionListener(this);

El OTSessionDelegate session(_ session:streamCreated:) Se envía un mensaje cuando se crea un nuevo flujo en una sesión. (Se crea un flujo cuando un cliente publica a la sesión). El sitio Objeto OTStream tiene propiedades que definen el flujo. Compara el connection propiedad del objeto OTStream con el connection propiedad del objeto OTSession para determinar si el flujo es uno de los que ha publicado tu 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.
    }
}

Cuando los flujos abandonan una sesión, el [OTSession session: streamDestroyed:] Se envía el mensaje. Cuando se elimina un flujo, la vista de cualquier objeto `OTSubscriber` asociado a dicho flujo se elimina de su vista principal. Comprueba si el flujo no ha sido publicado por tu propio cliente y, en ese caso, elimina su vista de la vista principal.

- (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 cuándo se desactiva el vídeo de un suscriptor

El representante del suscriptor envía el [OTSubscriberDelegate subscriberVideoDisabled:reason:] Mensaje que aparece cuando el vídeo del suscriptor está desactivado:

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

El reason El parámetro se puede establecer en una de las siguientes constantes definidas en la enumeración 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 evento que se produce cuando se crea en una sesión un flujo publicado por otro cliente. (Se crea un flujo cuando un cliente publica un flujo a la sesión o si el flujo ya existe al conectarse a la sesión.)

@Override
session.StreamReceived += Session_StreamReceived;

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

El on_stream_received función de devolución de llamada de la 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 Creación de una instancia de `otc_session` y funciones de devolución de llamada relacionadas con la sesión.

Para suscribirse a todas las transmisiones de la sesión, añade un objeto OTSubscriber como hijo 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 transmisiones de otros clientes están disponibles en la sesión.

El objeto OTSubscriber envía un 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.');
  }
}}/>

Darse de baja

Para detener la reproducción de un flujo al que estás suscrito:

session.unsubscribe(subscriber);

Para suscribirse a un flujo, pasa el objeto Stream al subscribe del objeto Session:

session.subscribe(stream, replacementElementId);

El subscribe() recibe los siguientes parámetros:

• stream—El objeto Stream.
• targetElement— (Opcional) Define el elemento DOM que sustituye el vídeo del suscriptor.
• 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 Ajustar el audio y el vídeo.

• completionHandler— (Opcional) Una función que se invoca de forma asíncrona cuando la llamada a la subscribe() el método se ejecuta correctamente o falla. Si la llamada al 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 todas las secuencias, excepto a las publicadas por tu cliente:

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

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

El 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 por defecto.
• "after" — El objeto «Subscriber» es un nuevo elemento insertado después del «targetElement» en el DOM HTML. (Tanto «Subscriber» como «targetElement» tienen el mismo elemento padre.)
• "before" — El objeto «Subscriber» es un nuevo elemento insertado antes del «targetElement» en el DOM HTML. (Tanto «Subscriber» como «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 «Subscriber» tiene un element propiedad, cuyo valor es el elemento DOM de HTML que la contiene.

Cancelar suscripción (JavaScript)

Para detener la reproducción de un flujo al que estás suscrito:

session.unsubscribe(subscriber);

Para suscribirse a un flujo, primero hay que crear un objeto `Subscriber.Builder` llamando a la función Subscriber.Builder(Context context, Stream stream) constructor. Pasa el contexto de la aplicación de Android para el objeto `Subscriber` y el objeto `Stream`. Llama a la 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);

El SubscriberKit.SubscriberListener.onConnected(SubscriberKit subscriber) El método se invoca cuando la aplicación empieza a recibir el flujo del suscriptor. En este momento, puedes añadir la vista del suscriptor (devuelta por el 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 canal

Para dejar de reproducir una transmisión a la que estás suscrito, llama a la Session.unsubscribe(Subscriber subscriber) método:

mSession.unsubscribe(mSubscriber);

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

Para suscribirte a un flujo, llama a la función OTSubscriber init(stream:delegate:) método, pasando un objeto OTStream y un objeto delegado para recibir mensajes relacionados con los suscriptores. A continuación, llama alOTSession subscribe(_:error:) Método para empezar a suscribirse a la transmisión:

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

El 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 propiedad) 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 canal

Para dejar de reproducir una transmisión a la que estás suscrito, llama a la OTSession unsubscribe(_:error:) método:

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

El suscriptor se ha desconectado. A continuación, elimina su vista de su supervista:

subscriber.view?.removeFromSuperview()

Para suscribirte a un flujo, llama a la función [OTSubscriber initWithStream:] método, pasando un objeto OTStream y un objeto delegado para recibir mensajes relacionados con los suscriptores. A continuación, llama al[OTSession subscribe:error] Método para empezar a suscribirse a la transmisión:

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

El [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 propiedad) 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 canal

Para dejar de reproducir una transmisión a la que estás suscrito, llama a la [OTSession unsubscribe:error:] método:

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

El suscriptor se ha desconectado. A continuación, elimina 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. Pasa el contexto de la aplicación de Windows para el suscriptor, el objeto Stream y un renderizador de vídeo.

El OpenTok.IVideoRenderer define el renderizador de vídeo. El sitio OpenTok.VideoRenderer Esta clase, incluida en el SDK de Vonage Video para Windows, se encarga de la reproducción de 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 bien, puedes crear tu propio renderizador de vídeo personalizado que implemente el 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 «Subscriber» 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 canal

Para dejar de reproducir una transmisión a la que estás suscrito, llama a la Session.Unsubscribe(subscriber) método:

session.Unsubscribe(subscriber);

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

El 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() función que recibe como parámetro el otc_stream y otc_subscriber_callbacks casos

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 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_subscriber_callbacks La estructura está formada por una serie de funciones de llamada de retorno que se activan cuando se producen eventos relacionados con el suscriptor:

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

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

Para dejar de reproducir una transmisión a la que estás suscrito, llama a la otc_session_unsubscribe() pasando la función otc_session y otc_subscriber ejemplos:

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.