Live-Unterschriften

Verwenden Sie die Live-Untertitel API um die Echtzeit-Audiountertitelung der mit einer Sitzung verbundenen Herausgeber und Abonnenten zu ermöglichen.

Die Live-Untertitelung muss auf Sitzungsebene über die Option REST-API.

Live-Untertitelung wird nur unterstützt in weitergeleitete Sitzung.

Publishing live captions

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

Diese Einstellung ist false standardmäßig.

Sie können diese Eigenschaft dynamisch ändern (basierend auf einer React-Zustandsänderung), um die Beschriftungen für den veröffentlichten Stream ein- und auszuschalten.

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

Sie können die subscribeToCaptions Eigenschaft zu true unabhängig davon, ob der Client, der den Stream veröffentlicht, gerade Live-Untertitel veröffentlicht. Der Abonnent erhält die Untertiteldaten, sobald der Herausgeber mit der Veröffentlichung der Untertitel beginnt.

Die Abonnenten erhalten die Untertitel über die captionReceived Ereignishandler (siehe oben).

Das captionReceived-Ereignisobjekt hat zwei properties:

• Text - Der Text der Beschriftung (eine Zeichenkette)
• isFinal - ob der Überschriftentext für eine Phrase endgültig ist (true) oder teilweise (false). Das React Native SDK zeigt den Text der Beschriftungsereignisse nicht an. Sie können Ihr eigenes UI-Element erstellen, um den Beschriftungstext basierend auf Beschriftungsereignissen anzuzeigen.

Eigene Live-Titel empfangen

Das Vonage Client SDK unterstützt nicht, dass ein Publisher Ereignisse für seine eigenen Untertitel empfängt. Um Untertitel für einen vom lokalen Client veröffentlichten Stream zu rendern, erstellen Sie einen versteckten Abonnenten (für den Stream des lokalen Herausgebers), der auf die Untertitelereignisse wartet. Setzen Sie die Eigenschaft subscribeToSelf des OTSubscriber zu true. Sie sollten das Video dieses Abonnenten nicht wiedergeben (indem Sie seine width und height auf 0 setzen) und Sie sollten kein Audio abonnieren (um ein Echo zu vermeiden, setzen Sie subscribeToAudio auf false).

Sie können die Beschriftungen in die Benutzeroberfläche einfügen, wie Sie es auch bei anderen Streams tun würden. Siehe Benutzerdefiniertes Rendering von Abonnenten.

Enabling live captions

Ein Verleger kann mit dem optionalen booleschen Wert initialisiert werden publishCaptions Parameter. Der Parameter wird über die Funktion properties Objekt. Dieser Parameter ist standardmäßig auf false gesetzt.

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

Toggling live captions for a publisher dynamically

Nachdem Live-Untertitel aktiviert wurden, kann ein Herausgeber das Senden von Untertiteln starten oder beenden, indem er die Funktion publishCaptions Methode. Diese Methode akzeptiert einen booleschen Wert als Parameter.

Der folgende Code zeigt ein Beispiel für das Anhalten von Live-Beschriftungen für einen Verlag.

publisher.publishCaptions(false);

Der folgende Code zeigt ein Beispiel für den Start von Live-Beschriftungen für einen Verlag.

publisher.publishCaptions(true);

Subscribing to live captions

Ein Abonnent kann wählen, ob er Live-Untertitel empfangen möchte oder nicht.

Subscriber subscribeToCaptions Method

Ein Teilnehmer kann den Empfang von Untertiteln starten oder beenden, indem er die asynchrone subscribeToCaptions Methode. Diese Methode akzeptiert einen booleschen Wert als Parameter.

Die Methode kann unabhängig davon aufgerufen werden, ob der Herausgeber gerade Live-Untertitel veröffentlicht. Der Abonnent erhält die Untertiteldaten, sobald der Herausgeber mit der Veröffentlichung von Untertiteln beginnt.

Der folgende Code zeigt ein Beispiel für den Start von Live-Untertiteln für einen Abonnenten.

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

Der folgende Code zeigt ein Beispiel für das Anhalten von Live-Untertiteln für einen Teilnehmer.

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

Enabling live captions for a subscriber

