Publicar: Conceptos básicos

El OT.initPublisher() El método inicializa y devuelve un objeto Publisher. El objeto Publisher representa la vista de un vídeo que publicas:

var publisher;
var targetElement = 'publisherContainer';

publisher = OT.initPublisher(targetElement, null, function(error) {
  if (error) {
    // The client cannot publish.
    // You may want to notify the user.
  } else {
    console.log('Publisher initialized.');
  }
});

El OT.initPublisher() El método toma tres parámetros:

• targetElement- (Opcional) Define el elemento DOM al que sustituye el vídeo del editor.

• properties— (Opcional) Un conjunto de propiedades que permiten personalizar el Publisher. El properties también incluye opciones para especificar un dispositivo de entrada de audio y vídeo utilizado por el editor. La dirección properties Este parámetro también incluye opciones para personalizar el aspecto de la vista en la página HTML (véase Personalizar la interfaz de usuario) y selecciona si deseas publicar audio y vídeo (véase Publicar sólo audio o vídeo). Para conocer más opciones de editor, consulta la documentación de la properties parámetro del OT.initPublisher() método.

• completionHandler- (Opcional) Un controlador de finalización que especifica si el editor se ha instanciado correctamente o con un error.

Puede pasar este objeto Publisher a la función Session.publish() para publicar un flujo en una sesión.

Antes de llamar Session.publish(), puedes utilizar este objeto Publisher para probar el micrófono y la cámara conectados al Publisher.

El insertMode propiedad del properties del OT.initPublisher() 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 Publisher sustituye el contenido del `targetElement`. Esta es la opción predeterminada.
• "after" - El objeto Publisher es un nuevo elemento insertado después del targetElement en el DOM HTML. (Tanto el Publisher como el targetElement tienen el mismo elemento padre).
• "before" - El objeto Publisher es un nuevo elemento insertado antes del targetElement en el DOM HTML. (Tanto el Publisher como el targetElement tienen el mismo elemento padre).
• "append" — El objeto «Publisher» es un nuevo elemento añadido como elemento secundario del «targetElement». Si hay otros elementos secundarios, el «Publisher» se añade al final como último elemento secundario del «targetElement».

Por ejemplo, el siguiente código añade un nuevo objeto Publisher como hijo de un objeto publisherContainer Elemento DOM:

// Try setting insertMode to other values: "replace", "after", or "before":
var publisherProperties = {insertMode: "append"};
var publisher = OT.initPublisher('publisherContainer', publisherProperties, function (error) {
  if (error) {
    console.log(error);
  } else {
    console.log("Publisher initialized.");
  }
});

Para un editor básico, utiliza el Publisher.Builder para instanciar un objeto Publisher. Introduzca el contexto de la aplicación Android para el editor:

mPublisher = new Publisher.Builder(context)
    .build();

Añade un objeto receptor para los eventos básicos relacionados con la publicación llamando a la función setPublisherListener(PublisherKit.PublisherListener listener) método del objeto Publisher:

mPublisher.setPublisherListener(this);

Implemente los métodos de la interfaz PublisherKit.PublisherListener en el objeto que especifique como objeto receptor de eventos. Estos métodos se ejecutan cuando se producen eventos relacionados con el editor.

El getView() del objeto Publisher devuelve la vista del vídeo que has publicado. Añádelo como subvista de un objeto android.view.ViewGroup para mostrarlo en la aplicación:

mPublisherViewContainer.addView(mPublisher.getView());

Pasa el objeto Publisher a la Session.publish() para publicar un flujo en una sesión.

Puede llamar a otros métodos del objeto Publisher.Builder para definir configuraciones personalizadas para el editor:

mPublisher = new Publisher.Builder(context)
    .name("Bob")
    .audioTrack(true)
    .frameRate(CameraCaptureFrameRate.FPS_7)
    .resolution(CameraCaptureResolution.LOW)
    .videoTrack(false)
    .capturer(mCapturer)
    .renderer(mRenderer)
    .build();

