Abonnieren: Grundlagen

Die <OTSession> Komponente versendet eine streamCreated Ereignis, wenn ein neuer Stream (ein anderer als der eigene) in einer Sitzung erstellt wird. Ein Stream wird erstellt, wenn ein Client einen Stream in der Sitzung veröffentlicht. Der streamCreated Ereignis wird auch für jeden vorhandenen Stream in der Sitzung ausgelöst, wenn Sie zum ersten Mal eine Verbindung herstellen. Das streamCreated-Ereignisobjekt enthält Details über den Stream, einschließlich Verbindungsdaten, Videoquellentyp ("Kamera" oder "Bildschirm") und mehr.

import OTSession from 'opentok-react-native';

<OTSession
  apiKey={apiKey}
  sessionId={sessionId}
  token={token}
  eventHandlers={{
    streamCreated: event => {
      console.log('Stream created -- stream ID:', event.streamId);
    },
  }}
/>

Sobald Sie den neuen Stream entdeckt haben, abonnieren Sie ihn wie im nächsten Abschnitt beschrieben.

Das Session-Objekt sendet eine streamCreated Ereignis, wenn ein neuer Stream (ein anderer als der eigene) in einer Sitzung erstellt wird. Ein Stream wird erstellt, wenn ein Client veröffentlicht einen Stream zur Sitzung. Die streamCreated Ereignis wird auch für jeden vorhandenen Stream in der Sitzung ausgelöst, wenn Sie zum ersten Mal eine Verbindung herstellen. Dieses Ereignis wird durch das StreamEvent definiert, das über eine stream Eigenschaft, die den erstellten Stream darstellt:

session.on("streamCreated", function (event) {
    console.log("New stream in the session: " + event.stream.streamId);
});
// Replace with a valid token:
session.connect(token);

Sie können einen beliebigen Stream abonnieren. Siehe den nächsten Abschnitt.

Die onStreamReceived(Session session, Stream stream) Methode des Session.SessionListener-Objekts wird aufgerufen, wenn ein von einem anderen Client veröffentlichter Stream in einer Sitzung erstellt wird. (Ein Stream wird erstellt, wenn ein Client einen Stream in der Sitzung veröffentlicht oder wenn der Stream vorhanden ist, wenn Sie sich mit der Sitzung verbinden.)

@Override
public void onStreamReceived(Session session, Stream stream) {
    // There is a new stream.
    // You may want to subscribe to it.
}

Fügen Sie ein Listener-Objekt für dieses Ereignis hinzu, indem Sie die setSessionListener(Session.SessionListener listener) Methode des Session-Objekts:

mSession.setSessionListener(this);

Die OTSessionDelegate session(_ session:streamCreated:) Nachricht wird gesendet, wenn ein neuer Stream in einer Sitzung erstellt wird. (Ein Stream wird erstellt, wenn ein Client veröffentlicht einen Stream zur Sitzung). Die OTStream-Objekt hat Eigenschaften, die den Stream definieren. Vergleichen Sie die connection Eigenschaft des OTStream-Objekts mit der connection Eigenschaft des OTSession-Objekts, um festzustellen, ob der Stream von Ihrem Client veröffentlicht wurde:

func session(_ session: OTSession, streamCreated stream: OTStream) {
    print("Session streamCreated: \(stream.streamId)")

    // See the declaration of subscribeToSelf above.
    if stream.connection.connectionId == session.connection.connectionId {
        // This is my own stream
    } else {
        // This is a stream from another client.
    }
}

Wenn Ströme eine Sitzung verlassen, wird die [OTSession session: streamDestroyed:] Nachricht gesendet wird. Wenn ein Stream gelöscht wird, wird die Ansicht für jedes OTSubscriber-Objekt für den Stream aus seiner Superview entfernt. Prüfen Sie, ob der Stream nicht von Ihrem eigenen Client veröffentlicht wird, und entfernen Sie seine Ansicht aus seiner Superview.

- (void)session:(OTSession*)session streamDestroyed:(OTStream *)stream
{
    NSLog(@"session streamDestroyed (%@)", stream.streamId);

    if ([subscriber.stream.streamId isEqualToString:stream.streamId])
    {
        [_subscriber.view removeFromSuperview];
        _subscriber = nil;
    }
}

Erkennen, wenn das Video eines Abonnenten deaktiviert ist

Der Delegierte des Abonnenten sendet die [OTSubscriberDelegate subscriberVideoDisabled:reason:] Nachricht, wenn das Video des Abonnenten deaktiviert ist:

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

