Legendas em tempo real

Use o API de legendas em tempo real para permitir a legenda em áudio em tempo real dos editores e assinantes conectados a uma sessão.

A legenda em tempo real deve ser ativada no nível da sessão por meio do API REST.

A legenda em tempo real é compatível apenas em sessão encaminhada.

Publishing live captions

<OTPublisher
  style={{width: 400, height: 300}}
  properties={{
    publishCaptions: true,
    // ... other properties
  }}
/>

Essa configuração é false por padrão.

Você pode alterar dinamicamente essa propriedade (com base em uma mudança no estado do React) para ativar ou desativar as legendas da transmissão publicada.

Subscribing to live captions

<OTSubscriber
  style={{width: 200, height: 200}}
  properties={{
    subscribeToCaptions: true,
    // ... other properties
  }}
  eventHandlers={{
    captionReceived: event => {
      console.log('Caption received:', event.text);
      console.log('Caption final:', event.isFinal);
    },
  }}
/>

Você pode definir o subscribeToCaptions propriedade para true independentemente de o cliente que está transmitindo o stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor iniciar a publicação das legendas.

Os assinantes recebem legendas por meio do captionReceived manipulador de eventos (mostrado acima).

O objeto do evento `captionReceived` possui dois properties:

• texto — O texto da legenda (uma sequência de caracteres)
• isFinal — Se o texto da legenda é definitivo para uma frase (true) ou parcial (falso). O SDK do React Native não exibe o texto dos eventos de legendas. Você pode criar seu próprio elemento de interface do usuário para renderizar o texto das legendas com base nos eventos de legendas.

Como receber suas próprias legendas em tempo real

O Client SDK do cliente web da Vonage não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir legendas de uma transmissão publicada pelo cliente local, crie um assinante oculto (da transmissão do emissor local) para monitorar os eventos de legenda. Defina a propriedade `subscribeToSelf` do OTSubscriber para true. Você não deve renderizar o vídeo desse assinante (definindo seu width e height para 0) e você não deve se inscrever para receber áudio (para evitar eco, configurando subscribeToAudio para falso).

Você pode adicionar as legendas à interface do usuário, da mesma forma que faria com as legendas de outras transmissões. Consulte Exibição personalizada dos assinantes.

Enabling live captions

Um publisher pode ser inicializado com o valor booleano opcional publishCaptions parâmetro. O parâmetro é passado por meio do properties objeto. Esse parâmetro terá o valor “false” por padrão.

const publisher = OT.initPublisher({ publishCaptions: true });

Toggling live captions for a publisher dynamically

Depois que as legendas em tempo real forem ativadas, um editor poderá iniciar ou interromper o envio de legendas chamando a função publishCaptions método. Esse método aceita um valor booleano como parâmetro.

O código abaixo mostra um exemplo de como interromper as legendas em tempo real para um editor.

publisher.publishCaptions(false);

O código abaixo mostra um exemplo de como ativar legendas em tempo real para um editor.

publisher.publishCaptions(true);

Subscribing to live captions

Um assinante pode optar por começar ou interromper o recebimento de legendas em tempo real.

Subscriber subscribeToCaptions Method

Um assinante pode ativar ou desativar o recebimento de legendas ligando para o serviço assíncrono subscribeToCaptions método. Esse método aceita um valor booleano como parâmetro.

O método pode ser chamado independentemente de o emissor estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor iniciar a publicação das legendas.

O código abaixo mostra um exemplo de como ativar legendas em tempo real para um assinante.

try {
    await subscriber.subscribeToCaptions(true);
} catch (err) {
    console.warn(err);
}

O código abaixo mostra um exemplo de como interromper as legendas em tempo real para um assinante.

try {
    await subscriber.subscribeToCaptions(false);
} catch (err) {
    console.warn(err);
}

Enabling live captions for a subscriber

Os assinantes podem verificar se estão ativamente inscritos nas legendas ao vivo de um canal usando o isSubscribedToCaptions método. Esse método não possui parâmetros e retorna um valor booleano

const isSubscribed = subscriber.isSubscribedToCaptions()
console.log(`${isSubscribed} states whether or not a given subscriber is subscribing to live captions`).

Receiving live captions

Os assinantes recebem legendas por meio de eventos. O SDK não exibe o texto dos eventos de legenda.

Subscriber captionReceived Event

