Implementa l'API Co-Doing

Programma di accesso in anteprima: questa funzionalità è disponibile solo in anteprima limitata, tramite un programma di accesso in anteprima.

Questa pagina descrive come utilizzare l'API Co-Doing per supportare uno scenario di co-doing.

Nota: per eseguire correttamente questa operazione è necessario affrontare diversi casi limite relativi alla latenza e altri ritardi. I seguenti esempi di codice rispondono ad alcuni casi d'uso nello scenario di co-doing.

Configurazione iniziale

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

Per utilizzare l'SDK Condivisione in tempo reale di Meet, chiama il metodo AddonClientFactory.getClient. Questa operazione restituisce un elemento AddonClient che funge da punto di ingresso per la sessione di co-doing.

Per utilizzare il client, chiama il metodo newSessionBuilder da AddonClient per restituire uno strumento per la creazione di un nuovo AddonSession. newSessionBuilder implementa l'interfaccia AddonSessionHandler per gestire i callback forniti dal componente aggiuntivo per la sessione.

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

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

Java

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

Quando partecipi a un'esperienza di condivisione in tempo reale, se un utente mette in pausa la riproduzione nell'app video locale, devi assicurarti che anche tutti i partecipanti all'esperienza di condivisione in tempo reale mettano in pausa il video.

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

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

Java

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 a tutte le altre istanze di Meet che partecipano all'esperienza di condivisione in tempo reale. Per maggiori dettagli su come ricevere aggiornamenti sulla trasmissione da altri partecipanti, consulta la sezione Gestire gli aggiornamenti in arrivo.

Il seguente diagramma descrive la sequenza di eventi dopo l'attivazione dell'azione di pausa:

Riattiva video

Come per Metti in pausa il video, se un utente riattiva il video nell'app locale, Meet deve trasmettere questa operazione agli altri partecipanti alla condivisione in tempo reale.

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

Il seguente esempio di codice mostra come notificare agli utenti lo stato riattivato dal lato mittente:

Java

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 Metti in pausa il video e Riattiva 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:

Java

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 in riproduzione selezionando un altro video nell'app locale, Meet deve riprodurre il nuovo video per tutti i partecipanti alla condivisione in tempo reale. Il video modificato è memorizzato in videoState.videoUrl.

Il seguente esempio di codice mostra come comunicare agli utenti l'URL del video aggiornato:

Java

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 la collaborazione

Quando un utente sceglie di terminare l'attività, il metodo endSession si disconnette dall'app Meet. Questo non obbliga Meet a terminare la riunione, né l'utente ad abbandonare la riunione.

Il seguente esempio di codice mostra come notificare agli utenti la sessione interrotta:

Java

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

Gestire gli aggiornamenti in arrivo

Quando l'app Meet di un altro partecipante riceve un annuncio, viene attivato il callback di onGlobalStateChanged(). Di solito, è importante prendere decisioni corrette in merito all'azione da intraprendere in risposta agli aggiornamenti in arrivo, ad esempio far corrispondere i timestamp dei video in entrata solo se sono sufficientemente diversi dal timestamp locale.

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

Java

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