Cómo implementar la API de Co-Doing

En esta página se describe la manera de usar la API de Co-Doing para admitir un trabajo conjunto situación.

Configuración inicial

Para preparar la biblioteca para su uso, la aplicación de compartir en vivo debe inicializar un elemento CoDoingClient un objeto que representa una sesión de cooperación.

Para utilizar el SDK de Compartir en vivo de Meet, llama al AddonClientFactory.getClient . Esto muestra un AddonClient que funcione como el punto de entrada para la sesión de cooperación.

Para usar el cliente, llama al newSessionBuilder método de AddonClient para mostrar un compilador para un nuevo AddonSession newSessionBuilder implementa AddonSessionHandler para administrar las devoluciones de llamada que proporciona el para la sesión.

Para iniciar una sesión, agrega withCoDoing en el compilador.

En la siguiente muestra de código, se muestra una inicialización básica del cliente de cohacer objeto:

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

Pausar video

Cuando se participa en una experiencia de compartir en vivo, si un usuario pausa la reproducción en su app de video local, asegúrate de que todos los participantes la experiencia de uso compartido también pausará el video.

Para ello, crea un CoDoingState en el que se muestre que el video está en pausa y se le indicará a Google Meet que lo transmita todos los demás participantes que usan el setGlobalState . El estado global compartido se convierte en el estado predeterminado para todos los participantes. existentes o nuevos, hasta que se establezca un estado nuevo.

En la siguiente muestra de código, se indica cómo notificar a los usuarios sobre el estado de 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);
};

La muestra de código activa el objeto videoState serializado para que se transmita. Todas las demás instancias de Meet que participen en la función Compartir en vivo una experiencia fluida a los desarrolladores. Para obtener detalles sobre cómo recibir actualizaciones de transmisiones de otras participantes, consulta Cómo administrar las actualizaciones entrantes sección.

En el siguiente diagrama, se describe la secuencia de eventos después de que se detiene activado:

Reanudar video

De manera similar a la opción de pausar video, si un usuario reanuda la reproducción en su app local, Meet debe transmitir esta operación a otras personas y compartir participantes.

Del lado del remitente (el usuario que reanuda el video), la única diferencia de El ejemplo de pausa es que el estado isPaused se actualizó.

En la siguiente muestra de código, se indica cómo notificar a los usuarios sobre el estado reanudado desde el lado del remitente:

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

Buscar video

Al igual que con las opciones para pausar video y reactivar video, si un usuario arrastra el cronograma en la app local a una marca de tiempo nueva Meet debe transmitir esta operación a todos los participantes.

En la siguiente muestra de código, se indica cómo notificar a los usuarios sobre la marca de tiempo actualizada del remitente:

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

Reproducir otro video

Si el usuario también cambia el video que está mirando seleccionando otro video en la app local, Meet debe reproducir el video nuevo para compartir en vivo participantes. El video modificado se almacena en videoState.videoUrl.

En la siguiente muestra de código, se indica cómo notificar a los usuarios sobre la URL del video actualizada:

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

Finalizar colaboración

Cuando un usuario decide finalizar la actividad, el endSession se desconecta de la app de Meet. Esto no fuerza Meet para finalizar la reunión ni provocará que el usuario abandone la reunión.

En la siguiente muestra de código, se indica cómo notificar a los usuarios sobre la sesión detenida:

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

Cómo controlar las actualizaciones entrantes

Cuando la app de Meet de otro participante recibe una transmisión, el onGlobalStateChanged() se activa la devolución de llamada. Por lo general, es importante tomar buenas decisiones sobre qué acción que se debe realizar en respuesta a las actualizaciones entrantes, como hacer coincidir solo el tráfico entrante las marcas de tiempo del video si son lo suficientemente diferentes de las marcas de tiempo locales.

En la siguiente muestra de código, se indica cómo controlar las diferentes actualizaciones entrantes:

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