Publicar: Noções básicas

O OT.initPublisher() O método inicializa e retorna um objeto Publisher. O objeto Publisher representa a visualização de um vídeo que você publica:

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

O OT.initPublisher() O método recebe três parâmetros:

• targetElement— (Opcional) Define o elemento DOM que o vídeo do Publisher substitui.

• properties— (Opcional) Um conjunto de propriedades que personalizam o Publisher. O properties O parâmetro também inclui opções para especificar um dispositivo de entrada de áudio e vídeo utilizado pelo editor. O properties Esse parâmetro também inclui opções para personalizar a aparência da visualização na página HTML (consulte Personalização da interface do usuário) e selecione se deseja publicar áudio e vídeo (consulte Publicação apenas de áudio ou vídeo). Para mais opções de editor, consulte a documentação do properties parâmetro do OT.initPublisher() método.

• completionHandler— (Opcional) Um manipulador de conclusão que especifica se o editor foi instanciado com sucesso ou se ocorreu um erro.

Você pode passar esse objeto Publisher para o Session.publish() método para publicar um fluxo em uma sessão.

Antes de ligar Session.publish(), você pode usar esse objeto Publisher para testar o microfone e a câmera conectados ao Publisher.

O insertMode propriedade do properties parâmetro do OT.initPublisher() 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 Publisher substitui o conteúdo do targetElement. Essa é a configuração padrão.
• "after" — O objeto Publisher é um novo elemento inserido após o targetElement no DOM HTML. (Tanto o Publisher quanto o targetElement têm o mesmo elemento pai.)
• "before" — O objeto Publisher é um novo elemento inserido antes do targetElement no DOM HTML. (Tanto o Publisher quanto o targetElement têm o mesmo elemento pai.)
• "append" — O objeto Publisher é 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 Publisher como filho de um 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 um editor básico, use o Publisher.Builder classe para instanciar um objeto Publisher. Passe o contexto do aplicativo Android para o publisher:

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

Adicione um objeto ouvinte para eventos básicos relacionados ao editor chamando o setPublisherListener(PublisherKit.PublisherListener listener) método do objeto Publisher:

mPublisher.setPublisherListener(this);

Implemente os métodos da interface PublisherKit.PublisherListener no objeto que você especificar como objeto ouvinte de eventos. Esses métodos são chamados quando ocorrem eventos relacionados ao editor.

O getView() O método do objeto Publisher retorna a visualização do vídeo que você publica. Adicione-a como uma subvisualização de um objeto android.view.ViewGroup para exibi-la no aplicativo:

mPublisherViewContainer.addView(mPublisher.getView());

Passe o objeto Publisher para o Session.publish() método para publicar um fluxo em uma sessão.

Você pode chamar outros métodos do objeto Publisher.Builder para definir configurações personalizadas para o editor:

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

Observe que, nas sessões que utilizam o Vonage Video Media Router (sessões com o modo de mídia (configurado como “routed”), reduzir a taxa de quadros diminui proporcionalmente a largura de banda utilizada pela transmissão. No entanto, em sessões em que o modo de mídia está configurado como “relayed”, reduzir a taxa de quadros não diminui a largura de banda da transmissão.

Utilizando um capturador de vídeo personalizado

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada. Você também pode usar o capturador de vídeo personalizado para publicar uma transmissão de compartilhamento de tela.

Compartilhamento de tela.

Você também pode usar uma fonte de áudio personalizada para a transmissão publicada — consulte Utilização de um driver de áudio personalizado.

Use o OTPublisher objeto para criar um editor. O view A propriedade do objeto contém a visualização do vídeo que você publica:

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

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

Passe o objeto Publisher para o OTSession publish(_:error:) método para publicar um fluxo em uma sessão.

É possível definir outras propriedades do objeto OTPublisherSettings para configurar opções personalizadas para o 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)!

Observe que, nas sessões que utilizam o Vonage Video Media Router (sessões com o modo de mídia (configurado como “routed”), reduzir a taxa de quadros diminui proporcionalmente a largura de banda utilizada pela transmissão. No entanto, em sessões em que o modo de mídia está configurado como “relayed”, reduzir a taxa de quadros não diminui a largura de banda da transmissão.

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada — consulte Utilizando um capturador de vídeo personalizado. Você também pode usar o capturador de vídeo personalizado para publicar uma transmissão de compartilhamento de tela — consulte Compartilhamento de tela.

Você também pode usar uma fonte de áudio personalizada para a transmissão publicada — consulte Utilização de um driver de áudio personalizado.

Use o OTPublisher objeto para criar um editor. O view A propriedade do objeto contém a visualização do vídeo que você publica:

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

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

Passe o objeto Publisher para o [OTSession publish:error] método para publicar um fluxo em uma sessão.

É possível definir outras propriedades do objeto OTPublisherSettings para configurar opções personalizadas para o 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];

