Implémenter l'API de co-visionnage

Cette page explique comment utiliser l'API Co-Watching pour soutenir un de visionnage à plusieurs.

Configuration initiale

Pour préparer la bibliothèque en vue de son utilisation, l'application de partage en direct doit initialiser une CoWatchingClient qui représente une session de visionnage à plusieurs.

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 visionnage à plusieurs.

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 withCoWatching sur le compilateur.

L'exemple de code suivant montre une initialisation de base du client de visionnage à plusieurs objet:

class AwesomeVideoAddonSessionHandler implements AddonSessionHandler {}

// For sample implementation, see the "Manage remote state" section below.
class AwesomeVideoCoWatchingHandler implements CoWatchingHandler {}

public ListenableFuture<AddonSession> initialSetup() {
  AddonClient meetClient = AddonClientFactory.getClient();
  return meetClient
      .newSessionBuilder(
          new AwesomeVideoAddonSessionHandler())
      .withCoWatching(new AwesomeVideoCoWatchingHandler())
      .begin();
}

Envoyer des notifications en cas d'actions des utilisateurs

Lorsque l'utilisateur local effectue des actions (par exemple, mettre en pause ou rechercher un contenu multimédia) sur son appareil. La bibliothèque doit en être informée pour que ces actions puissent être pour les autres participants à l'expérience de visionnage à plusieurs. Par exemple, comment notifier la bibliothèque dans plusieurs États, consultez la section Obtenir a démarré.

Vous pouvez contrôler l'état de visionnage à plusieurs à l'aide des méthodes suivantes:

• CoWatchingClient.notifyBuffering: Informe Meet que le contenu multimédia n'est pas prêt à être lu en raison à la mise en mémoire tampon en raison d'un commutateur multimédia, d'une recherche multimédia ou d'un réseau normal. les embouteillages.
• CoWatchingClient.notifyEnded: Informe Meet que le lecteur multimédia a atteint la fin de le contenu multimédia actuel.
• CoWatchingClient.notifyPauseState Informer Meet que l'utilisateur a suspendu ou réactivé la lecture de contenus multimédias. Meet peut ainsi dupliquer cette action pour les autres utilisateurs.
• CoWatchingClient.notifyPlayoutRate: Informe Meet que l'utilisateur a modifié le taux de lecture de le média à une nouvelle valeur (par exemple, 1,25x).
• CoWatchingClient.notifyQueueUpdate: Informe Meet que la file d'attente a été modifiée. Meet peut dupliquer cela pour les autres utilisateurs.
• CoWatchingClient.notifyReady: Informe Meet que la mise en mémoire tampon est terminée et que le contenu multimédia est prêt à être lu, à partir du code temporel fourni.
• CoWatchingClient.notifySeekToTimestamp: Informe Meet que l'utilisateur a recherché le point de lecture de le contenu multimédia, afin que Meet puisse dupliquer cette action pour les autres utilisateurs.
• CoWatchingClient.notifySwitchedToMedia: Informe Meet que l'utilisateur a changé de contenu multimédia. Meet peut les transmettre aux autres utilisateurs. Propose également une option pour une mise à jour simultanée de la file d'attente.

L'exemple de code suivant montre comment avertir les utilisateurs:

public void onVideoPaused(Duration currentTimestamp) {
  // Use Meet to broadcast the pause state to ensure other participants also pause.
  this.session.getCoWatching().notifyPauseState(/* paused= */ true, currentTimestamp);
};

Gérer l'état distant

Pour appliquer les mises à jour entrantes des participants à distance, vous devez proposer Meet permet de gérer directement l'état de lecture d'un contenu multimédia local à l'aide de la CoWatchingHandler.onCoWatchingStateChanged() .

Meet doit également récupérer la position actuelle du contenu multimédia en appelant la méthode CoWatchingHandler.onStateQuery() . Il est appelé régulièrement, il doit donc être écrit pour être performant (par exemple, < 100 ms).

L'exemple de code suivant illustre une implémentation de la classe CoWatchingHandler:

class AwesomeVideoCoWatchingHandler implements CoWatchingHandler {
  /** Applies incoming playback state to the local video. */
  public void onCoWatchingStateChanged(CoWatchingState newState) {
    // Handle transition to new video.
    if (!newState.mediaId().equals(this.videoPlayer.videoUrl)) {
      this.videoPlayer.loadVideo(newState.mediaId());
    }

    // Only adjust the local video playout if it's sufficiently diverged from the timestamp in the
    // applied update.
    if (newState
            .mediaPlayoutPosition()
            .minus(this.videoPlayer.videoTimestamp)
            .compareTo(Duration.ofMillis(500))
        > 0) {
      this.videoPlayer.seek(newState.mediaPlayoutPosition());
    }

    // Update pause state, if necessary.
    if (newState.playbackState().equals(PLAY) && this.videoPlayer.isPaused) {
      this.videoPlayer.unpause();
    } else if (newState.playbackState().equals(PAUSE) && !this.videoPlayer.isPaused) {
      this.videoPlayer.pause();
    }
  }

  /** Returns local video playback state. */
  public Optional<QueriedCoWatchingState> onStateQuery() {
    return Optional.of(QueriedCoWatchingState.of(
      /* mediaPlayoutPosition= */ this.videoPlayer.videoTimestamp));
  }
}