Abonnenten können verifizieren, ob sie die Live-Untertitel eines Herausgebers aktiv abonniert haben, indem sie die isSubscribedToCaptions Methode. Diese Methode hat keine Parameter und gibt einen booleschen Wert zurück

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

Receiving live captions

Abonnenten erhalten Untertitel über Ereignisse. Das SDK zeigt den Text der Beschriftungsereignisse nicht an.

Subscriber captionReceived Event

Ein Abonnent, der aktiv Live-Untertitel abonniert hat, sendet captionReceived Veranstaltungen. Die Website captionReceived Ereignisobjekt hat drei Eigenschaften: caption, streamIdund isFinal. streamId ist die ID des Streams, während caption ist der transkribierte Text. isFinal zeigt an, ob die Transkription einer Beschriftung abgeschlossen ist. Dieser Wert ist nur bei der Verwendung von Teilbeschriftungen relevant. Der Entwickler kann wählen, wie und wo der Text der Beschriftung dargestellt werden soll.

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

Die folgende Abbildung zeigt die Konsolenprotokolle bei der Verwendung von Teiluntertiteln und der Aussage "Dies ist mein Satz" durch einen Herausgeber.

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

Das Vonage Client SDK unterstützt nicht den Empfang von Ereignissen für eigene Untertitel durch einen Publisher. Um die eigenen Beschriftungen des Sprechers wiederzugeben, erstellen Sie einen versteckten Abonnenten (für den Stream des lokalen Herausgebers), der auf die Beschriftungsereignisse wartet. Dieser Abonnent sollte nicht mit dem DOM verbunden sein und keine Audioereignisse abonnieren, um ein Echo zu vermeiden. Sie können die Untertitel dann in die Benutzeroberfläche einfügen.

Im Folgenden wird gezeigt, wie ein versteckter Abonnent für den Herausgeber erstellt wird, um seine eigenen Beschriftungen zu erhalten.

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

Anmerkung: Für OpenTok.js 2.25.0 und früher müssen Sie die testNetwork zu true in den Optionen, die an Session.subscribe()aufgrund eines Fehlers.

Sample

Die Vonage Web-Beispiele Basic-Captions Beispiel verwendet Live-Untertitel in einer mit dem Vonage Web Client SDK erstellten Webanwendung.

Publishing live captions

Ein Herausgeber kann die Veröffentlichung von Live-Untertiteln in Echtzeit starten oder stoppen, indem er die Funktion setPublishCaptions() Methode des PublisherKit-Objekts:

publisher.setPublishCaptions(true);

Wenn der Verlag keine Tonspur anbietet, wird die PublisherKit.PublisherListener.onError() Methode mit einem Fehler aufgerufen wird (mit der code Eigenschaft des Fehlers, die auf PublisherMissingAudioTrack).

Das Android SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Beschriftungen des Sprechers zu rendern, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Beschriftungsereignisse wartet. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Funktion subscribeToCaptions() Methode des SubscriberKit-Objekts:

subscriber.setSubscribeToCaptions(true);

Sie können diese Methode unabhängig davon aufrufen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um den Empfang von Untertiteln zu beenden, übergeben Sie false in die Methode:

subscriber.setSubscribeToCaptions(false);

Abonnenten können verifizieren, ob sie die Live-Untertitel eines Streams aktiv abonniert haben, indem sie die isSubscribedToCaptions() Methode:

boolean isSubscribed = subscriber.getSubscribeToCaptions();

Abonnenten erhalten Beschriftungen über Ereignisse. Das SDK zeigt den Text der Beschriftungen nicht in der Benutzeroberfläche an. Verwenden Sie die SubscriberKit.CaptionsListener Schnittstelle, um einen Listener für Untertitelereignisse einzurichten:

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

Die hasCaptions() Methode eines Stream-Objekts meldet, ob der Stream Untertitel hat:

boolean hasCaptions = stream.hasCaptions();

Umsetzung der onStreamHasCaptionsChanged() Methode der Session.StreamPropertiesListener Schnittstelle, um zu überwachen, wann ein Stream Untertitel aktiviert und deaktiviert hat:

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

Ein Herausgeber kann die Veröffentlichung von Live-Untertiteln in Echtzeit starten oder stoppen, indem er die Option publishCaptions Eigenschaft des OTPublisherKit-Objekts:

publisher.publishCaptions = true

Wenn der Verlag keine Tonspur anbietet, wird die [PublisherKit publisher:didFailWithError:] Nachricht gesendet wird, mit der code Eigenschaft des Fehlers, die auf OTPublisherMissingAudioTrack.

Das Vonage iOS SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Beschriftungen des Sprechers wiederzugeben, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Beschriftungsereignisse hört. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Option subscribeToCaptions Eigenschaft des OTSubscriberKit-Objekts:

subscriber.subscribeToCaptions = true

Sie können diese Methode unabhängig davon aufrufen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um keine Untertitel mehr zu erhalten, setzen Sie die Eigenschaft auf false:

subscriber.setSubscribeToCaptions = false

Die OTSubscriberKitCaptionsDelegate(_:subscriber:caption:isFinal:) Nachricht wird gesendet, wenn ein Abonnent eines Streams Untertitel empfängt:

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

Sie können einen Schlüssel-Wert-Beobachter für die hasCaptions Eigenschaft eines OTStream-Objekts um zu sehen, wann der Stream Untertitel aktiviert und deaktiviert hat.

//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

Ein Herausgeber kann die Veröffentlichung von Live-Untertiteln in Echtzeit starten oder stoppen, indem er die Option publishCaptions Eigenschaft des OTPublisherKit-Objekts:

publisher.publishCaptions = YES;

Wenn der Verlag keine Tonspur anbietet, wird die [PublisherKit publisher:didFailWithError:] Nachricht gesendet wird, mit der code Eigenschaft des Fehlers, die auf OTPublisherMissingAudioTrack.

Das Vonage iOS SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Beschriftungen des Sprechers wiederzugeben, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Beschriftungsereignisse hört. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Option subscribeToCaptions Eigenschaft des OTSubscriberKit-Objekts:

subscriber.subscribeToCaptions = YES;

Sie können diese Methode unabhängig davon aufrufen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um keine Untertitel mehr zu erhalten, setzen Sie die Eigenschaft auf NO:

subscriber.setSubscribeToCaptions = NO;

Die [OTSubscriberKitCaptionsDelegate subscriber:caption:isFinal:] Nachricht wird gesendet, wenn ein Abonnent eines Streams Untertitel empfängt:

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

Sie können einen Schlüssel-Wert-Beobachter für die hasCaptions Eigenschaft eines OTStream um zu sehen, wann der Stream Untertitel aktiviert und deaktiviert hat:

//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

Ein Herausgeber kann die Veröffentlichung von Live-Untertiteln in Echtzeit starten oder stoppen, indem er die Option PublishCaptions Eigenschaft des Publisher-Objekts:

publisher.PublishCaptions = true;

Wenn der Verlag keine Tonspur anbietet, wird die PublisherKit.Error Ereignis ausgelöst wird, mit dem ErrorCode Eigenschaft des ErrorEventArgs-Objekts auf PublisherMissingAudioTrack.

Das Vonage Windows SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Untertitel des Sprechers zu rendern, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Untertitelereignisse hört. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Option SubscribeToCaptions Eigenschaft des Subscriber-Objekts:

subscriber.SubscribeToCaptions = true;

Sie können diese Eigenschaft unabhängig davon einstellen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um keine Untertitel mehr zu erhalten, setzen Sie die Eigenschaft auf false:

subscriber.SubscribeToCaptions = false;

Abonnenten erhalten Beschriftungen über Ereignisse. Das SDK zeigt den Text der Beschriftungen nicht in der Benutzeroberfläche an. Fügen Sie einen Ereignis-Listener für die Subscriber.CaptionText Veranstaltung:

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

Die HasCaptions eines Stream-Objekts zeigt an, ob der Stream Untertitel hat:

stream.HasCaptions;

Die Session.StreamHasCaptionsChanged wird ausgelöst, wenn ein Stream Untertitel aktiviert und deaktiviert hat:

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

Publishing live captions

Ein Herausgeber kann die Veröffentlichung von Live-Untertiteln in Echtzeit starten oder stoppen, indem er die Funktion otc_publisher_set_publish_captions() Funktion:

otc_publisher_set_publish_captions(publisher, OTC_FALSE);

