Co-Doing API implementieren

Auf dieser Seite wird beschrieben, wie Sie die Co-Doing API für ein Co-Doing-Szenario verwenden können.

Ersteinrichtung

Zur Vorbereitung der Bibliothek für die Verwendung sollte die Live-Freigabeanwendung ein CoDoingClient-Objekt initialisieren, das eine Co-Doing-Sitzung darstellt.

Wenn Sie das Meet Live Sharing SDK verwenden möchten, rufen Sie die Methode AddonClientFactory.getClient auf. Dadurch wird ein AddonClient zurückgegeben, das als Einstiegspunkt für die Co-Doing-Sitzung dient.

Rufen Sie zur Verwendung des Clients die Methode newSessionBuilder aus AddonClient auf, um einen Builder für einen neuen AddonSession zurückzugeben. Mit newSessionBuilder wird die Schnittstelle AddonSessionHandler implementiert, um die vom Add-on für die Sitzung bereitgestellten Callbacks zu verarbeiten.

Fügen Sie dem Builder die Methode withCoDoing hinzu, um eine Sitzung zu starten.

Das folgende Codebeispiel zeigt eine grundlegende Initialisierung des Co-Doing-Clientobjekts:

class AwesomeVideoAddonSessionHandler implements AddonSessionHandler {}

//For sample implementation, see the "Handle incoming updates" section.
class AwesomeVideoCoDoingHandler implements CoDoingHandler {}

public ListenableFuture<AddonSession> initialSetup() {
  AddonClient meetClient = AddonClientFactory.getClient();
  return meetClient
      .newSessionBuilder(
          new AwesomeVideoAddonSessionHandler())
      .withCoDoing(new AwesomeVideoCoDoingHandler())
      .begin();
}

Video anhalten

Wenn ein Nutzer bei der Teilnahme an der Funktion „Live teilen“ die Wiedergabe in seiner lokalen Video-App pausiert, müssen Sie dafür sorgen, dass auch alle Teilnehmer der Funktion „Live teilen“ ihr Video anhalten.

Erstellen Sie dazu eine CoDoingState-Nachricht, die angibt, dass das Video pausiert wird, und weisen Sie Google Meet an, mit der Methode setGlobalState an alle anderen Teilnehmer zu übertragen. Der gemeinsame globale Status wird zum Standardstatus für alle vorhandenen oder neuen Teilnehmer, bis ein neuer Status festgelegt wird.

Das folgende Codebeispiel zeigt, wie Nutzer über den Status „Pausiert“ informiert werden:

public void onVideoPaused(String videoUrl, Instant currentTimestamp) {
  // Create an internal state object to share with other participants. Note: It's
  // good practice to encode all metadata—even seemingly irrelevant data—into
  // ActivityState updates to guard against race conditions and other subtle
  // failures.
  AwesomeVideoState videoState = AwesomeVideoState
    .builder()
    .videoUrl(videoUrl)
    .videoTimestamp(currentTimestamp)
    .isPaused(true)
    .build();

  // Create the CoDoingState object to wrap the internal state
  CoDoingState coDoingState = new CoDoingState();
  coDoingState.state = SerializationUtils.serialize(videoState);

  // Use Meet to broadcast internal state update to all other participants
  this.coDoingClient.setGlobalState(coDoingState);
};

Durch das Codebeispiel wird das serialisierte videoState-Objekt an alle anderen Meet-Instanzen übertragen, die an der Live-Freigabe teilnehmen. Weitere Informationen zum Empfangen von Broadcast-Updates von anderen Teilnehmern finden Sie im Abschnitt Eingehende Updates verarbeiten.

Das folgende Diagramm zeigt die Abfolge der Ereignisse, nachdem die Pause ausgelöst wurde:

Pausierung des Videos aufheben

Ähnlich wie beim Pausieren des Videos muss ein Nutzer, wenn er das Video in seiner lokalen App wieder aktiviert, diesen Vorgang an andere Teilnehmer der Live-Freigabe übertragen.

Auf der Absenderseite (dem Nutzer, der die Pausierung des Videos aufhebt) besteht der einzige Unterschied zum Pausenbeispiel darin, dass der Status isPaused aktualisiert wird.

Das folgende Codebeispiel zeigt, wie Nutzer auf Absenderseite über den nicht pausierten Status informiert werden:

public void onVideoUnpaused(String videoUrl, Instant currentTimestamp) {
  AwesomeVideoState videoState = AwesomeVideoState
    .builder()
    .videoUrl(videoUrl)
    .videoTimestamp(currentTimestamp)
    .isPaused(false)
    .build();

  CoDoingState coDoingState = new CoDoingState();
  coDoingState.state = SerializationUtils.serialize(videoState);

  this.coDoingClient.setGlobalState(coDoingState);
}

Videosuche

Wenn ein Nutzer die Zeitachse in der lokalen App auf einen neuen Zeitstempel zieht, muss dieser Vorgang wie bei Video pausieren und Video fortsetzen an alle Teilnehmer übertragen werden.

Das folgende Codebeispiel zeigt, wie Nutzer auf Absenderseite über den aktualisierten Zeitstempel informiert werden:

public void onVideoSeeked(String videoUrl, Instant currentTimestamp, bool isPaused) {
  AwesomeVideoState videoState = AwesomeVideoState
    .builder()
    .videoUrl(videoUrl)
    .videoTimestamp(currentTimestamp)
    .isPaused(isPaused)
    .build();

  CoDoingState coDoingState = new CoDoingState();
  coDoingState.state = SerializationUtils.serialize(videoState);

  this.coDoingClient.setGlobalState(coDoingState);
}

Anderes Video abspielen

Wenn der Nutzer das angesehene Video auch ändert, indem er ein anderes Video in der lokalen App auswählt, muss Meet das neue Video für alle Teilnehmer abspielen, die die Funktion „Live teilen“ nutzen. Das geänderte Video wird in videoState.videoUrl gespeichert.

Das folgende Codebeispiel zeigt, wie Nutzer über die aktualisierte Video-URL informiert werden:

public void onVideoChanged(String videoUrl, Duration currentTimestamp, bool isPaused) {
  AwesomeVideoState videoState = AwesomeVideoState
    .builder()
    .videoUrl(videoUrl)
    .videoTimestamp(currentTimestamp)
    .isPaused(isPaused)
    .build();

  CoDoingState coDoingState = new CoDoingState();
  coDoingState.state = SerializationUtils.serialize(videoState);

  this.coDoingClient.setGlobalState(coDoingState);
}

Gemeinsame Bearbeitung beenden

Wenn ein Nutzer sich entscheidet, die Aktivität zu beenden, wird die Verbindung zwischen der Methode endSession und der Meet App getrennt. Dadurch wird Meet nicht gezwungen, die Videokonferenz zu beenden, und der Nutzer wird die Videokonferenz nicht verlassen.

Das folgende Codebeispiel zeigt, wie Nutzer über die beendete Sitzung benachrichtigt werden:

public void endCoDoing() {
  this.session.endSession();
}

Eingehende Updates verarbeiten

Wenn die Meet App eines anderen Teilnehmers eine Nachricht annimmt, wird der onGlobalStateChanged()-Callback ausgelöst. Normalerweise ist es wichtig, gute Entscheidungen darüber zu treffen, welche Aktion als Reaktion auf eingehende Aktualisierungen ausgeführt werden soll. Beispielsweise müssen eingehende Videozeitstempel nur abgeglichen werden, wenn sie sich ausreichend vom lokalen Zeitstempel unterscheiden.

Das folgende Codebeispiel zeigt, wie die verschiedenen eingehenden Updates verarbeitet werden:

class AwesomeVideoCoDoingHandler implements CoDoingHandler {
  public void onGlobalStateChanged(CoDoingState update) {
    AwesomeVideoState videoState = SerializationUtils.deserialize(update.state());

    // Handle transition to new video.
    if (!videoState.videoUrl.equals(this.videoPlayer.videoUrl)) {
      this.videoPlayer.loadVideo(videoState.videoUrl);
    }

    // If the timestamp in the arriving update has sufficiently diverged, adjust
    // the local video playout.
    if (videoState.videoTimestamp.minus(this.videoPlayer.videoTimestamp).abs() >
                                        Duration.ofSeconds(2)) {
      this.videoPlayer.seek(videoState.videoTimestamp);
    }

    // Update pause state, if necessary.
    if (!videoState.isPaused && this.videoPlayer.isPaused) {
      this.videoPlayer.unpause();
    } else if (videoState.isPaused && !this.videoPlayer.isPaused) {
      this.videoPlayer.pause();
    }
  }
}