Implementa l'API Co-Doing

Programma di accesso in anteprima: questa funzionalità era disponibile soltanto in anteprima limitata, tramite un programma di accesso in anteprima. Al momento le nuove registrazioni non sono disponibili per questo programma.

In questa pagina viene descritto come utilizzare l'API Co-Doing per supportare uno scenario di co-doing.

Nota: per farlo correttamente è necessario risolvere diversi casi limite relativi a latenza e altri ritardi. I seguenti esempi di codice affrontano 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 co-doing.

Per utilizzare l'SDK di condivisione in tempo reale di Meet, chiama il metodo AddonClientFactory.getClient. Questo restituisce un elemento 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 una nuova AddonSession. newSessionBuilder implementa l'interfaccia AddonSessionHandler per gestire i callback forniti dal componente aggiuntivo per la sessione.

Per avviare una sessione, aggiungi il metodo withCoDoing allo strumento di creazione.

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 sull'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 trasmetterlo 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 informazioni dettagliate su come ricevere gli aggiornamenti degli annunci da parte di 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 la messa in pausa del video, se un utente riattiva la riproduzione del video nell'app locale, Meet deve trasmettere questa operazione agli altri partecipanti alla condivisione in tempo reale.

Sul lato del 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

Proprio 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:

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 da guardare 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 viene archiviato in videoState.videoUrl.

Il seguente esempio di codice mostra come informare gli utenti dell'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 co-doing

Quando un utente sceglie di terminare l'attività, il metodo endSession si disconnette dall'app Meet. Questo non costringe Meet a terminare la riunione, né causa l'abbandono della riunione.

Il seguente esempio di codice mostra come inviare una notifica agli utenti della 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 oculate sull'azione da intraprendere in risposta agli aggiornamenti in arrivo, ad esempio associando i timestamp dei video in arrivo solo se sono sufficientemente diversi dal timestamp locale.

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

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