Wenn der Verlag keine Tonspur anbietet, wird die otc_publisher_callbacks.on_error() Rückruf Funktion wird mit einem Fehler aufgerufen, wobei der Fehlercode auf OTC_PUBLISHER_MISSING_AUDIO_TRACK.

Das Vonage macOS SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Untertitel des Sprechers zu rendern, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Untertitelereignisse wartet. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Funktion otc_subscriber_set_subscribe_to_captions() Funktion:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_TRUE);

Sie können diese Funktion unabhängig davon aufrufen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um den Empfang von Untertiteln zu beenden, übergeben Sie OTC_FALSE in die Funktion:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_FALSE);

Abonnenten können verifizieren, ob sie die Live-Untertitel eines Streams aktiv abonniert haben, indem sie die otc_subscriber_get_subscribe_to_captions() Funktion:

otc_bool isSubscribed = otc_subscriber_get_subscribe_to_captions(subscriber);

Abonnenten erhalten Beschriftungen über Ereignisse. Das SDK zeigt den Text der Beschriftungen nicht in der Benutzeroberfläche an. Setzen Sie die on_caption_text() Mitgliedsfunktion der otc_subscriber_callbacks Instanz um einen Listener für Untertitelereignisse einzurichten:

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;

Die otc_stream_has_captions() meldet, ob ein Stream Untertitel hat:

otc_bool hasCaptions = otc_stream_has_captions(stream);

Umsetzung der on_stream_has_captions_changed() Mitgliedsfunktion der otc_session_callbacks Instanz, um zu überwachen, wann ein Stream Untertitel aktiviert und deaktiviert hat:

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

Ein Publisher kann die Veröffentlichung von Echtzeit-Live-Untertiteln starten oder stoppen, indem er die Funktion otc_publisher_set_publish_captions() Funktion:

otc_publisher_set_publish_captions(publisher, OTC_FALSE);

Wenn der Verlag keine Tonspur anbietet, wird die otc_publisher_callbacks.on_error() Rückruf Funktion wird mit einem Fehler aufgerufen, wobei der Fehlercode auf OTC_PUBLISHER_MISSING_AUDIO_TRACK.

Das Vonage Linus SDK unterstützt nicht, dass ein Herausgeber Ereignisse für seine eigenen Untertitel empfängt. Um die eigenen Untertitel des Sprechers zu rendern, erstellen Sie einen versteckten Abonnenten (für den Stream des Herausgebers), der auf die Untertitelereignisse wartet. (Siehe den nächsten Abschnitt.)

Subscribing to live captions

Ein Teilnehmer kann den Empfang von Untertiteln starten oder stoppen, indem er die Funktion otc_subscriber_set_subscribe_to_captions() Funktion:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_TRUE);

Sie können diese Funktion unabhängig davon aufrufen, ob der Herausgeber des Streams gerade Live-Untertitel veröffentlicht. Der Abonnent beginnt mit dem Empfang von Untertiteldaten, sobald der Herausgeber mit der Untertitel zu veröffentlichen.

Um den Empfang von Untertiteln zu beenden, übergeben Sie OTC_FALSE in die Funktion:

otc_subscriber_set_subscribe_to_captions(subscriber, OTC_FALSE);

Abonnenten können verifizieren, ob sie die Live-Untertitel eines Streams aktiv abonniert haben, indem sie die otc_subscriber_get_subscribe_to_captions() Funktion:

otc_bool isSubscribed = otc_subscriber_get_subscribe_to_captions(subscriber);

Abonnenten erhalten Beschriftungen über Ereignisse. Das SDK zeigt den Text der Beschriftungen nicht in der Benutzeroberfläche an. Setzen Sie die on_caption_text() Mitgliedsfunktion der otc_subscriber_callbacks Instanz um einen Listener für Untertitelereignisse einzurichten:

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;

Die otc_stream_has_captions() meldet, ob ein Stream Untertitel hat:

otc_bool hasCaptions = otc_stream_has_captions(stream);

Umsetzung der on_stream_has_captions_changed() Mitgliedsfunktion der otc_session_callbacks Instanz, um zu überwachen, wann ein Stream Untertitel aktiviert und deaktiviert hat:

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;