Implementa l'API Co-Doing

In questa pagina viene descritto come utilizzare l'API Co-Doing per supportare un co-doing in questo scenario.

Configurazione iniziale

Per preparare la libreria all'uso, l'applicazione di condivisione in tempo reale deve inizializzare un componente CoDoingClient che rappresenta una sessione di co-doing.

Per utilizzare l'SDK di condivisione in tempo reale di Meet, chiama il AddonClientFactory.getClient . Questo restituisce un AddonClient che funge da punto di accesso per la sessione di co-doing.

Per utilizzare il client, chiama il metodo newSessionBuilder da AddonClient per restituire un builder per un nuovo AddonSession. L'newSessionBuilder implementa i parametri AddonSessionHandler per gestire i callback forniti per la sessione.

Per iniziare una sessione, aggiungi il metodo withCoDoing sul builder.

Il seguente esempio di codice mostra un'inizializzazione di base del client di co-doing :

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

Metti in pausa il video

Durante la partecipazione a un'esperienza di condivisione in tempo reale, se un utente mette in pausa la riproduzione nell'app di video locale, devi assicurarti che tutti i partecipanti alla live un'esperienza di condivisione, mette in pausa il video.

Per farlo, crea un CoDoingState un messaggio che indica che il video è in pausa e chiedi a Google Meet di trasmetterlo tutti gli altri partecipanti che utilizzano setGlobalState . Lo stato globale condiviso diventa lo stato predefinito per tutti i partecipanti. esistente o nuovo, fino a quando non viene impostato un nuovo stato.

Il seguente esempio di codice mostra come notificare agli utenti lo stato di pausa:

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

L'esempio di codice attiva la trasmissione dell'oggetto videoState serializzato su tutte le altre istanze di Meet che partecipano alla condivisione in tempo reale un'esperienza senza intervento manuale. Per i dettagli su come ricevere aggiornamenti di broadcast da altri partecipanti, vedi Gestire gli aggiornamenti in arrivo .

Il seguente diagramma descrive la sequenza di eventi dopo l'azione di pausa viene attivato:

Riattiva video

Come per la messa in pausa del video, se un utente riattiva la riproduzione del video l'app locale, Meet deve trasmettere questa operazione ad altri la condivisione dei partecipanti.

Per quanto riguarda il mittente (l'utente che riattiva il video), l'unica differenza l'esempio di pausa è che lo stato isPaused è aggiornato.

Il seguente esempio di codice mostra come notificare agli utenti lo stato Riattivato da lato mittente:

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

Cerca video

Come per mettere in pausa il video e riattivare il video, se un utente trascina la sequenza temporale sull'app locale su un nuovo timestamp, Meet deve trasmettere questa operazione a tutti i partecipanti.

Il seguente esempio di codice mostra come notificare agli utenti il timestamp aggiornato dal lato mittente:

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

Riproduci un video diverso

Se l'utente cambia anche il video guardato selezionando un altro video su nell'app locale, Meet deve riprodurre il nuovo video per tutte le condivisioni in tempo reale partecipanti. Il video modificato viene archiviato in videoState.videoUrl.

Il seguente esempio di codice mostra come informare gli utenti dell'URL del video aggiornato:

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

Termina co-doing

Quando un utente sceglie di terminare l'attività, l'evento endSession viene disconnesso dall'app Meet. Questa operazione non forza Meet chiude la riunione né provoca l'abbandono da parte dell'utente riunione.

Il seguente esempio di codice mostra come inviare una notifica agli utenti della sessione interrotta:

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

Gestire gli aggiornamenti in arrivo

Quando l'app Meet di un altro partecipante riceve un annuncio, onGlobalStateChanged() viene attivato il callback. Di solito, è importante prendere buone decisioni su cosa l'azione da intraprendere in risposta agli aggiornamenti in arrivo, ad esempio solo la corrispondenza in arrivo i timestamp del video se sono sufficientemente diversi dal timestamp locale.

Il seguente esempio di codice mostra come gestire i diversi aggiornamenti in entrata:

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