Cette page explique comment utiliser l'API de co-doing pour prendre en charge un scénario de co-doing.
Configuration initiale
Pour préparer la bibliothèque à utiliser, l'application de partage en direct doit initialiser un objet CoDoingClient
qui représente une session de co-dodo.
Pour utiliser le SDK de partage en direct Meet, appelez la méthode AddonClientFactory.getClient
. Cela renvoie un AddonClient
qui sert de point d'entrée pour la session de co-dodo.
Pour utiliser le client, appelez la méthode newSessionBuilder
à partir de AddonClient
afin de renvoyer un compilateur pour un nouveau AddonSession
.
newSessionBuilder
implémente l'interface AddonSessionHandler
pour gérer les rappels fournis par le module complémentaire pour la session.
Pour démarrer une session, ajoutez la méthode withCoDoing
au compilateur.
L'exemple de code suivant montre une initialisation de base de l'objet client de co-création:
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();
}
Mettre la vidéo en pause
Lorsque vous participez à une expérience de partage en direct, si un utilisateur suspend la lecture dans son application vidéo locale, vous devez vous assurer que tous les participants à l'expérience de partage en direct mettent également leur vidéo en pause.
Pour ce faire, créez un message CoDoingState
indiquant que la vidéo est mise en pause et demandez à Google Meet de la diffuser auprès de tous les autres participants à l'aide de la méthode setGlobalState
. L'état global partagé devient l'état par défaut pour tous les participants, existants ou nouveaux, jusqu'à ce qu'un nouvel état soit défini.
L'exemple de code suivant montre comment informer les utilisateurs de l'état "Suspendu" :
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'exemple de code déclenche la diffusion de l'objet videoState
sérialisé à toutes les autres instances de Meet participant à l'expérience de partage en direct. Pour savoir comment recevoir des notifications de diffusion d'autres participants, consultez la section Gérer les mises à jour entrantes.
Le schéma suivant décrit la séquence des événements après le déclenchement de l'action de mise en veille:
Réactiver la vidéo
Comme pour la mise en pause de la vidéo, si un utilisateur réactive la vidéo dans son application locale, Meet doit diffuser cette opération auprès des autres participants au partage en direct.
Du côté de l'expéditeur (l'utilisateur qui réactive la vidéo), la seule différence par rapport à l'exemple de mise en pause est que l'état isPaused
est mis à jour.
L'exemple de code suivant montre comment informer les utilisateurs de l'état réactivé côté expéditeur:
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);
}
Rechercher une vidéo
Comme pour mettre la vidéo en pause et la réactiver, 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 côté expéditeur:
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);
}
Lire une autre vidéo
Si l'utilisateur modifie également la vidéo en cours de visionnage en sélectionnant une autre vidéo dans l'application locale, Meet doit la lire pour tous les participants au partage en direct. 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:
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);
}
Mettre fin au codo
Lorsqu'un utilisateur choisit de mettre fin à l'activité, la méthode endSession
se déconnecte de l'application Meet. Cela ne force pas Meet à mettre fin à la réunion et ne l'oblige pas à la quitter.
L'exemple de code suivant montre comment avertir les utilisateurs de l'arrêt de la session:
Java
public void endCoDoing() {
this.session.endSession();
}
Gérer les mises à jour entrantes
Lorsque l'application Meet d'un autre participant reçoit une annonce, le rappel onGlobalStateChanged()
est déclenché. En règle générale, il est important de prendre les bonnes décisions concernant les mesures à prendre en réponse aux mises à jour entrantes. Par exemple, il est important de ne faire correspondre les codes temporels des vidéos entrantes que s'ils sont suffisamment différents de l'horodatage local.
L'exemple de code suivant montre comment gérer les différentes mises à jour entrantes:
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();
}
}
}