Wdrażanie interfejsu Co-Doing API

Na tej stronie dowiesz się, jak korzystać z interfejsu API wspólnego działania, aby wesprzeć wspólne działanie

Konfiguracja początkowa

Aby przygotować bibliotekę do użycia, aplikacja do udostępniania na żywo powinna zainicjować CoDoingClient który reprezentuje sesję wspólnego wykonywania.

Aby użyć pakietu SDK do udostępniania na żywo w Meet, wywołaj metodę AddonClientFactory.getClient . Powoduje to zwrócenie AddonClient który jest punktem wyjścia dla sesji wspólnego tworzenia.

Aby użyć klienta, wywołaj metodę newSessionBuilder z AddonClient, aby zwrócić konstruktor dla nowego AddonSession newSessionBuilder implementuje metodę AddonSessionHandler do obsługi wywołań zwrotnych udostępnianych przez dla danej sesji.

Aby rozpocząć sesję, dodaj withCoDoing w konstruktorze.

Poniższa próbka kodu pokazuje podstawowe inicjowanie klienta korzystającego ze wspólnego działania obiekt:

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

Wstrzymaj film

Jeśli użytkownik wstrzyma odtwarzanie w ramach udostępniania na żywo, w lokalnej aplikacji wideo, musisz upewnić się, że wszyscy uczestnicy udostępnia też treści.

W tym celu utwórz CoDoingState komunikat informujący o wstrzymaniu obrazu wideo i polecenie Google Meet, aby go przesłać; wszyscy pozostali uczestnicy używają setGlobalState . Udostępniony stan globalny staje się domyślnym stanem dla wszystkich uczestników. istniejący lub nowy, dopóki nie zostanie ustawiony nowy stan.

Poniższy przykładowy kod pokazuje, jak powiadomić użytkowników o stanie wstrzymania:

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

Przykładowy kod aktywuje zserializowany obiekt videoState, do którego ma być przesyłany komunikat wszystkie pozostałe instancje Meet, w których włączone jest udostępnianie na żywo. z myślą o użytkownikach. Szczegółowe informacje na temat odbierania informacji o transmisjach od innych osób uczestników, zapoznaj się z sekcją Obsługa aktualizacji przychodzących .

Poniższy diagram przedstawia sekwencję zdarzeń po wykonaniu działania wstrzymania wywołane:

Cofnij wstrzymanie filmu

Podobnie jak w przypadku wstrzymania filmu, jeśli użytkownik wznowi odtwarzanie filmu na swoim lokalnej aplikacji, Meet musi transmitować tę operację do innych transmisji na żywo udostępniania.

Po stronie nadawcy (czyli użytkownika, który wznawia odtwarzanie filmu) jedyna różnica Przykład wstrzymania: stan isPaused został zaktualizowany.

Poniższy przykładowy kod pokazuje, jak powiadomić użytkowników o stanie wznowienia od po stronie nadawcy:

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

Szukaj filmu

Podobnie jak wstrzymanie filmu i wznowienie odtwarzania, jeśli użytkownik przeciągnie oś czasu w aplikacji lokalnej do nowej sygnatury czasowej, Meet musi transmitować tę operację do wszystkich uczestników.

Poniższy przykładowy kod pokazuje, jak powiadomić użytkowników o zaktualizowanej sygnaturze czasowej od strony nadawcy:

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

Odtwórz inny film

Jeśli użytkownik zmieni też oglądany film, wybierając inny film w aplikacji lokalnej, Meet musi odtworzyć nowy film podczas udostępniania na żywo uczestników. Zmieniony film jest przechowywany na koncie videoState.videoUrl.

Poniższy przykładowy kod pokazuje, jak powiadomić użytkowników o zaktualizowanym adresie URL filmu:

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

Zakończ wspólne działanie

Gdy użytkownik zakończy działanie, endSession zostanie odłączona od aplikacji Meet. Nie wymusza to zakończenie spotkania przez Meet, ale nie spowoduje to opuszczenia przez użytkownika spotkanie.

Poniższy przykładowy kod pokazuje, jak powiadomić użytkowników o zatrzymanej sesji:

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

Obsługa przychodzących aktualizacji

Gdy aplikacja Meet innego uczestnika odbierze transmisję, onGlobalStateChanged() wywołanie zwrotne. Zazwyczaj trzeba podejmować przemyślane decyzje działania, jakie należy podjąć w odpowiedzi na przychodzące aktualizacje, np. dopasowywanie tylko przychodzących sygnatury czasowe filmu, jeśli wystarczająco różnią się od lokalnej sygnatury czasowej.

Poniższy przykładowy kod pokazuje, jak obsługiwać różne przychodzące aktualizacje:

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