Tenga en cuenta que en las sesiones que utilizan el router de medios de vídeo de Vonage (sesiones con el modo multimedia enrutado), al reducir la frecuencia de imagen se reduce proporcionalmente el ancho de banda utilizado por el flujo. Sin embargo, en las sesiones que tienen el modo de medios establecido en retransmitido, la reducción de la frecuencia de imagen no reduce el ancho de banda del flujo.

Uso de un capturador de vídeo personalizado

Puede utilizar un capturador de vídeo personalizado para publicar un flujo con una fuente de vídeo personalizada. También puede utilizar el capturador de vídeo personalizado para publicar un flujo de pantalla compartida.

Compartir pantalla.

También puedes utilizar una fuente de audio personalizada para la transmisión publicada; consulta Uso de un controlador de audio personalizado.

Utiliza el OTPublisher para crear un editor. La dirección view La propiedad del objeto contiene la vista del vídeo que publicas:

let publisher = OTPublisher(delegate: self, settings: OTPublisherSettings())!
if let publisherView = publisher.view {
    self.view.addSubview(publisherView)
    publisherView.frame = CGRect(x: 0, y: 0, width: 200, height: 150)
}

Implementa los métodos del protocolo OTPublisherDelegate en el objeto que especifiques como objeto delegado. Estos métodos se llaman cuando se producen eventos relacionados con el editor.

Pasa el objeto Publisher a la OTSession publish(_:error:) para publicar un flujo en una sesión.

Puedes configurar otras propiedades del objeto OTPublisherSettings para definir ajustes personalizados para el editor:

let publisherSettings = OTPublisherSettings()
publisherSettings.name = "Bob's video"
publisherSettings.audioTrack = false
publisherSettings.videoTrack = true
publisherSettings.cameraResolution = .high
publisherSettings.cameraFrameRate = .rate30FPS
let publisher = OTPublisher(delegate: self, settings: publisherSettings)!

Tenga en cuenta que en las sesiones que utilizan el router de medios de vídeo de Vonage (sesiones con el modo multimedia enrutado), al reducir la frecuencia de imagen se reduce proporcionalmente el ancho de banda utilizado por el flujo. Sin embargo, en las sesiones que tienen el modo de medios establecido en retransmitido, la reducción de la frecuencia de imagen no reduce el ancho de banda del flujo.

Puede utilizar un capturador de vídeo personalizado para publicar un flujo con una fuente de vídeo personalizada - véase Uso de un capturador de vídeo personalizado. También puedes utilizar el capturador de vídeo personalizado para publicar una transmisión en la que se comparta la pantalla; consulta Compartir pantalla.

También puedes utilizar una fuente de audio personalizada para la transmisión publicada; consulta Uso de un controlador de audio personalizado.

Utiliza el OTPublisher para crear un editor. La dirección view La propiedad del objeto contiene la vista del vídeo que publicas:

OTPublisher publisher = [[OTPublisher alloc]
                        initWithDelegate:self
                        settings:[[OTPublisherSettings alloc] init]];
[self.view addSubview:publisher.view];
[publisher.view setFrame:CGRectMake(0, 0, 200, 150)];

Implementa los métodos del protocolo OTPublisherDelegate en el objeto que especifiques como objeto delegado. Estos métodos se llaman cuando se producen eventos relacionados con el editor.

Pasa el objeto Publisher a la [OTSession publish:error] para publicar un flujo en una sesión.

Puedes configurar otras propiedades del objeto OTPublisherSettings para definir ajustes personalizados para el editor:

OTPublisherSettings *_publisherSettings = [[OTPublisherSettings alloc] init];
_publisherSettings.name = @"Bob's video";
_publisherSettings.audioTrack = NO;
_publisherSettings.videoTrack = YES;
_publisherSettings.cameraResolution = OTCameraCaptureResolutionHigh;
_publisherSettings.cameraFrameRate = OTCameraCaptureFrameRate30FPS;
_publisher = [[OTPublisher alloc]
                initWithDelegate:self
                settings:_publisherSettings];

