Ce guide explique comment implémenter la "synchronisation incrémentielle" de données d'agenda. Utilisation vous pouvez synchroniser les données de toutes les collections d'agendas pendant l'enregistrement la bande passante réseau.
Sommaire
Présentation
La synchronisation incrémentielle comprend deux étapes:
La synchronisation complète initiale s'effectue au tout début synchroniser l'état du client avec l'état du serveur. Le client obtient un jeton de synchronisation nécessaire à la persistance.
La synchronisation incrémentielle est effectuée à plusieurs reprises et met à jour le client les modifications qui se sont produites depuis la dernière synchronisation. Chaque fois, le client fournit le jeton de synchronisation précédent obtenu du serveur et stocke le nouveau jeton de synchronisation à partir de la réponse.
Synchronisation complète initiale
La synchronisation complète initiale correspond à la requête initiale pour toutes les ressources du collection que vous souhaitez synchroniser. Vous pouvez restreindre la liste à l'aide de paramètres de requête si vous souhaitez uniquement synchroniser un sous-ensemble de ressources.
Dans la réponse à l'opération de liste, vous trouverez un champ appelé
nextSyncToken représentant un jeton de synchronisation. Vous devrez stocker la valeur
nextSyncToken Si l'ensemble de résultats est trop volumineux et que la réponse est reçue
paginé, la nextSyncToken
n'apparaît que sur la toute dernière page.
Synchronisation incrémentielle
La synchronisation incrémentielle vous permet de récupérer toutes les ressources
modifié depuis la dernière demande de synchronisation. Pour ce faire, vous devez
établir une liste
avec votre jeton de synchronisation le plus récent spécifié dans le champ syncToken.
N'oubliez pas que le résultat contiendra toujours les entrées supprimées, de sorte que le
les clients auront la possibilité de
les supprimer de l'espace de stockage.
Lorsqu'un grand nombre de ressources a changé depuis la dernière
demande de synchronisation incrémentielle, vous pouvez voir un pageToken au lieu de syncToken dans le résultat de la liste. Dans ce cas, vous devez effectuer exactement le même
requête de liste utilisée pour récupérer la première page lors de la synchronisation incrémentielle
(avec exactement le même syncToken), ajoutez-y pageToken et
paginez toutes les requêtes suivantes jusqu'à ce que vous trouviez un autre syncToken sur la dernière page. Pensez à enregistrer ce syncToken pour la prochaine synchronisation
à l'avenir.
Voici des exemples de requêtes pour une demande nécessitant une synchronisation paginée incrémentielle:
Requête d'origine
GET /calendars/primary/events?maxResults=10&singleEvents=true&syncToken=CPDAlvWDx70CEPDAlvWDx
// Result contains the following
"nextPageToken":"CiAKGjBpNDd2Nmp2Zml2cXRwYjBpOXA",
Récupérer la page suivante
GET /calendars/primary/events?maxResults=10&singleEvents=true&syncToken=CPDAlvWDx70CEPDAlvWDx&pageToken=CiAKGjBpNDd2Nmp2Zml2cXRwYjBpOXA
Synchronisation complète requise par le serveur
Il arrive que le serveur invalide les jetons de synchronisation pour diverses raisons
y compris l'expiration des jetons ou les modifications
des LCA associées.
Dans ce cas, le serveur répond à une requête incrémentielle avec un
code de réponse 410. Cela devrait déclencher l'effacement complet du magasin du client.
et une nouvelle synchronisation complète.
Exemple de code
L'extrait de code ci-dessous montre comment utiliser des jetons de synchronisation avec la classe Bibliothèque cliente Java. La première fois la méthode run est appelée, elle effectue une synchronisation complète et stocke le jeton de synchronisation. Lors de chaque exécution ultérieure, il charge le jeton de synchronisation enregistré et effectue une la synchronisation incrémentielle.
private static void run() throws IOException {
// Construct the {@link Calendar.Events.List} request, but don't execute it yet.
Calendar.Events.List request = client.events().list("primary");
// Load the sync token stored from the last execution, if any.
String syncToken = syncSettingsDataStore.get(SYNC_TOKEN_KEY);
if (syncToken == null) {
System.out.println("Performing full sync.");
// Set the filters you want to use during the full sync. Sync tokens aren't compatible with
// most filters, but you may want to limit your full sync to only a certain date range.
// In this example we are only syncing events up to a year old.
Date oneYearAgo = Utils.getRelativeDate(java.util.Calendar.YEAR, -1);
request.setTimeMin(new DateTime(oneYearAgo, TimeZone.getTimeZone("UTC")));
} else {
System.out.println("Performing incremental sync.");
request.setSyncToken(syncToken);
}
// Retrieve the events, one page at a time.
String pageToken = null;
Events events = null;
do {
request.setPageToken(pageToken);
try {
events = request.execute();
} catch (GoogleJsonResponseException e) {
if (e.getStatusCode() == 410) {
// A 410 status code, "Gone", indicates that the sync token is invalid.
System.out.println("Invalid sync token, clearing event store and re-syncing.");
syncSettingsDataStore.delete(SYNC_TOKEN_KEY);
eventDataStore.clear();
run();
} else {
throw e;
}
}
List<Event> items = events.getItems();
if (items.size() == 0) {
System.out.println("No new events to sync.");
} else {
for (Event event : items) {
syncEvent(event);
}
}
pageToken = events.getNextPageToken();
} while (pageToken != null);
// Store the sync token from the last request to be used during the next execution.
syncSettingsDataStore.set(SYNC_TOKEN_KEY, events.getNextSyncToken());
System.out.println("Sync complete.");
}
Ancienne synchronisation
Pour les collections d'événements, il est toujours possible d'effectuer une synchronisation dans le
l'ancienne méthode en conservant la valeur du champ mis à jour dans une liste d'événements.
puis utiliser le champ modifiedSince pour récupérer les événements mis à jour.
Cette approche n'est plus recommandée, car elle est plus sujette aux erreurs
aux mises à jour manquées (par exemple, si les restrictions sur les requêtes ne sont pas appliquées).
De plus, elle n'est disponible que pour les événements.