Observe que, nas sessões que utilizam o Vonage Video Media Router (sessões com o modo de mídia (configurado como “routed”), reduzir a taxa de quadros diminui proporcionalmente a largura de banda utilizada pela transmissão. No entanto, em sessões em que o modo de mídia está configurado como “relayed”, reduzir a taxa de quadros não diminui a largura de banda da transmissão.

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada — consulte Utilizando um capturador de vídeo personalizado.

Você também pode usar o capturador de vídeo personalizado para publicar uma transmissão de compartilhamento de tela — consulte Compartilhamento de tela.

Você também pode usar uma fonte de áudio personalizada para a transmissão publicada — consulte Utilização de um driver de áudio personalizado.

É possível criar um Publisher básico chamando a função Publisher() construtor, passando a instância do aplicativo do 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);
}

Passe o objeto Publisher para o Session.publish() método para publicar um fluxo em uma sessão.

Por padrão, o Publisher utiliza o capturador de vídeo padrão, que usa o microfone e a câmera padrão do sistema como fontes de áudio e vídeo para a transmissão publicada. Isso é definido pelo VideoCapturer no SDK de vídeo da Vonage.

É possível definir um objeto de captura de vídeo específico para o editor utilizar. Esse objeto captura vídeo de uma fonte de vídeo (como uma câmera) e possui configurações para o vídeo (como a taxa de quadros e a resolução).

Você pode usar o VideoCapturer.EnumerateDevices() método para enumerar dispositivos de captura de vídeo (câmeras) no sistema. Ele retorna uma lista de objetos VideoDevice. A classe VideoDevice inclui vários CreateVideoCapturer() métodos para instanciar um objeto VideoCapturer que utilize o dispositivo de vídeo:

• VideoCapturer.CreateVideoCapturer(format) — Cria um objeto VideoCapturer usando as configurações definidas por um objeto VideoFormat.
• VideoCapturer.CreateVideoCapturer(width, height, fps) — Cria um objeto VideoCapturer com a resolução definida pelo width e height parâmetros e com a taxa de quadros definida pelo fps parâmetro.
• VideoCapturer.CreateVideoCapturer(resolution, fps) — Cria um objeto VideoCapturer com a resolução definida pelo resolution parâmetro e com a taxa de quadros definida pelo fps parâmetro. O OpenTok.VideoCapturer.Resolution A enum define os valores utilizados pela resolution parâmetro: Low (320 x 240 pixels), Medium (640 x 480 pixels), e High (1280 x 720 pixels), e High 1080p (1920 x 1080 pixels).

O capturador de vídeo utiliza a resolução suportada pelo sistema que for mais próxima da resolução especificada por você.

Por padrão, os desenvolvedores utilizam um renderizador de vídeo padrão para o Windows Presentation Foundation, definido pela classe VideoRenderer no SDK do Vonage Video para Windows. Você também pode especificar um renderizador para o vídeo criando uma classe que implemente a interface IVideoRenderer. É possível usar um renderizador de vídeo personalizado — consulte Utilizando um renderizador de vídeo personalizado.

O código a seguir cria um Publisher que utiliza o capturador de vídeo padrão do sistema, com a resolução definida como 720p (VideoCapturer.Resolution.High) e a taxa de quadros definida em 30 quadros 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);
}