Tenga en cuenta que en las sesiones que utilizan el router de medios de vídeo de Vonage (sesiones con el modo multimedia enrutado), al reducir la frecuencia de imagen se reduce proporcionalmente el ancho de banda utilizado por el flujo. Sin embargo, en las sesiones que tienen el modo de medios establecido en retransmitido, la reducción de la frecuencia de imagen no reduce el ancho de banda del flujo.

Puede utilizar un capturador de vídeo personalizado para publicar un flujo con una fuente de vídeo personalizada - véase Uso de un capturador de vídeo personalizado.

También puede utilizar el capturador de vídeo personalizado para publicar un flujo de pantalla compartida - ver Compartir pantalla.

También puedes utilizar una fuente de audio personalizada para la transmisión publicada; consulta Uso de un controlador de audio personalizado.

Puede crear un Publisher básico llamando a la función Publisher() pasando la instancia de la aplicación Windows:

publisher = new Publisher(Context.Instance);
publisher.Error += Publisher_Error;

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

Pasa el objeto Publisher a la Session.publish() para publicar un flujo en una sesión.

De manera predeterminada, el editor utiliza el capturador de video predeterminado, que utiliza el micrófono y la cámara predeterminados del sistema como fuente de audio y video para la transmisión publicada. Esto se define mediante VideoCapturer en el SDK de video de Vonage.

Puede definir un objeto capturador de vídeo específico para que lo utilice el editor. Este objeto captura vídeo de una fuente de vídeo (como una cámara) y tiene ajustes para el vídeo (como la frecuencia de imagen y la resolución).

Puedes utilizar el VideoCapturer.EnumerateDevices() Método para enumerar los dispositivos de captura de vídeo (cámaras) del sistema. Devuelve una lista de objetos `VideoDevice`. La clase `VideoDevice` incluye una serie de CreateVideoCapturer() para instanciar un objeto VideoCapturer que utilice el dispositivo de vídeo:

• VideoCapturer.CreateVideoCapturer(format) — Crea un objeto `VideoCapturer` utilizando la configuración definida por un objeto `VideoFormat`.
• VideoCapturer.CreateVideoCapturer(width, height, fps) - Crea un objeto VideoCapturer con la resolución definida por la directiva width y height y con la frecuencia de imagen definida por fps parámetro.
• VideoCapturer.CreateVideoCapturer(resolution, fps) - Crea un objeto VideoCapturer con la resolución definida por la directiva resolution parámetro y con la frecuencia de fotogramas definida por el fps parámetro. La dirección OpenTok.VideoCapturer.Resolution define los valores utilizados por el resolution parámetro: Low (320x240 píxeles), Medium (640x480 píxeles), y High (1280x720 píxeles), y High 1080p (1920 x 1080 píxeles).

El capturador de vídeo utiliza la resolución soportada en el sistema más cercana a la resolución que especifiques.

De forma predeterminada, los editores utilizan un renderizador de vídeo predeterminado para Windows Presentation Foundation, definido por la clase `VideoRenderer` del SDK de Vonage Video para Windows. También puedes especificar un renderizador para el vídeo creando una clase que implemente la interfaz `IVideoRenderer`. Puedes utilizar un renderizador de vídeo personalizado; consulta Uso de un renderizador de vídeo personalizado.

El siguiente código crea un Publisher que utiliza el capturador de vídeo predeterminado del sistema con la resolución establecida en 720p (VideoCapturer.Resolution.High) y la frecuencia de imagen fijada en 30 fotogramas por segundo:

var devices = VideoCapturer.EnumerateDevices();
var selectedDevice = devices[0];
capturer = selectedDevice.CreateVideoCapturer(VideoCapturer.Resolution.High,
                VideoCapturer.VideoCapturer.FrameRate.Fps30);
publisher = new Publisher(Context.Instance, renderer: publisherVideoRenderer, capturer: capturer);
publisher.Error += Publisher_Error;

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

Nota: En las sesiones que utilizan el router de medios de vídeo de Vonage (sesiones con el modo multimedia enrutado), al reducir la frecuencia de imagen se reduce proporcionalmente el ancho de banda utilizado por el flujo. Sin embargo, en las sesiones que tienen el modo de medios establecido en retransmitido, la reducción de la frecuencia de imagen no reduce el ancho de banda del flujo.

