Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Synchronisation des données entre les clients
****
Si vous débutez avec Amazon Cognito Sync, utilisez [AWS AppSync](https://aws.amazon.com/appsync/). Comme Amazon Cognito Sync, AWS AppSync il s'agit d'un service permettant de synchroniser les données des applications entre les appareils.
Il permet de synchroniser les données utilisateur telles que des préférences de l'application ou l'état d'un jeu. Il étend également ces capacités en permettant à plusieurs utilisateurs de se synchroniser et de collaborer en temps réel sur des données partagées.
Amazon Cognito vous permet d'enregistrer les données utilisateur dans des jeux de données qui contiennent des paires clé/valeur. Amazon Cognito associe ces données à une identité dans votre groupe d'identités, afin que votre application puisse y accéder indépendamment des connexions et des appareils. Pour synchroniser ces données entre le service Amazon Cognito et les appareils d'utilisateurs finaux, appelez la méthode de synchronisation. Chaque ensemble de données peut avoir une taille maximale de 1 Mo. Vous pouvez associer jusqu'à 20 ensembles de données à une identité.
Le client Amazon Cognito Sync crée un cache local pour les données d'identité. Quand votre application lit et écrit les clés, elle communique avec le cache local. Cette communication garantit la disponibilité immédiate sur l'appareil de toutes les modifications que vous y apportez, même lorsque vous êtes hors ligne. Lorsque la méthode de synchronisation est appelée, les modifications provenant du service sont envoyées au dispositif, tandis que toutes les modifications locales sont transmises au service. À ce stade, les modifications sont disponibles et peuvent être synchronisées sur d'autres appareils.
## Initialisation du client Amazon Cognito Sync
Pour initialiser le client Amazon Cognito Sync, vous devez commencer par créer un fournisseur d'informations d'identification. Le fournisseur d'informations d' AWS identification acquiert des informations d'identification temporaires pour permettre à votre application d'accéder à vos AWS ressources. Vous devez également importer les fichiers d'en-tête nécessaires. Pour initialiser le client Amazon Cognito Sync, procédez comme suit.
### Android
1. Pour créer un fournisseur d'informations d'identification, suivez les instructions décrites dans [Obtention des informations d'identification](getting-credentials.md).
1. Importez le package Amazon Cognito comme suit : `import com.amazonaws.mobileconnectors.cognito.*;`
1. Initialisez Amazon Cognito Sync. Transmettez le contexte de l'application Android, l'D du groupe d'identités, une Région AWS et un fournisseur d'informations d'identification Amazon Cognito initialisé comme suit :
```
CognitoSyncManager client = new CognitoSyncManager(
getApplicationContext(),
Regions.YOUR_REGION,
credentialsProvider);
```
### iOS : Objective-C
1. Pour créer un fournisseur d'informations d'identification, suivez les instructions décrites dans [Obtention des informations d'identification](getting-credentials.md).
1. Importez `AWSCore` et `Cognito`, et initialisez `AWSCognito` comme suit :
```
#import
#import
AWSCognito *syncClient = [AWSCognito defaultCognito];
```
1. Si vous utilisez CocoaPods, remplacez-le `` par`AWSCore.h`. Suivez la même syntaxe pour l'importation Amazon Cognito.
### iOS : Swift
1. Pour créer un fournisseur d'informations d'identification, suivez les instructions décrites dans [Obtention des informations d'identification](getting-credentials.md).
1. Importez et initialisez `AWSCognito` comme suit :
```
import AWSCognito
let syncClient = AWSCognito.default()!
```
### JavaScript
1. Téléchargez le [gestionnaire de synchronisation Amazon Cognito](https://github.com/aws/amazon-cognito-js) pour. JavaScript
1. Intégrez la bibliothèque du gestionnaire de synchronisation dans le projet.
1. Pour créer un fournisseur d'informations d'identification, suivez les instructions décrites dans [Obtention des informations d'identification](getting-credentials.md).
1. Initialisez le gestionnaire de synchronisation comme suit :
```
var syncManager = new AWS.CognitoSyncManager();
```
### Unity
1. Créez une instance de `CognitoAWSCredentials`, conformément aux instructions fournies dans [Obtention des informations d'identification](getting-credentials.md).
1. Créez une instance de `CognitoSyncManager`. Transmettez l'objet `CognitoAwsCredentials` et `AmazonCognitoSyncConfig`, et incluez au moins la région définie, comme suit :
```
AmazonCognitoSyncConfig clientConfig = new AmazonCognitoSyncConfig { RegionEndpoint = REGION };
CognitoSyncManager syncManager = new CognitoSyncManager(credentials, clientConfig);
```
### Xamarin
1. Créez une instance de `CognitoAWSCredentials`, conformément aux instructions fournies dans [Obtention des informations d'identification](getting-credentials.md).
1. Créez une instance de `CognitoSyncManager`. Transmettez l'objet `CognitoAwsCredentials` et `AmazonCognitoSyncConfig`, et incluez au moins la région définie, comme suit :
```
AmazonCognitoSyncConfig clientConfig = new AmazonCognitoSyncConfig { RegionEndpoint = REGION };
CognitoSyncManager syncManager = new CognitoSyncManager(credentials, clientConfig);
```
## Comprendre les jeux de données
Amazon Cognito organise les données de profil utilisateur en jeux de données. Chacun d'eux peut contenir jusqu'à 1 Mo de données sous la forme de paires clé/valeur. Un jeu de données représente l'entité la plus élémentaire que vous pouvez synchroniser. Les opérations de lecture et d'écriture sur un ensemble de données s'appliquent uniquement au stockage local tant que la méthode de synchronisation n'est pas appelée. Amazon Cognito identifie un jeu de données à l'aide d'une chaîne unique. Vous pouvez créer un nouveau jeu de données ou en ouvrir un déjà existant, comme suit.
### Android
```
Dataset dataset = client.openOrCreateDataset("datasetname");
```
Pour supprimer un jeu de données, commencez par appeler la méthode afin de le supprimer du stockage local, puis appelez la méthode `synchronize` pour supprimer le jeu de données d'Amazon Cognito, comme suit :
```
dataset.delete();
dataset.synchronize(syncCallback);
```
### iOS : Objective-C
```
AWSCognitoDataset *dataset = [syncClient openOrCreateDataset:@"myDataSet"];
```
Pour supprimer un jeu de données, commencez par appeler la méthode afin de le supprimer du stockage local, puis appelez la méthode `synchronize` pour supprimer le jeu de données d'Amazon Cognito, comme suit :
```
[dataset clear];
[dataset synchronize];
```
### iOS : Swift
```
let dataset = syncClient.openOrCreateDataset("myDataSet")!
```
Pour supprimer un jeu de données, commencez par appeler la méthode afin de le supprimer du stockage local, puis appelez la méthode `synchronize` comme suit, pour supprimer le jeu de données d'Amazon Cognito :
```
dataset.clear()
dataset.synchronize()
```
### JavaScript
```
syncManager.openOrCreateDataset('myDatasetName', function(err, dataset) {
// ...
});
```
### Unity
```
string myValue = dataset.Get("myKey");
dataset.Put("myKey", "newValue");
```
Pour supprimer une clé d'un jeu de données, utilisez `Remove` comme suit :
```
dataset.Remove("myKey");
```
### Xamarin
```
Dataset dataset = syncManager.OpenOrCreateDataset("myDatasetName");
```
Pour supprimer un jeu de données, commencez par appeler la méthode afin de le supprimer du stockage local, puis appelez la méthode `synchronize` pour supprimer le jeu de données d'Amazon Cognito, comme suit :
```
dataset.Delete();
dataset.SynchronizeAsync();
```
## Lecture et écriture de données dans les jeux de données
Les jeux de données Amazon Cognito fonctionnent comme des dictionnaires, avec des valeurs accessibles par clé. Vous pouvez lire, ajouter ou modifier les clés et les valeurs d'un jeu de données comme s'il s'agissait d'un dictionnaire, comme illustré dans les exemples suivants.
Notez que les valeurs que vous écrivez dans un jeu de données affectent uniquement la version locale mise en cache des données tant que vous n'appelez pas la méthode de synchronisation.
### Android
```
String value = dataset.get("myKey");
dataset.put("myKey", "my value");
```
### iOS : Objective-C
```
[dataset setString:@"my value" forKey:@"myKey"];
NSString *value = [dataset stringForKey:@"myKey"];
```
### iOS : Swift
```
dataset.setString("my value", forKey:"myKey")
let value = dataset.stringForKey("myKey")
```
### JavaScript
```
dataset.get('myKey', function(err, value) {
console.log('myRecord: ' + value);
});
dataset.put('newKey', 'newValue', function(err, record) {
console.log(record);
});
dataset.remove('oldKey', function(err, record) {
console.log(success);
});
```
### Unity
```
string myValue = dataset.Get("myKey");
dataset.Put("myKey", "newValue");
```
### Xamarin
```
//obtain a value
string myValue = dataset.Get("myKey");
// Create a record in a dataset and synchronize with the server
dataset.OnSyncSuccess += SyncSuccessCallback;
dataset.Put("myKey", "myValue");
dataset.SynchronizeAsync();
void SyncSuccessCallback(object sender, SyncSuccessEventArgs e) {
// Your handler code here
}
```
### Android
Pour supprimer des clés d'un jeu de données, utilisez la méthode `remove` comme suit :
```
dataset.remove("myKey");
```
### iOS : Objective-C
Pour supprimer une clé d'un jeu de données, utilisez `removeObjectForKey` comme suit :
```
[dataset removeObjectForKey:@"myKey"];
```
### iOS : Swift
Pour supprimer une clé d'un jeu de données, utilisez `removeObjectForKey` comme suit :
```
dataset.removeObjectForKey("myKey")
```
### Unity
Pour supprimer une clé d'un jeu de données, utilisez `Remove` comme suit :
```
dataset.Remove("myKey");
```
### Xamarin
Vous pouvez utiliser `Remove` pour supprimer une clé à partir d'un ensemble de données :
```
dataset.Remove("myKey");
```
## Synchronisation des données locales avec le magasin de synchronisation
### Android
La méthode `synchronize` compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
```
dataset.synchronize(syncCallback);
```
La méthode `synchronize` reçoit une implémentation de l'interface `SyncCallback`, comme décrit ci-après.
La méthode `synchronizeOnConnectivity()` tente d'effectuer la synchronisation lorsque la connectivité est disponible. Si la connectivité est disponible immédiatement, `synchronizeOnConnectivity()` se comporte comme `synchronize()`. Sinon, il est à l'affut des modifications de connectivité et effectue une synchronisation une fois que la connexion est disponible. Si `synchronizeOnConnectivity()` est appelé plusieurs fois, seule la dernière demande de synchronisation est conservée, et seul le dernier rappel est déclenché. Si l'ensemble de données ou le rappel est nettoyé de la mémoire, cette méthode n'effectue pas une synchronisation, et le rappel n'est pas déclenché.
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).
### iOS : Objective-C
La méthode `synchronize` compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
La méthode `synchronize` est asynchrone et renvoie un objet `AWSTask` pour traiter la réponse :
```
[[dataset synchronize] continueWithBlock:^id(AWSTask *task) {
if (task.isCancelled) {
// Task cancelled.
} else if (task.error) {
// Error while executing task.
} else {
// Task succeeded. The data was saved in the sync store.
}
return nil;
}];
```
La méthode `synchronizeOnConnectivity` tente d'effectuer la synchronisation lorsque le dispositif est connecté. Tout d'abord, `synchronizeOnConnectivity` vérifie si le dispositif est en ligne. Si tel est le cas, il appelle immédiatement la synchronisation et renvoie l'objet `AWSTask` associé à la tentative.
Si le dispositif n'est pas connecté, `synchronizeOnConnectivity` 1) programme la synchronisation pour qu'elle ait lieu la prochaine fois qu'il sera en ligne et 2) renvoie un objet `AWSTask` avec un résultat nul. La synchronisation programmée est uniquement valide pour le cycle de vie de l'objet de l'ensemble de données. Les données ne seront pas synchronisées si l'application est arrêtée avant d'avoir récupéré la connectivité. Si vous souhaitez recevoir une notification lorsque des événements se produisent au cours de la synchronisation programmée, vous devez ajouter des observateurs des notifications trouvées dans `AWSCognito`.
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).
### iOS : Swift
La méthode `synchronize` compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
La méthode `synchronize` est asynchrone et renvoie un objet `AWSTask` pour traiter la réponse :
```
dataset.synchronize().continueWith(block: { (task) -> AnyObject? in
if task.isCancelled {
// Task cancelled.
} else if task.error != nil {
// Error while executing task
} else {
// Task succeeded. The data was saved in the sync store.
}
return task
})
```
La méthode `synchronizeOnConnectivity` tente d'effectuer la synchronisation lorsque le dispositif est connecté. Tout d'abord, `synchronizeOnConnectivity` vérifie si le dispositif est en ligne. Si tel est le cas, il appelle immédiatement `synchronize` et renvoie l'objet `AWSTask` associé à la tentative.
Si le dispositif n'est pas connecté, `synchronizeOnConnectivity` 1) programme la synchronisation pour qu'elle ait lieu la prochaine fois qu'il sera en ligne et 2) renvoie un objet `AWSTask` avec un résultat nul. La synchronisation programmée est uniquement valide pour le cycle de vie de l'objet de l'ensemble de données. Les données ne seront pas synchronisées si l'application est arrêtée avant d'avoir récupéré la connectivité. Si vous souhaitez recevoir une notification lorsque des événements se produisent au cours de la synchronisation programmée, vous devez ajouter des observateurs des notifications trouvées dans `AWSCognito`.
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).
### JavaScript
La méthode `synchronize` compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
```
dataset.synchronize();
```
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).
### Unity
La méthode de synchonisation compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
```
dataset.Synchronize();
```
La synchronisation est exécutée de façon asynchrone et finit par appeler l'un des différents rappels que vous pouvez spécifier dans l'ensemble de données.
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).
### Xamarin
La méthode `synchronize` compare les données locales mises en cache aux données stockées dans le magasin Amazon Cognito Sync. Les modifications à distance sont extraites du magasin Amazon Cognito Sync. Le cas échéant, la résolution des conflits est appelée, et les valeurs mises à jour sur l'appareil sont transférées au service. Pour synchroniser un ensemble de données, appelez sa méthode `synchronize` :
```
dataset.SynchronizeAsync();
```
Pour en savoir plus sur la synchronisation des ensembles de données et sur les différents rappels, consultez la section [Gestion des rappels d'événements](handling-callbacks.md).