Die reason kann auf eine der folgenden Konstanten gesetzt werden, die in der Aufzählung OTSubscriberVideoEventReason definiert sind:

• OTSubscriberVideoEventPublisherPropertyChanged - Das Videoereignis wurde durch das Anhalten des Videostreams durch den Herausgeber des Streams verursacht.
• OTSubscriberVideoEventQualityChanged - Das Videoereignis wurde durch eine Änderung der Qualität des Video-Streams verursacht. Die Qualität des Videostroms kann sich aufgrund von Netzwerkbedingungen oder CPU-Auslastung beim Teilnehmer oder Herausgeber ändern. Dieser Grund wird nur in Sitzungen verwendet, bei denen der Medienmodus auf "geroutet" eingestellt ist. (Siehe Der Vonage Video Media Router und die Medienmodi.) Mit dieser Funktion des Vonage Video Media Routers kann ein Teilnehmer den Videostream unterbrechen, wenn sich die Qualität des Videostreams verschlechtert, und die Nachricht wird gesendet. Wenn sich die Bedingungen verbessern, wird der Videostream wieder aufgenommen, und die [OTSubscriberKit subscriberVideoEnabled:reason:] Nachricht gesendet wird. Wenn der Videostream unterbrochen wird, empfängt der Abonnent weiterhin den Audiostream, sofern ein solcher vorhanden ist.
• OTSubscriberVideoEventSubscriberPropertyChanged - Das Videoereignis wurde durch eine Änderung der OTSubscriberKit.subscribeToVideo Eigentum.

Wenn der Videostream wieder aufgenommen wird, wird die [OTSubscriberKit subscriberVideoEnabled:reason:] Nachricht gesendet wird.

Wenn Sie einen Stream veröffentlichen, können Sie verhindern, dass das Video aufgrund der Streamqualität deaktiviert wird. Bevor Sie den [OTSession publish:error:] Methode, setzen Sie die audioFallbackEnabled Eigenschaft des Publisher-Objekts (oder PublisherKit-Objekts) auf NO.

Das Session-Objekt sendet eine StreamReceived Ereignis, wenn ein von einem anderen Client veröffentlichter Stream in einer Sitzung erstellt wird. (Ein Stream wird erstellt, wenn ein Client veröffentlicht einen Stream zur Sitzung hinzufügen oder wenn der Stream bereits existiert, wenn Sie eine Verbindung zur Sitzung herstellen).

@Override
session.StreamReceived += Session_StreamReceived;

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

Die on_stream_received Callback-Funktion des otc_session_callbacks struct wird aufgerufen, wenn ein von einem anderen Client veröffentlichter Stream in einer Sitzung erstellt wird. (Ein Stream wird erstellt, wenn ein Client veröffentlicht einen Stream zur Sitzung hinzufügen oder wenn der Stream existiert, wenn Sie sich mit der Sitzung verbinden). Siehe Instanziierung einer otc_session-Instanz und sitzungsbezogene Rückrufe.

Um alle Streams in der Sitzung zu abonnieren, fügen Sie ein OTSubscriber-Objekt als Chile des OTSession-Objekts hinzu:

<OTSession
  applicationId="the Application ID"
  sessionId="the session ID"
  token="the token">
  <OTSubscriber/>
</OTSession>

Nachdem der Client eine Verbindung zur Sitzung hergestellt hat, fügt das OTSubscriber-Objekt Ansichten für Abonnentenvideos hinzu, wenn Streams anderer Clients in der Sitzung verfügbar werden.

Das OTSubscriber-Objekt sendet eine connected Ereignis, wenn ein Abonnent das Streaming erfolgreich startet. Es wird ein Fehlerereignis ausgelöst, wenn es ein error Abonnieren. Einstellen eventHandlers der Komponente OTSubscriber, und setzen Sie die connected und error Eigenschaften dieses Objekts an Callback-Funktionen:

<OTSubscriber
eventHandlers={{
  connected: () => {
    console.log('The subscriber started streaming.');
  },
  error: () => {
    console.log('The subscriber failed.');
  }
}}/>

Um einen Stream zu abonnieren, übergeben Sie das Stream-Objekt an die subscribe Methode des Session-Objekts:

session.subscribe(stream, replacementElementId);

Die subscribe() Methode nimmt die folgenden Parameter entgegen:

• stream-Das Stream-Objekt.
• targetElement- (Optional) Legt das DOM-Element fest, das durch das Abonnentenvideo ersetzt wird.
• properties- (Optional) Eine Reihe von Eigenschaften, die das Erscheinungsbild der Abonnentenansicht auf der HTML-Seite anpassen und festlegen, ob Audio und Video abonniert werden sollen

