Implémenter l'API Co-Doing

Cette page explique comment utiliser l'API de co-doing pour faciliter le co-doing dans ce scénario.

Configuration initiale

Pour préparer la bibliothèque en vue de son utilisation, l'application de partage en direct doit initialiser une CoDoingClient qui représente une session de co-doigt.

Pour utiliser le SDK de partage en direct Meet, appelez la méthode AddonClientFactory.getClient . Cette opération renvoie une AddonClient qui sert de point d'entrée à la session de co-doigt.

Pour utiliser le client, appelez la méthode newSessionBuilder de AddonClient pour renvoyer un compilateur pour une nouvelle AddonSession Le newSessionBuilder implémente la AddonSessionHandler pour gérer les rappels fournis par la supplémentaire pour la session.

Pour commencer une séance, ajoutez la withCoDoing sur le compilateur.

L'exemple de code suivant montre une initialisation de base du client de co-création objet:

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

Mettre la vidéo en pause

Lors d'une expérience de partage en direct, si un utilisateur met la lecture en pause sur leur application vidéo locale, vous devez vous assurer que tous les participants l'expérience de partage la mettent également en pause.

Pour ce faire, créez un CoDoingState message indiquant que la vidéo est mise en pause et demande à Google Meet de la diffuser tous les autres participants à l'aide du setGlobalState . L'état global partagé devient l'état par défaut pour tous les participants, existante ou nouvelle, jusqu'à ce qu'un nouvel état soit défini.

L'exemple de code suivant montre comment informer les utilisateurs de l'état "Suspendu" :

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'exemple de code déclenche la diffusion de l'objet videoState sérialisé sur toutes les autres instances de Meet participant au partage en direct expérience. Pour savoir comment recevoir des annonces diffusées par d'autres participants, consultez Gérer les mises à jour entrantes. .

Le schéma suivant décrit la séquence des événements après l'action de mise en veille. déclenchée:

Réactiver la vidéo

Comme avec l'option Mettre la vidéo en pause, si l'utilisateur reprend la lecture de la vidéo sur sa application locale, Meet doit diffuser cette opération aux autres partager des participants.

Du côté de l'expéditeur (l'utilisateur qui réactive la vidéo), la seule différence l'exemple de mise en veille indique que l'état isPaused est mis à jour.

L'exemple de code suivant montre comment informer les utilisateurs que la fonctionnalité est réactivée côté expéditeur:

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

Rechercher une vidéo

Comme pour mettre la vidéo en pause et la réactiver, procédez comme suit : si un utilisateur fait glisser la chronologie de l'application locale vers un nouvel horodatage, Meet doit diffuser cette opération auprès de tous les participants.

L'exemple de code suivant montre comment informer les utilisateurs du code temporel mis à jour du côté de l'expéditeur:

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

Lire une autre vidéo

Si l'utilisateur modifie également la vidéo en cours de visionnage en sélectionnant une autre vidéo sur l'application locale, Meet doit lire la nouvelle vidéo pour tous les partages en direct participants. La vidéo modifiée est stockée dans videoState.videoUrl.

L'exemple de code suivant montre comment informer les utilisateurs de la mise à jour de l'URL de la vidéo:

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

Mettre fin au codo

Lorsqu'un utilisateur choisit de mettre fin à l'activité, endSession se déconnecte de l'application Meet. Cela ne vous oblige pas Meet met fin à la réunion et n'entraîne pas la fermeture de l'utilisateur réunion.

L'exemple de code suivant montre comment avertir les utilisateurs de l'arrêt de la session:

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

Gérer les mises à jour entrantes

Lorsque l'application Meet d'un autre participant reçoit une annonce, onGlobalStateChanged() est déclenché. En général, il est important de prendre de bonnes décisions sur ce que action à entreprendre en réponse aux mises à jour entrantes (par exemple, uniquement les correspondances entrantes les codes temporels de la vidéo s'ils sont suffisamment différents du code temporel local.

L'exemple de code suivant montre comment gérer les différentes mises à jour 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();
    }
  }
}