Observação: Em sessões que utilizam o Vonage Video Media Router (sessões com o modo de mídia (configurado como “routed”), reduzir a taxa de quadros diminui proporcionalmente a largura de banda utilizada pela transmissão. No entanto, em sessões em que o modo de mídia está configurado como “relayed”, reduzir a taxa de quadros não diminui a largura de banda da transmissão.

Você passa outros parâmetros opcionais da função Publisher() construtor para definir configurações personalizadas para o stream publicado:

• name — O nome do vídeo do editor. O Stream.Name A propriedade de um stream publicado por esse editor será definida com esse valor (em todos os clientes).
• hasAudioTrack — Se deve incluir uma faixa de áudio na transmissão publicada. O padrão é true.
• hasVideoTrack — Se deve incluir uma faixa de áudio na transmissão publicada. O padrão é true.
• stereo — Se o áudio estéreo deve ser ativado na transmissão publicada. O padrão é false. Defina isso como true para transmitir o áudio de um microfone estéreo.

Você também pode alterar a fonte de áudio utilizada pelo editor. Ou você pode criar um driver de áudio personalizado para ser utilizado por todos os editores e assinantes.

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada — consulte Utilizando um capturador de vídeo personalizado.

Você também pode usar o capturador de vídeo personalizado para publicar uma transmissão de compartilhamento de tela — consulte Compartilhamento de tela.

Observação: A classe OpenTok.Publisher e a classe OpenTok.VideoCapturer implementam a interface System.IDisposable. Certifique-se de chamar o Dispose() método desses objetos para liberar seus recursos quando você não precisar mais deles (por exemplo, quando o Publisher for removido ou quando o aplicativo ou a janela estiver sendo fechado).

Comece criando uma estrutura do 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;

Use o user_data membro do otc_publisher_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 uma matriz de caracteres. Mas poderia ser um ponteiro para uma instância de algum outro tipo que contenha informações relevantes.

Os demais membros do otc_publisher_callbacks A estrutura é composta por funções de retorno de chamada que são invocadas quando ocorrem eventos relacionados ao fluxo publicado:

• on_stream_created — É chamado quando o editor inicia a transmissão para a sessão.
• on_render_frame — É chamado sempre que o publisher estiver pronto para renderizar um novo quadro de vídeo na transmissão.
• on_stream_destroyed — É chamado quando o fluxo do publisher é destruído.
• on_error — É chamado quando ocorre um erro na publicação do fluxo.

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_publisher_callbacks Consulte a documentação de referência do SDK do OpenTok para Linux para obter detalhes sobre cada uma das funções de retorno de chamada.

Ligue para o otc_publisher_new() para criar um otc_publisher estrutura, que representa o editor do 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;
}

O otc_publisher_new() O método recebe três argumentos:

• name — Um nome (opcional) que identifica o emissor da transmissão.
• capturer — Use este parâmetro se desejar especificar um capturador de vídeo personalizado. Se estiver definido como NULL, o editor utiliza a câmera padrão do sistema como fonte de vídeo.

Veja Utilizando um capturador de vídeo personalizado para saber como implementar um capturador de vídeo personalizado.

• callbacks — O otc_publisher_callbacks estrutura de callback do editor, descrita acima.

Criar um driver de áudio personalizado para ser utilizado por todos os editores e assinantes.

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada — consulte Utilizando um capturador de vídeo personalizado.

Para publicar um stream, adicione um componente OTPublisher como filho do objeto OTSession:

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

O publisher inicia a transmissão quando o cliente se conecta à sessão. O objeto OTPublisher despacha um streamCreated evento quando começa a transmitir para a sessão. Ele dispara um error mesmo que haja um error publicação. Defina um eventHandlers propriedade do componente OTPublisher e defina o streamCreated e error propriedades desse objeto para as funções de retorno de chamada:

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

Passe o objeto publisher para o publish() método de um objeto Session para publicar um fluxo na sessão:

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

O segundo parâmetro é uma função de manipulador de conclusão à qual é passado um objeto de erro caso a publicação falhe. Caso contrário, a função de manipulador de conclusão é chamada sem que nenhum erro seja passado a ela.

Este código pressupõe que session é um objeto Session e que o cliente se conectou à sessão. Para obter mais informações, consulte Participar de uma sessão.

O objeto Publish dispara um streamCreated evento quando a transmissão para a sessão é iniciada:

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

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

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário está se conectando por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Passe o objeto publisher para o publish(PublisherKit publisher) método de um objeto Session para publicar o fluxo na sessão:

mSession.publish(mPublisher);

Este código pressupõe que mSession é um objeto Session e que o cliente se conectou à sessão. Para obter mais informações, consulte Participar de uma sessão.

O PublisherKit.PublisherListener.onStreamCreated(PublisherKit publisher, Stream stream) O método é chamado quando o editor inicia a transmissão para a sessão:

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

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário está se conectando por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Passe o objeto publisher para o OTSession publish(_:error:) método de um objeto OTSession para publicar o fluxo na sessão:

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

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

Este código pressupõe que session é um objeto Session e que o cliente se conectou à sessão. Para obter mais informações, consulte Participar de uma sessão.

O OTPublisherDelegate publisher(_:streamCreated:) A mensagem é enviada quando o editor começa a transmitir para a sessão.

Passe o objeto publisher para o [OTSession publish:error] método de um objeto OTSession para publicar o fluxo na sessão:

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