Um assinante que esteja ativamente inscrito no serviço de legendas ao vivo enviará captionReceived eventos. O captionReceived O objeto `event` possui três propriedades: caption, streamId, e isFinal. streamId é o ID do fluxo, enquanto caption é o texto transcrito. isFinal indica se a transcrição de uma legenda foi concluída. Esse valor só é relevante ao se utilizar legendas parciais. O desenvolvedor pode escolher como e onde exibir o texto da legenda.

subscriber.on('captionReceived', function(event){
    console.log(`Caption received for stream ${event.streamId}`);
    console.log(`Caption text: ${event.caption}`);
    console.log(`Final text: ${event.isFinal}`);
})

A seguir, são apresentados os registros do console ao usar legendas parciais e quando um locutor diz “Esta é a minha frase.”

subscriber.on('captionReceived', function(event){
    console.log(`The ${event.isFinal ? 'complete' : 'partial'} caption text is: "${event.caption}"`)
})
// The partial caption text is: "This"
// The partial caption text is: "This is"
// The partial caption text is: "This is my" 
// The complete caption text is: "This is my sentence"

Receiving your own live captions

O Client SDK do cliente web da Vonage não permite que um editor receba eventos relativos às suas próprias legendas. Para exibir as próprias legendas do locutor, crie um assinante oculto (no fluxo do editor local) para monitorar os eventos de legenda. Esse assinante não deve estar vinculado ao DOM nem assinar o áudio, a fim de evitar eco. Você pode então adicionar as legendas à interface do usuário.

A seguir, é mostrada a criação de um assinante oculto para que o editor receba suas próprias legendas.

const captionOnlySub = session.subscribe(
    publisher.stream,
    document.createElement('div'),
    {
    audioVolume: 0,
    testNetwork: true, // This option is only needed in OpenTok.js versions below 2.25.1
    },
);

captionOnlySub.on('captionReceived', (event) => {
    // Do something with the event.caption
});

Observação: Para o OpenTok.js 2.25.0 e versões anteriores, é necessário definir testNetwork para true nas opções passadas para Session.subscribe(), devido a um bug.

Sample

O Amostra de legendas do Basic da Vonage Web-Samples utiliza legendas em tempo real em um aplicativo web desenvolvido com o Vonage Client SDK.

Publishing live captions

Um editor pode iniciar ou interromper a exibição de legendas ao vivo em tempo real chamando a função setPublishCaptions() método do objeto PublisherKit:

publisher.setPublishCaptions(true);

Se a editora não incluir uma faixa de áudio, o PublisherKit.PublisherListener.onError() o método é chamado com um erro (com o code propriedade do conjunto de erros definida como PublisherMissingAudioTrack).

O SDK do Android não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas ligando para o subscribeToCaptions() método do objeto SubscriberKit:

subscriber.setSubscribeToCaptions(true);

Você pode chamar esse método independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, passe false no método:

subscriber.setSubscribeToCaptions(false);

Os assinantes podem verificar se estão ativamente inscritos nas legendas ao vivo de uma transmissão usando o isSubscribedToCaptions() método:

boolean isSubscribed = subscriber.getSubscribeToCaptions();

Os assinantes recebem legendas por meio de eventos. O SDK não exibe o texto das legendas na interface do usuário. Use o SubscriberKit.CaptionsListener interface para configurar um ouvinte para eventos de legendas:

SubscriberKit.CaptionsListener captionsListener = new SubscriberKit.CaptionsListener() {
    @Override
    public void onCaptionText(SubscriberKit subscriber, String text, boolean isFinal) {
        // Display the text in the UI.
    }
}

O hasCaptions() O método de um objeto Stream informa se o stream possui legendas:

boolean hasCaptions = stream.hasCaptions();

Implementar o onStreamHasCaptionsChanged() método do Session.StreamPropertiesListener interface para monitorar quando as legendas de uma transmissão estão ativadas ou desativadas:

Session.StreamPropertiesListener captioningListener = new Session.StreamPropertiesListener() {
    @Override
    public void onStreamHasCaptionsChanged(Session session, Stream stream, boolean hasCaptions) {
        // Adjust UI to indicate that captions are or are not available.
    }
}

Publishing live captions

Uma emissora pode iniciar ou interromper a exibição de legendas ao vivo em tempo real configurando o publishCaptions propriedade do objeto OTPublisherKit:

publisher.publishCaptions = true