Puede pasar otros parámetros opcionales del Publisher() constructor para definir ajustes personalizados para la transmisión publicada:

• name - El nombre del vídeo del editor. El Stream.Name La propiedad de una transmisión publicada por este emisor se establecerá en este valor (en todos los clientes).
• hasAudioTrack — Si se debe incluir una pista de audio en la transmisión publicada. El valor por defecto es true.
• hasVideoTrack — Si se debe incluir una pista de audio en la transmisión publicada. El valor por defecto es true.
• stereo — Si se desea habilitar el audio estéreo en la transmisión publicada. El valor por defecto es false. Ajústelo a true para reproducir el audio de un micrófono estéreo.

También puede cambiar la fuente de audio utilizada por el editor. O también puedes crear un controlador de audio personalizado para uso de todos los editores y abonados.

Puede utilizar un capturador de vídeo personalizado para publicar un flujo con una fuente de vídeo personalizada - véase Uso de un capturador de vídeo personalizado.

También puede utilizar el capturador de vídeo personalizado para publicar un flujo de pantalla compartida - ver Compartir pantalla.

Nota: La clase OpenTok.Publisher y OpenTok.VideoCapturer implementan la interfaz System.IDisposable. Asegúrese de llamar a la clase Dispose() de estos objetos para liberar sus recursos cuando ya no necesites el objeto (por ejemplo, cuando se elimina el Editor o cuando se cierra la aplicación o la ventana).

Comience por crear una estructura de tipo otc_publisher_callbacks:

char *publisher_user_data = strdup("Publisher user data");

static void on_publisher_stream_created(otc_publisher *publisher,
                                        void *user_data,
                                        const otc_stream *stream) {
  // The stream has been created.
}

static void on_publisher_render_frame(otc_publisher *publisher,
                                      void *user_data,
                                      const otc_video_frame *frame) {
  // You can render the frame to the UI.
}

static void on_publisher_stream_destroyed(otc_publisher *publisher,
                                          void *user_data,
                                          const otc_stream *stream) {
  // The stream has been destroyed.
}

static void on_publisher_error(otc_publisher *publisher,
                                void *user_data,
                                const char* error_string,
                                enum otc_publisher_error_code error_code) {
  // Handle the error.
}


struct otc_publisher_callbacks publisher_callbacks = {0};
publisher_callbacks.user_data = publisher_user_data;
publisher_callbacks.on_stream_created = on_publisher_stream_created;
publisher_callbacks.on_render_frame = on_publisher_render_frame;
publisher_callbacks.on_stream_destroyed = on_publisher_stream_destroyed;
publisher_callbacks.on_error = on_publisher_error;

Utiliza el user_data miembro de la otc_publisher_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 array char. 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_publisher_callbacks son funciones de devolución de llamada que se invocan cuando se producen eventos relacionados con el flujo publicado:

• on_stream_created — Se invoca cuando el editor comienza a transmitir datos a la sesión.
• on_render_frame - Se llama cada vez que el editor está listo para renderizar un nuevo fotograma de vídeo en la secuencia.
• on_stream_destroyed - Llamada cuando se destruye el flujo del editor.
• on_error — Se invoca cuando se produce un error al publicar el flujo.

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_publisher_callbacks en la referencia OpenTok Linux SDK para más detalles sobre cada una de las funciones de callback.

Llame al otc_publisher_new() para crear un otc_publisher estructura, que representa al editor de OpenTok:

publisher = otc_publisher_new("Bob's video",
                                                    NULL, /* Use the system camera. */
                                                    &publisher_callbacks);
if (publisher == NULL) {
  printf("Could not create OpenTok publisher successfully");
  otc_session_delete(session);
  otc_destroy();
  return EXIT_FAILURE;
}

El otc_publisher_new() recibe tres argumentos:

• name — Un nombre (opcional) que identifique al editor de la transmisión.
• capturer - Utilice este parámetro si desea proporcionar un capturador de vídeo personalizado. Si se establece en NULLel editor utiliza la cámara predeterminada del sistema como fuente de vídeo.

Véase Uso de un capturador de vídeo personalizado para ver cómo implementar un capturador de vídeo personalizado.

• callbacks - La otc_publisher_callbacks estructura de devolución de llamada del editor, descrita anteriormente.

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

Puede utilizar un capturador de vídeo personalizado para publicar un flujo con una fuente de vídeo personalizada - véase Uso de un capturador de vídeo personalizado.

Para publicar un flujo, añada un componente OTPublisher como hijo del objeto OTSession:

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

El publicador inicia el streaming cuando el cliente se conecta a la sesión. El objeto OTPublisher envía un streamCreated evento cuando comienza a transmitir a la sesión. Envía un error si hay un evento error publicación. Establecer un eventHandlers del componente OTPublisher, y establezca la propiedad streamCreated y error de ese objeto a funciones de devolución de llamada:

<OTPublisher
eventHandlers={{
  streamCreated: () => {
    console.log('The publisher started streaming.');
  },
  error: event => {
    console.log('Publisher error:', event);
  },
}}/>

Pasar el objeto editor a publish() Método de un objeto Session para publicar un flujo en la sesión:

publisher = OT.initPublisher('replacementElementId');
session.publish(publisher, function(error) {
  if (error) {
    console.log(error);
  } else {
    console.log('Publishing a stream.');
  }
});

El segundo parámetro es una función de gestión de finalización a la que se pasa un objeto de error si falla la publicación. En caso contrario, se llama a la función de finalización sin pasarle ningún error.

Este código supone que session es un objeto Session y que el cliente se ha conectado a la sesión. Para obtener más información, consulta Cómo unirse a una sesión.

El objeto Publish envía un streamCreated cuando comience a transmitirse a la sesión:

var publisher = OT.initPublisher();
session.publish(publisher, function(error) {
  if (error) {
    console.log(error);
  } else {
    console.log('Publishing a stream.');
  }
});
publisher.on('streamCreated', function (event) {
    console.log('The publisher started streaming.');
});

El objeto Publisher tiene un element propiedad, cuyo valor es el elemento DOM de HTML que la contiene.

Puede establecer la tasa de bits máxima para un flujo publicado. Establecer la bitrate máximo puede ayudar a reducir el consumo de ancho de banda cuando un usuario está se conecta desde una conexión con contador. Consulte esta documentación.

Pasar el objeto editor a publish(PublisherKit publisher) de un objeto Session para publicar el flujo en la sesión:

mSession.publish(mPublisher);

Este código supone que mSession es un objeto Session y que el cliente se ha conectado a la sesión. Para obtener más información, consulta Cómo unirse a una sesión.

El PublisherKit.PublisherListener.onStreamCreated(PublisherKit publisher, Stream stream) se llama cuando el editor comienza a transmitir a la sesión:

@Override
public void onStreamCreated(publisher, stream) {
    // The publisher started streaming.
}

Puede establecer la tasa de bits máxima para un flujo publicado. Establecer la bitrate máximo puede ayudar a reducir el consumo de ancho de banda cuando un usuario está se conecta desde una conexión con contador. Consulte esta documentación.

Pasar el objeto editor a OTSession publish(_:error:) de un objeto OTSession para publicar el flujo en la sesión:

var error: OTError?
session.publish(publisher, error: &error)

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

Este código supone que session es un objeto Session y que el cliente se ha conectado a la sesión. Para obtener más información, consulta Cómo unirse a una sesión.

El OTPublisherDelegate publisher(_:streamCreated:) El mensaje se envía cuando el editor comienza a transmitir datos a la sesión.

Pasar el objeto editor a [OTSession publish:error] de un objeto OTSession para publicar el flujo en la sesión:

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

Este código supone que session es un objeto Session y que el cliente se ha conectado a la sesión. Para obtener más información, consulta Creación de una sesión.

El [OTPublisherDelegate publisher:streamCreated:] El mensaje se envía cuando el editor comienza a transmitir datos a la sesión.