Este código pressupõe que session é um objeto Session e que o cliente se conectou à sessão. Para obter mais informações, consulte Criação de uma sessão.

O [OTPublisherDelegate publisher:streamCreated:] A mensagem é enviada quando o editor começa a transmitir para a sessão.

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário está se conectando por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Passe o objeto publisher para o Publish(publisher) método de um objeto Session para publicar o fluxo na sessão:

session.Publish(publisher);

Este código pressupõe que session é um objeto Session, que publisher é um objeto Publisher e que o cliente se conectou à sessão. Para obter mais informações, consulte Participar de uma sessão.

O Publisher envia o StreamCreated evento que ocorre quando o editor inicia a transmissão para a sessão:

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

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário está se conectando por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Quando o aplicativo se conecta a uma sessão, o on_connected() função de retorno de chamada do otc_session_callbacks a estrutura é chamada (ver Participar de uma sessão). Em resposta a isso, você pode chamar o otc_session_publish() função para publicar um stream na sessão do OpenTok:

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

O otc_session_publish() A função recebe dois argumentos:

• O ponteiro para o otc_session estrutura.
• O otc_publisher estrutura.

Isso retorna OTC_SUCCESS quando consegue iniciar a publicação de um fluxo na sessão. Ou então retorna um erro, e o otc_error a função de retorno de chamada é chamada.

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário está se conectando por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Setting the degradation preference

Você pode definir esse valor usando qualquer uma das opções fornecidas DegradationPreference valores:

• DegradationPreference.NotSet: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

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

• DegradationPreference.MaintainFrameRateAndResolution: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

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

• DegradationPreference.MaintainFrameRate: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

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

• DegradationPreference.MaintainResolution: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

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

• DegradationPreference.Balanced: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

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

Setting the degradation preference

Para definir a preferência de redução de qualidade do editor, use publisher.setDegradationPreference com qualquer uma das opções disponíveis oferecidas em DegradationPreference:

publisher.setDegradationPreference(DegradationPreference.DegradationPreferenceMaintainResolution);

O seguinte DegradationPreference Estão disponíveis os seguintes valores:

• DegradationPreferenceNotSet: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

• DegradationPreferenceMaintainFrameRateAndResolution: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

• DegradationPreferenceMaintainFrameRate: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

• DegradationPreferenceMaintainResolution: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

• DegradationPreferenceBalanced: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

Getting the current degradation preference

Para recuperar a preferência de degradação do editor configurada no momento, use publisher.getDegradationPreference:

DegradationPreference preference = publisher.getDegradationPreference();

Setting the degradation preference

Para definir a preferência de redução de qualidade do editor, defina publisher.degradationPreference propriedade a qualquer uma das opções disponíveis oferecidas em OTDegradationPreference:

publisher.degradationPreference = .maintainResolution

O seguinte OTDegradationPreference Estão disponíveis os seguintes valores:

• notSet: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

• maintainFrameRateAndResolution: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

• maintainFrameRate: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

• maintainResolution: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

• balanced: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

Getting the current degradation preference

Para obter a preferência de degradação do editor configurada no momento, consulte publisher.degradationPreference propriedade:

let preference = publisher.degradationPreference;

Setting the degradation preference

Para definir a preferência de redução de qualidade do editor, defina publisher.degradationPreference propriedade a qualquer uma das opções disponíveis oferecidas em OTDegradationPreference:

publisher.degradationPreference = OTDegradationPreferenceMaintainResolution;

O seguinte OTDegradationPreference Estão disponíveis os seguintes valores:

• OTDegradationPreferenceNotSet: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

• OTDegradationPreferenceMaintainFrameRateAndResolution: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

• OTDegradationPreferenceMaintainFrameRate: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

• OTDegradationPreferenceMaintainResolution: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

• OTDegradationPreferenceBalanced: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

Getting the current degradation preference

Para obter a preferência de degradação do editor configurada no momento, consulte publisher.degradationPreference propriedade:

OTDegradationPreference preference = publisher.degradationPreference;

Setting the degradation preference

Para definir a preferência de redução de qualidade do editor, defina publisher.DegradationPreference propriedade a qualquer uma das opções disponíveis oferecidas em DegradationPreference:

publisher.DegradationPreference = DegradationPreference.MaintainResolution;

O seguinte DegradationPreference Estão disponíveis os seguintes valores:

• NotSet: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

• MaintainFrameRateAndResolution: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

• MaintainFrameRate: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