siehe Anpassen der Benutzeroberfläche

siehe Einstellen von Audio und Video.

• completionHandler- (Optional) Eine Funktion, die asynchron aufgerufen wird, wenn der Aufruf der subscribe() Methode erfolgreich abgeschlossen wird oder fehlschlägt. Wenn der Aufruf der Methode subscribe() Methode fehlschlägt, wird dem Completion-Handler ein Fehlerobjekt übergeben. Dieses Objekt hat eine code und message Eigenschaften, die den Fehler beschreiben.

Der folgende Code abonniert alle Streams, außer denen, die von Ihrem Client veröffentlicht werden:

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

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

Die insertMode Eigenschaft der properties Parameter des Session.subscribe() Methode gibt an, wie das Publisher-Objekt in das HTML-DOM eingefügt wird, und zwar in Bezug auf die targetElement Parameter. Sie können diesen Parameter auf einen der folgenden Werte einstellen:

• "replace" - Das Subscriber-Objekt ersetzt den Inhalt des targetElements. Dies ist der Standard.
• "after" - Das Subscriber-Objekt ist ein neues Element, das nach dem targetElement im HTML-DOM eingefügt wird. (Sowohl das Subscriber- als auch das targetElement haben dasselbe übergeordnete Element).
• "before" - Das Subscriber-Objekt ist ein neues Element, das vor dem targetElement im HTML-DOM eingefügt wird. (Sowohl das Subscriber- als auch das targetElement haben dasselbe übergeordnete Element).
• "append" - Das Subscriber-Objekt ist ein neues Element, das als untergeordnetes Element des targetElements hinzugefügt wird. Wenn es weitere untergeordnete Elemente gibt, wird der Publisher als letztes untergeordnetes Element des targetElements angefügt.

Der folgende Code fügt zum Beispiel ein neues Subscriber-Objekt als untergeordnetes Objekt einer subscriberContainer DOM-Element:

session.on('streamCreated', function(event) {
  var subscriberProperties = {insertMode: 'append'};
  var subscriber = session.subscribe(event.stream,
    'subscriberContainer',
    subscriberProperties,
    function (error) {
      if (error) {
        console.log(error);
      } else {
        console.log('Subscriber added.');
      }
  });
});

Das Subscriber-Objekt hat eine element die auf das HTML-DOM-Element gesetzt wird, das sie enthält.

Um einen Stream zu abonnieren, instanziieren Sie zunächst ein Subscriber.Builder-Objekt, indem Sie die Subscriber.Builder(Context context, Stream stream) Konstruktor. Geben Sie den Android-Anwendungskontext für den Abonnenten und das Stream-Objekt ein. Rufen Sie den build() Methode, um das Subscriber-Objekt zu erstellen. Rufen Sie dann die subscribe() des Session-Objekts, um mit dem Abonnieren des Streams zu beginnen:

mSubscriber = new Subscriber.Builder(context, stream)
    .build();
mSession.subscribe(mSubscriber);

Die SubscriberKit.SubscriberListener.onConnected(SubscriberKit subscriber) wird aufgerufen, wenn die App beginnt, den Stream des Abonnenten zu empfangen. Zu diesem Zeitpunkt können Sie die Ansicht des Abonnenten (zurückgegeben von der Methode getView() Methode des Subscriber-Objekts) als Unteransicht eines android.view.ViewGroup-Objekts, um es in der App anzuzeigen:

@Override
public void onConnected(subscriber) {
    // mViewContainer is an Android View
    RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(
            getResources().getDisplayMetrics().widthPixels, getResources()
                    .getDisplayMetrics().heightPixels);
    mViewContainer.addView(mSubscriber.getView(), layoutParams);
}

Abmelden von einem Stream

Um die Wiedergabe eines Streams, den Sie abonniert haben, zu beenden, rufen Sie die Funktion Session.unsubscribe(Subscriber subscriber) Methode:

mSession.unsubscribe(mSubscriber);

Der Abonnent wird getrennt, und seine Ansicht wird aus der übergeordneten Ansicht entfernt.

Um einen Stream zu abonnieren, rufen Sie die OTSubscriber init(stream:delegate:) und übergibt ein OTStream-Objekt und ein Delegate-Objekt, das die Nachrichten der Abonnenten empfängt. Rufen Sie dann dieOTSession subscribe(_:error:) um das Abonnieren des Streams zu starten:

func session(_ session: OTSession, streamCreated stream: OTStream) {
    subscriber = OTSubscriber(stream: stream, delegate: self)
    var error: OTError?
    session.subscribe(subscriber!, error: &error)
    
    if error {
        print("subscribe failed with error: \(error)")
    }
}

Die OTSubscriberDelegate subscriberDidConnect(toStream:) Nachricht wird gesendet, wenn die App beginnt, den Stream des Abonnenten zu empfangen. Zu diesem Zeitpunkt können Sie die Ansicht des Abonnenten (dargestellt durch das Feld OTSubscriber view Eigenschaft) an die App:

func subscriberDidConnect(toStream subscriber: OTSubscriberKit) {
    if let subscriberView = self.subscriber?.view {
        subscriberView.frame = CGRect(x: 0, y: 300, width: 400, height: 300)
        self.view.addSubview(subscriberView)
    }
}

Abmelden von einem Stream

Um die Wiedergabe eines Streams, den Sie abonniert haben, zu beenden, rufen Sie die Funktion OTSession unsubscribe(_:error:) Methode:

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

Die Verbindung des Abonnenten ist unterbrochen. Entfernen Sie als Nächstes seine Ansicht aus seiner Superview:

subscriber.view?.removeFromSuperview()

Um einen Stream zu abonnieren, rufen Sie die [OTSubscriber initWithStream:] und übergibt ein OTStream-Objekt und ein Delegate-Objekt, das die Nachrichten der Abonnenten empfängt. Rufen Sie dann die[OTSession subscribe:error] um das Abonnieren des Streams zu starten:

- (void)session:(OTSession*)session streamCreated:(OTStream*)stream
{
    subscriber = [[OTSubscriber alloc] initWithStream:stream delegate:self];
    OTError* error = nil;
    [session subscribe:subscriber error:&error]
    if (error) {
      NSLog(@"subscribe failed with error: (%@)", error);
    }
}

Die [OTSubscriberDelegate subscriberDidConnectToStream:] Nachricht wird gesendet, wenn die App beginnt, den Stream des Abonnenten zu empfangen. Zu diesem Zeitpunkt können Sie die Ansicht des Abonnenten (dargestellt durch das Feld OTSubscriber.view Eigenschaft) an die App:

- (void)subscriberDidConnectToStream:(OTSubscriber*)subscriber
{
    [subscriber.view setFrame:CGRectMake(0, 300, 400, 300)];
    [self.view addSubview:subscriber.view];
}

Abmelden von einem Stream

Um die Wiedergabe eines Streams, den Sie abonniert haben, zu beenden, rufen Sie die Funktion [OTSession unsubscribe:error:] Methode:

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

Die Verbindung des Abonnenten ist unterbrochen. Entfernen Sie als Nächstes seine Ansicht aus seiner Superview:

[subscriber.view removeFromSuperview:];

Um einen Stream zu abonnieren, instanziieren Sie zunächst ein Subscriber-Objekt, indem Sie die Subscriber(context, stream, renderer) Konstruktor. Geben Sie den Windows-Anwendungskontext für den Abonnenten, das Stream-Objekt und einen Video-Renderer ein.

Die OpenTok.IVideoRenderer Schnittstelle definiert den Video-Renderer. Die OpenTok.VideoRenderer Klasse, die im Vonage Video Windows SDK enthalten ist, rendert Video auf ein Windows Presentation Framework-Steuerelement. Das VideoRenderer-Objekt ist eine Unterklasse von System.Windows.Controls.Control.

Sie können dieses Element zu Ihrer Ansichtshierarchie hinzufügen. Oder Sie können Ihren eigenen benutzerdefinierten Video-Renderer erstellen, der die OpenTok.IVideoRenderer Schnittstelle.

Rufen Sie die subscribe() des Session-Objekts, um mit dem Abonnieren des Streams zu beginnen:

VideoRenderer videoRenderer = new VideoRenderer();
// Add the video renderer to the application's view hierarchy.

Subscriber subscriber = new Subscriber(Context.Instance, stream, renderer);
subscriber.Error += Subscriber_Error;
session.subscribe(subscriber);

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

Das Subscriber-Objekt sendet eine Error Ereignis, wenn ein Fehler beim Abonnieren des Streams auftritt. Prüfen Sie die ErrorCode der Argumente, die an das Ereignis übergeben werden, um zu erfahren, warum die Anmeldung fehlgeschlagen ist. (Die OpenTok.ErrorCode enum definiert ErrorCode Werte).

Das Subscriber-Objekt sendet eine Connected Ereignis, wenn die App beginnt, den Stream des Abonnenten zu empfangen.