Puede establecer la tasa de bits máxima para un flujo publicado. Establecer la bitrate máximo puede ayudar a reducir el consumo de ancho de banda cuando un usuario está se conecta desde una conexión con contador. Consulte esta documentación.

Pasar el objeto editor a Publish(publisher) de un objeto Session para publicar el flujo en la sesión:

session.Publish(publisher);

Este código supone que session es un objeto Session, que publisher es un objeto Publisher y que el cliente se ha conectado a la sesión. Para más información, véase Cómo unirse a una sesión.

El Publisher envía el StreamCreated cuando el editor comienza a transmitir a la sesión:

publisher.StreamCreated += Publisher_StreamCreated;
session.Publish(publisher);
private void Publisher_StreamCreated(object sender, Publisher.StreamEventArgs e)
{
    Console.WriteLine("The publisher started streaming.");
}

Puede establecer la tasa de bits máxima para un flujo publicado. Establecer la bitrate máximo puede ayudar a reducir el consumo de ancho de banda cuando un usuario está se conecta desde una conexión con contador. Consulte esta documentación.

Cuando la aplicación se conecta a una sesión, el icono on_connected() función de devolución de llamada de la otc_session_callbacks se llama a la estructura (véase Cómo unirse a una sesión). En respuesta a esto, puede llamar a la función otc_session_publish() Función para publicar una transmisión en la sesión de OpenTok:

if (otc_session_publish(session, publisher) != OTC_SUCCESS) {
  printf("Could not publish successfully.");
}

El otc_session_publish() toma dos argumentos:

• El puntero al otc_session estructura.
• El otc_publisher estructura.

Devuelve OTC_SUCCESS cuando se inicia con éxito la publicación de un flujo en la sesión. O devuelve un error, y el otc_error .

Puede establecer la tasa de bits máxima para un flujo publicado. Establecer la bitrate máximo puede ayudar a reducir el consumo de ancho de banda cuando un usuario está se conecta desde una conexión con contador. Consulte esta documentación.

Setting the degradation preference

Puedes configurar este valor utilizando cualquiera de las opciones proporcionadas DegradationPreference valores:

• DegradationPreference.NotSet: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

<OTPublisher
  properties={{
    degradationPreference: DegradationPreference.NotSet
  }}
/>

• DegradationPreference.MaintainFrameRateAndResolution: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

<OTPublisher
  properties={{
    degradationPreference: DegradationPreference.MaintainFrameRateAndResolution
  }}
/>

• DegradationPreference.MaintainFrameRate: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

<OTPublisher
  properties={{
    degradationPreference: DegradationPreference.MaintainFrameRate
  }}
/>

• DegradationPreference.MaintainResolution: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

<OTPublisher
  properties={{
    degradationPreference: DegradationPreference.MaintainResolution
  }}
/>

• DegradationPreference.Balanced: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

<OTPublisher
  properties={{
    degradationPreference: DegradationPreference.Balanced
  }}
/>

Setting the degradation preference

Para establecer la preferencia de degradación del editor, utilice publisher.setDegradationPreference con cualquiera de las opciones disponibles que se ofrecen en DegradationPreference:

publisher.setDegradationPreference(DegradationPreference.DegradationPreferenceMaintainResolution);

Lo siguiente DegradationPreference están disponibles:

• DegradationPreferenceNotSet: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

• DegradationPreferenceMaintainFrameRateAndResolution: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

• DegradationPreferenceMaintainFrameRate: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

• DegradationPreferenceMaintainResolution: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

• DegradationPreferenceBalanced: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

Getting the current degradation preference

Para recuperar la preferencia de degradación del editor actualmente configurada, utilice publisher.getDegradationPreference:

DegradationPreference preference = publisher.getDegradationPreference();

Setting the degradation preference

Para establecer la preferencia de degradación del editor, establezca publisher.degradationPreference a cualquiera de las opciones disponibles en OTDegradationPreference:

publisher.degradationPreference = .maintainResolution

Lo siguiente OTDegradationPreference están disponibles:

• notSet: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

• maintainFrameRateAndResolution: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

• maintainFrameRate: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

• maintainResolution: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

• balanced: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

Getting the current degradation preference

Para consultar la preferencia de degradación del editor configurada actualmente, lee publisher.degradationPreference propiedad:

let preference = publisher.degradationPreference;

Setting the degradation preference

Para establecer la preferencia de degradación del editor, establezca publisher.degradationPreference a cualquiera de las opciones disponibles en OTDegradationPreference:

publisher.degradationPreference = OTDegradationPreferenceMaintainResolution;

Lo siguiente OTDegradationPreference están disponibles:

• OTDegradationPreferenceNotSet: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

• OTDegradationPreferenceMaintainFrameRateAndResolution: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

• OTDegradationPreferenceMaintainFrameRate: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

• OTDegradationPreferenceMaintainResolution: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

• OTDegradationPreferenceBalanced: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

Getting the current degradation preference

Para consultar la preferencia de degradación del editor configurada actualmente, lee publisher.degradationPreference propiedad:

OTDegradationPreference preference = publisher.degradationPreference;

Setting the degradation preference

Para establecer la preferencia de degradación del editor, establezca publisher.DegradationPreference a cualquiera de las opciones disponibles en DegradationPreference:

publisher.DegradationPreference = DegradationPreference.MaintainResolution;

Lo siguiente DegradationPreference están disponibles:

• NotSet: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

• MaintainFrameRateAndResolution: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

• MaintainFrameRate: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

• MaintainResolution: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

• Balanced: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

Getting the current degradation preference

Para consultar la preferencia de degradación del editor configurada actualmente, lee publisher.DegradationPreference propiedad:

DegradationPreference preference = publisher.DegradationPreference;

Setting the degradation preference

Para establecer la preferencia de degradación del editor, utilice otc_publisher_set_degradation_preference con cualquiera de las opciones disponibles que se ofrecen en otc_degradation_preference:

otc_publisher_set_degradation_preference(publisher, OTC_DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION);

Lo siguiente otc_degradation_preference están disponibles:

• OTC_DEGRADATION_PREFERENCE_NOT_SET: El valor por defecto. El motor de vídeo decidirá la preferencia de degradación óptima.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION: El motor de vídeo intentará mantener constante la frecuencia de fotogramas y no reducir la resolución.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE: El motor de vídeo intentará mantener constante la frecuencia de fotogramas, pero podría reducir la resolución si fuera necesario.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION: El motor de vídeo no reducirá la resolución, pero puede reducir la frecuencia de imagen si es necesario.

• OTC_DEGRADATION_PREFERENCE_BALANCED: El motor de vídeo intentará alcanzar un equilibrio entre la reducción de la resolución y la velocidad de fotogramas cuando sea necesario.

Getting the current degradation preference

Para recuperar la preferencia de degradación del editor actualmente configurada, utilice otc_publisher_get_degradation_preference:

otc_degradation_preference preference = otc_publisher_get_degradation_preference(publisher);

Puede hacer que el editor deje de transmitir a la sesión desmontándolo (eliminándolo del componente OTSession padre). Por ejemplo, el siguiente código detiene la publicación de un flujo después de 30 segundos:

import React, {Component} from 'react';
import {View} from 'react-native';
import {OTSession, OTPublisher} from 'opentok-react-native';

class App extends Component {
  constructor(props) {
    super(props);
    this.apiKey = 'your-api-key';
    this.sessionId = 'valid-session-id';
    this.token = 'valid-token';
    this.publisherOptions = {
      publishCaptions: true,
      publishVideo: true,
      publishAudio: false,
    };
    this.state = {
      publishing: true,
    };
    this.publisherEventHandlers = {
      streamCreated: event => {
        setTimeout(
          function () {
            console.log(10);
            this.setState({publishing: false});
          }.bind(this),
          10000,
        );
      },
    };
  }

