In questa pagina viene descritto come utilizzare l'API Co-Doing per supportare un co-doing in questo scenario.
Configurazione iniziale
Per preparare la libreria all'uso, l'applicazione di condivisione in tempo reale deve inizializzare un componente
CoDoingClient
che rappresenta una sessione di co-doing.
Per utilizzare l'SDK di condivisione in tempo reale di Meet, chiama il
AddonClientFactory.getClient
. Questo restituisce un
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 un nuovo
AddonSession
.
L'newSessionBuilder
implementa i parametri
AddonSessionHandler
per gestire i callback forniti
per la sessione.
Per iniziare una sessione, aggiungi il metodo
withCoDoing
sul builder.
Il seguente esempio di codice mostra un'inizializzazione di base del 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
Durante la partecipazione a un'esperienza di condivisione in tempo reale, se un utente mette in pausa la riproduzione nell'app di video locale, devi assicurarti che tutti i partecipanti alla live un'esperienza di condivisione, mette in pausa il video.
Per farlo, crea un
CoDoingState
un messaggio che indica che il video è in pausa e chiedi a Google Meet di trasmetterlo
tutti gli altri partecipanti che utilizzano
setGlobalState
. Lo stato globale condiviso diventa lo stato predefinito per tutti i partecipanti.
esistente o nuovo, 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 su
tutte le altre istanze di Meet che partecipano alla condivisione in tempo reale
un'esperienza senza intervento manuale. Per i dettagli su come ricevere aggiornamenti di broadcast da altri
partecipanti, vedi Gestire gli aggiornamenti in arrivo
.
Il seguente diagramma descrive la sequenza di eventi dopo l'azione di pausa viene attivato:
Riattiva video
Come per la messa in pausa del video, se un utente riattiva la riproduzione del video l'app locale, Meet deve trasmettere questa operazione ad altri la condivisione dei partecipanti.
Per quanto riguarda il mittente (l'utente che riattiva il video), l'unica differenza
l'esempio di pausa è che lo stato isPaused
è aggiornato.
Il seguente esempio di codice mostra come notificare agli utenti lo stato Riattivato da 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
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 guardato selezionando un altro video su
nell'app locale, Meet deve riprodurre il nuovo video per tutte le condivisioni in tempo reale
partecipanti. 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à, l'evento
endSession
viene disconnesso dall'app Meet. Questa operazione non forza
Meet chiude la riunione né provoca l'abbandono da parte dell'utente
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,
onGlobalStateChanged()
viene attivato il callback. Di solito, è importante prendere buone decisioni su cosa
l'azione da intraprendere in risposta agli aggiornamenti in arrivo, ad esempio solo la corrispondenza in arrivo
i timestamp del video 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();
}
}
}