• MaintainResolution: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

• Balanced: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

Getting the current degradation preference

Para obter a preferência de degradação do editor configurada no momento, consulte publisher.DegradationPreference propriedade:

DegradationPreference preference = publisher.DegradationPreference;

Setting the degradation preference

Para definir a preferência de redução de qualidade do editor, use otc_publisher_set_degradation_preference com qualquer uma das opções disponíveis oferecidas em otc_degradation_preference:

otc_publisher_set_degradation_preference(publisher, OTC_DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION);

O seguinte otc_degradation_preference Estão disponíveis os seguintes valores:

• OTC_DEGRADATION_PREFERENCE_NOT_SET: O valor padrão. O mecanismo de vídeo determinará a preferência ideal de redução de qualidade.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION: O motor de vídeo tentará manter a taxa de quadros estável e não reduzir a resolução.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE: O motor de vídeo tentará manter a taxa de quadros estável, mas poderá reduzir a resolução, se necessário.

• OTC_DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION: O motor de vídeo não reduzirá a resolução, mas poderá reduzir a taxa de quadros, se necessário.

• OTC_DEGRADATION_PREFERENCE_BALANCED: O motor de vídeo tentará encontrar um equilíbrio entre a redução da resolução e da taxa de quadros, quando necessário.

Getting the current degradation preference

Para recuperar a preferência de degradação do editor configurada no momento, use otc_publisher_get_degradation_preference:

otc_degradation_preference preference = otc_publisher_get_degradation_preference(publisher);

É possível impedir que o publisher transmita para a sessão desmontando-o (removendo-o do componente OTSession pai). Por exemplo, o código a seguir interrompe a publicação de um stream após 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 quando um stream publicado sai de uma sessão

O objeto OTPublisher dispara um streamDestroyed evento quando a transmissão para a sessão é interrompida:

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

Para interromper um editor, chame a função unpublish() método do objeto Session:

session.unpublish(publisher);

Observe que é possível interromper individualmente o envio de vídeo ou áudio (mesmo continuando a publicar).

Para obter mais informações, consulte Ajustando o áudio e o vídeo.

Detectar quando um stream publicado sai de uma sessão

O objeto Publisher dispacha um streamDestroyed evento quando a transmissão para a sessão é interrompida:

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

O streamDestroyed O evento é definido pela classe StreamEvent. O evento inclui um reason propriedade, que explica por que a transmissão foi encerrada. Esses motivos incluem "clientDisconnected", "forceDisconnected", "forceUnpublished", ou "networkDisconnected". Para mais detalhes, consulte StreamEvent.

Por padrão, quando um Publisher despacha o streamDestroyed evento, o Publisher é destruído e removido do DOM HTML. É possível impedir esse comportamento padrão chamando o preventDefault() método do objeto StreamEvent:

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

Talvez você queira impedir o comportamento padrão e manter o Publisher, caso deseje reutilizar o objeto Publisher para publicar novamente na sessão.

A editora também envia um destroyed evento que ocorre quando o objeto é removido do DOM HTML. Em resposta a esse evento, você pode optar por ajustar (ou remover) os elementos do DOM relacionados ao editor que foi removido.

Para interromper um editor, chame a função unpublish(PublisherKit publisher) método do objeto Session:

mSession.unpublish(mPublisher);

O PublisherKit.PublisherListener.onStreamDestroyed(PublisherKit publisher, Stream stream) O método é chamado quando o editor interrompe a transmissão para a sessão:

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

Para interromper um editor, chame a função OTSession unpublish(_:error:) método do objeto OTSession:

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

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

O OTPublisherDelegate publisher(_:streamDestroyed:) A mensagem é enviada quando o editor interrompe a transmissão para a sessão. Quando essa mensagem for enviada, remova a visualização do editor de sua supervisualização:

publisher.view?.removeFromSuperview();

Para interromper um editor, chame a função [OTSession unpublish:error:] método do objeto OTSession:

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

O [OTPublisherDelegate publisher:streamDestroyed:] A mensagem é enviada quando o editor interrompe a transmissão para a sessão. Quando essa mensagem for enviada, remova a visualização do editor de sua supervisualização:

[publisher.view removeFromSuperview:];

Para interromper um editor, chame a função Unpublish(publisher) método do objeto Session:

session.unpublish(mPublisher);

O Publisher envia o StreamCreated evento que ocorre quando o editor inicia a transmissão para a sessão:

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

Ligue para o otc_session_unpublish() função, passando o otc_session e otc_publisher estruturas:

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