  render() {
    return (
      <View>
        <OTSession
          applicationId={this.apiKey}
          sessionId={this.sessionId}
          token={this.token}
          {this.state.publishing ? (
            <OTPublisher
              eventHandlers={this.publisherEventHandlers}
              ref={instance => {
                this.publisher = instance;
              }}
            />
          ) : null}
        </OTSession>
      </View>
    );
  }
}

export default App;

Detectar cuándo un flujo publicado abandona una sesión

El objeto OTPublisher envía un streamDestroyed cuando deja de transmitir a la sesión:

<OTPublisher
  eventHandlers={{
    streamDestroyed: function() {
      console.log('The publisher stopped streaming.');
    },
  }}
/>

Para detener a un editor, llama al unpublish() del objeto Session:

session.unpublish(publisher);

Tenga en cuenta que puede detener individualmente el envío de vídeo o audio (sin dejar de publicar).

Para más información, consulte Ajustar el audio y el vídeo.

Detectar cuándo un flujo publicado abandona una sesión

El objeto Publisher envía un streamDestroyed cuando deja de transmitir a la sesión:

var publisher = OT.initPublisher();
session.publish(publisher);
publisher.on("streamDestroyed", function (event) {
    console.log("The publisher stopped streaming. Reason: "
    + event.reason);
});

El streamDestroyed El evento viene definido por la clase StreamEvent. El evento incluye un reason que detalla por qué ha finalizado el flujo. Estas razones incluyen "clientDisconnected", "forceDisconnected", "forceUnpublished", o "networkDisconnected". Para más detalles, véase StreamEvent.

Por defecto, cuando un editor envía el comando streamDestroyed el editor se destruye y se elimina del DOM HTML. Puede evitar este comportamiento por defecto llamando a la función preventDefault() del objeto StreamEvent:

publisher.on("streamDestroyed", function (event) {
    event.preventDefault();
    console.log("The publisher stopped streaming.");
});

Es posible que desee evitar el comportamiento predeterminado y conservar el Editor si desea reutilizar el objeto Editor para publicar de nuevo en la sesión.

La editorial también envía un destroyed evento que se produce cuando el objeto se ha eliminado del DOM HTML. En respuesta a este evento, puedes optar por modificar (o eliminar) los elementos del DOM relacionados con el editor que se ha eliminado.

Para detener a un editor, llama al unpublish(PublisherKit publisher) del objeto Session:

mSession.unpublish(mPublisher);

El PublisherKit.PublisherListener.onStreamDestroyed(PublisherKit publisher, Stream stream) cuando el editor deja de transmitir a la sesión:

@Override
public void onStreamDestroyed(publisher, stream) {
    // The publisher stopped streaming.
}

Para detener a un editor, llama al OTSession unpublish(_:error:) método del objeto OTSession:

var error: OTError?
session.unpublish(publisher, error: &error)

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

El OTPublisherDelegate publisher(_:streamDestroyed:) Se envía este mensaje cuando el editor deja de transmitir datos a la sesión. Cuando se envíe este mensaje, elimina la vista del editor de su vista superior:

publisher.view?.removeFromSuperview();

Para detener a un editor, llama al [OTSession unpublish:error:] método del objeto OTSession:

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

El [OTPublisherDelegate publisher:streamDestroyed:] Se envía este mensaje cuando el editor deja de transmitir datos a la sesión. Cuando se envíe este mensaje, elimina la vista del editor de su vista superior:

[publisher.view removeFromSuperview:];

Para detener a un editor, llama al Unpublish(publisher) del objeto Session:

session.unpublish(mPublisher);

El Publisher envía el StreamCreated cuando el editor comienza a transmitir a la sesión:

publisher.StreamCreated += Publisher_StreamDestroyed;
session.Publish(publisher);
private void Publisher_StreamDestroyed(object sender, Publisher.StreamEventArgs e)
{
    Console.WriteLine("The publisher stopped streaming.");
}

Llame al otc_session_unpublish() pasando la función otc_session y otc_publisher structs:

otc_status status = otc_session_unpublish(session, publisher);
  if (status == OTC_SUCCESS) {
  printf("Unpublished successfully.");
} else {
  printf("Could not unpublish.");
}