Se a editora não incluir uma faixa de áudio, o [PublisherKit publisher:didFailWithError:] a mensagem é enviada, com o code propriedade do conjunto de erros definida como OTPublisherMissingAudioTrack.

O SDK do Vonage para iOS não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas configurando o subscribeToCaptions propriedade do objeto OTSubscriberKit:

subscriber.subscribeToCaptions = true

Você pode chamar esse método independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, defina a propriedade como false:

subscriber.setSubscribeToCaptions = false

O OTSubscriberKitCaptionsDelegate(_:subscriber:caption:isFinal:) A mensagem é enviada quando um assinante de um stream recebe legendas:

// OTSubscriberKitDelegate callbacks:
func subscriber(_ subscriber: OTSubscriberKit, caption text: NSString, isFinal final: Bool) {
  // Display caption text in UI.
}

Você pode configurar um observador de chave-valor para o hasCaptions propriedade de um objeto OTStream para verificar quando as legendas do stream estão ativadas ou desativadas.

//add observer on a stream of interest
let hasCaptionsObservation: NSKeyValueObservation = subscriber.stream.observe(\.hasCaptions, options: [.old, .new]) { object, change in
	guard let oldValue = change.oldValue else { return }
	guard let newValue = change.newValue else { return }
	print("KVO change for \(subscriber.stream.streamId) hasCaptions: \(newValue)")
	//manipulate GUI element
}

Publishing live captions

Uma emissora pode iniciar ou interromper a exibição de legendas ao vivo em tempo real configurando o publishCaptions propriedade do objeto OTPublisherKit:

publisher.publishCaptions = YES;

Se a editora não incluir uma faixa de áudio, o [PublisherKit publisher:didFailWithError:] a mensagem é enviada, com o code propriedade do conjunto de erros definida como OTPublisherMissingAudioTrack.

O SDK do Vonage para iOS não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas configurando o subscribeToCaptions propriedade do objeto OTSubscriberKit:

subscriber.subscribeToCaptions = YES;

Você pode chamar esse método independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, defina a propriedade como NO:

subscriber.setSubscribeToCaptions = NO;

O [OTSubscriberKitCaptionsDelegate subscriber:caption:isFinal:] A mensagem é enviada quando um assinante de um stream recebe legendas:

// OTSubscriber delegate callbacks:
-(void) subscriber:(OTSubscriberKit *)subscriber caption:(NSString *)text isFinal:(BOOL)final {
    // Display caption text in UI.
}

Você pode configurar um observador de chave-valor para o hasCaptions propriedade de um OTStream para verificar quando as legendas do stream estão ativadas ou desativadas:

//add observer on a stream of interest
[_subscriber.stream addObserver:self forKeyPath:@"hasCaptions" options:NSKeyValueObservingOptionNew context:NULL];
    
- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context {
    NSLog(@"KVO change for %@ = %@",keyPath, change); 
    //manipulate GUI element
}

Publishing live captions

Uma emissora pode iniciar ou interromper a exibição de legendas ao vivo em tempo real configurando o PublishCaptions propriedade do objeto Publisher:

publisher.PublishCaptions = true;

Se a editora não incluir uma faixa de áudio, o PublisherKit.Error o evento é disparado, com o ErrorCode propriedade do objeto ErrorEventArgs definida como PublisherMissingAudioTrack.

O SDK do Vonage para Windows não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas configurando o SubscribeToCaptions propriedade do objeto Subscriber:

subscriber.SubscribeToCaptions = true;

Você pode definir essa propriedade independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, defina a propriedade como false:

subscriber.SubscribeToCaptions = false;

Os assinantes recebem legendas por meio de eventos. O SDK não exibe o texto das legendas na interface do usuário. Adicione um ouvinte de eventos para o Subscriber.CaptionText evento:

subscriber.CaptionText += (object sender, Subscriber.CaptionTextArgs e) =>
{
	// Display the text in the UI.
};

O HasCaptions A propriedade de um objeto Stream indica se o stream possui legendas:

stream.HasCaptions;

O Session.StreamHasCaptionsChanged O evento é disparado quando as legendas de uma transmissão são ativadas ou desativadas:

session.StreamHasCaptionsChanged += (object sender, StreamEventArgs e) =>
{
	// Adjust UI to indicate that captions are or are not available.
};

Publishing live captions

Um editor pode iniciar ou interromper a exibição de legendas ao vivo em tempo real chamando a função otc_publisher_set_publish_captions() função:

otc_publisher_set_publish_captions(publisher, OTC_FALSE);

Se a editora não incluir uma faixa de áudio, o otc_publisher_callbacks.on_error() A função de retorno de chamada é chamada com um erro, com o código de erro definido como OTC_PUBLISHER_MISSING_AUDIO_TRACK.

O SDK do Vonage para macOS não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas ligando para o otc_subscriber_set_subscribe_to_captions() função:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_TRUE);

Você pode chamar essa função independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, passe OTC_FALSE na função:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_FALSE);

Os assinantes podem verificar se estão ativamente inscritos nas legendas ao vivo de uma transmissão usando o otc_subscriber_get_subscribe_to_captions() função:

otc_bool isSubscribed = otc_subscriber_get_subscribe_to_captions(subscriber);

Os assinantes recebem legendas por meio de eventos. O SDK não exibe o texto das legendas na interface do usuário. Defina o on_caption_text() função de membro do otc_subscriber_callbacks exemplo para configurar um ouvinte para eventos de legendas:

static void on_caption_text(otc_subscriber *subscriber,
                                      void *user_data,
                                      const char* text) {
    // Display the text in the UI.
}

subscriber_callbacks.on_caption_text = on_caption_text;

O otc_stream_has_captions() A função verifica se um stream possui legendas:

otc_bool hasCaptions = otc_stream_has_captions(stream);

Implementar o on_stream_has_captions_changed() função de membro do otc_session_callbacks Exemplo para monitorar quando as legendas de uma transmissão estão ativadas ou desativadas:

static void on_stream_has_captions_changed(otc_session* session,
                                                   void *user_data,
                                             otc_stream *stream,
                                                  otc_bool has_captions) {
  // Adjust UI to indicate that captions are or are not available.
}

session_callbacks.on_stream_has_captions_changed = on_stream_has_captions_changed;

Publishing live captions

Uma emissora pode iniciar ou interromper a exibição de legendas ao vivo em tempo real chamando a função otc_publisher_set_publish_captions() função:

otc_publisher_set_publish_captions(publisher, OTC_FALSE);

Se a editora não incluir uma faixa de áudio, o otc_publisher_callbacks.on_error() A função de retorno de chamada é chamada com um erro, com o código de erro definido como OTC_PUBLISHER_MISSING_AUDIO_TRACK.

O SDK do Vonage Linus não permite que um emissor receba eventos relativos às suas próprias legendas. Para exibir as legendas do próprio locutor, crie um assinante oculto (no fluxo do emissor) para monitorar os eventos de legenda. (Consulte a próxima seção.)

Subscribing to live captions

Um assinante pode ativar ou desativar a exibição de legendas ligando para o otc_subscriber_set_subscribe_to_captions() função:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_TRUE);

Você pode chamar essa função independentemente de o emissor do stream estar ou não publicando legendas em tempo real no momento. O assinante começará a receber os dados das legendas assim que o emissor começar a publicar as legendas.

Para deixar de receber legendas, passe OTC_FALSE na função:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_FALSE);

Os assinantes podem verificar se estão ativamente inscritos nas legendas ao vivo de uma transmissão usando o otc_subscriber_get_subscribe_to_captions() função:

otc_bool isSubscribed = otc_subscriber_get_subscribe_to_captions(subscriber);

Os assinantes recebem legendas por meio de eventos. O SDK não exibe o texto das legendas na interface do usuário. Defina o on_caption_text() função de membro do otc_subscriber_callbacks exemplo para configurar um ouvinte para eventos de legendas:

static void on_caption_text(otc_subscriber *subscriber,
                                      void *user_data,
                                      const char* text) {
    // Display the text in the UI.
}

subscriber_callbacks.on_caption_text = on_caption_text;

O otc_stream_has_captions() A função verifica se um stream possui legendas:

otc_bool hasCaptions = otc_stream_has_captions(stream);

Implementar o on_stream_has_captions_changed() função de membro do otc_session_callbacks Exemplo para monitorar quando as legendas de uma transmissão estão ativadas ou desativadas:

static void on_stream_has_captions_changed(otc_session* session,
                                                   void *user_data,
                                             otc_stream *stream,
                                                  otc_bool has_captions) {
  // Adjust UI to indicate that captions are or are not available.
}

session_callbacks.on_stream_has_captions_changed = on_stream_has_captions_changed;