Anmerkung: Die Klasse OpenTok.Subscriber implementiert die Schnittstelle System.IDisposable. Stellen Sie sicher, dass Sie die Dispose() Methode des Subscriber-Objekts, um seine Ressourcen freizugeben, wenn Sie das Objekt nicht mehr benötigen (z. B. wenn der Subscriber das Videostreaming beendet oder wenn die Anwendung oder das Fenster geschlossen wird).

Sie können eine benutzerdefinierter Audiotreiber die von allen Verlegern und Abonnenten verwendet werden können.

Abmelden von einem Stream

Um die Wiedergabe eines Streams, den Sie abonniert haben, zu beenden, rufen Sie die Funktion Session.Unsubscribe(subscriber) Methode:

session.unsubscribe(subscriber);

Der Abonnent wird getrennt, und seine Ansicht wird aus der übergeordneten Ansicht entfernt.

Die on_stream_received Callback-Funktion (siehe vorheriger Abschnitt) enthält eine stream Parameter, der ein Zeiger auf eine otc_stream Struktur, die den neuen Stream repräsentiert. Um den Stream zu abonnieren, instanziieren Sie eine otc_subscriber_callbacks Instanz, setzen Sie einige Callback-Funktionen für teilnehmerbezogene Ereignisse und rufen Sie dann die otc_subscriber_new() Funktion, die die otc_stream und otc_subscriber_callbacks Instanzen

char *user_data = strdup("Session user data");

static void on_subscriber_connected(otc_subscriber *subscriber,
                                    void *user_data,
                                    const otc_stream *stream) {
  // Called when the subscriber connects to the stream.
}

static void on_render_frame(otc_subscriber *subscriber,
                            void *user_data,
                            const otc_video_frame *frame) {
  // Called when the subscriber is ready to render a new video frame
}

static void on_error(otc_subscriber *subscriber,
                      void *user_data) {
  // Called when there is an error.
}

struct otc_subscriber_callbacks subscriber_callbacks = {0};
subscriber_callbacks.user_data = user_data;
subscriber_callbacks.on_connected = on_subscriber_connected;
subscriber_callbacks.on_render_frame = on_subscriber_render_frame;
subscriber_callbacks.on_error = on_subscriber_error;

otc_subscriber *subscriber = otc_subscriber_new(stream,
                                                &subscriber_callbacks);
if (subscriber == NULL) {
  printf("Could not create OpenTok subscriber successfully");
  return;
}

if (otc_session_subscribe(session, subscriber) != OTC_SUCCESS) {
  printf("Could not subscribe successfully.");
}

Verwenden Sie die user_data Mitglied des otc_subscriber_callbacks Struktur, um Daten festzulegen, auf die Sie in den Callback-Funktionen verweisen möchten. In diesem Beispiel setzen wir ihn auf einen Zeiger auf ein String-Objekt. Es könnte aber auch ein Zeiger auf eine Instanz eines anderen Typs sein, der sinnvolle Informationen enthält.

Die anderen Mitglieder der otc_subscriber_callbacks Struktur sind jeweils Callback-Funktionen, die aufgerufen werden, wenn Ereignisse im Zusammenhang mit dem Abonnenten auftreten:

• on_connected - Wird aufgerufen, wenn der Teilnehmer eine Verbindung mit dem Audio-Video-Stream herstellt.
• on_render_frame - Wird jedes Mal aufgerufen, wenn der Abonnent bereit ist, ein neues Videobild zu rendern.
• on_error - Wird aufgerufen, wenn ein Teilnehmerfehler auftritt.

Alle Rückrufe erfolgen nicht über die Anwendung oder den Hauptthread, sondern über einen internen Thread. Die Anwendung sollte den Rückruf so schnell wie möglich zurückgeben, um ein Blockieren des internen Threads zu vermeiden.

Siehe otc_subscriber_callbacks in der Vonage Video Linux SDK-Referenz für Details zu den einzelnen Callback-Funktionen.

Abmelden von einem Stream

Um die Wiedergabe eines Streams, den Sie abonniert haben, zu beenden, rufen Sie die Funktion otc_session_unsubscribe() Funktion, indem Sie die otc_session und otc_subscriber Instanzen:

if (session.unsubscribe(session, subscriber) ==  OTC_SUCCESS) {
  printf("Unsubscribed from the stream successfully.");
  otc_subscriber_delete(subscriber);
} else {
  printf("Could not unsubscribe successfully.");
};

Rufen Sie die otc_subscriber_delete() Funktion, um die Subscriber-Instanz freizugeben, einschließlich aller daran gebundenen Hardware- und UI-Ressourcen.