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.

# Gestion des rappels d'événements
<a name="handling-callbacks"></a>

****  
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.

En tant que développeur Amazon Cognito Sync, vous pouvez implémenter différents rappels pour gérer différents événements et scénarios de synchronisation. L'`SyncCallback`interface du SDK Android configure les notifications relatives à la synchronisation des ensembles de données, notamment `onSuccess()` lorsqu'un ensemble de données est téléchargé avec succès, `onFailure()` lorsqu'une exception se produit, et `onConflict()` pour résoudre les conflits entre les données locales et distantes.

Dans le SDK iOS, vous pouvez vous inscrire pour recevoir des notifications similaires `AWSCognitoDidStartSynchronizeNotification` et définir des gestionnaires tels que celui `AWSCognitoRecordConflictHandler` pour la résolution des conflits. Les JavaScript plateformes Unity et Xamarin ont des mécanismes de rappel analogues. Lorsque vous implémentez ces rappels, votre application peut gérer avec élégance les différents événements et scénarios de synchronisation qui peuvent se produire lors de l'utilisation d'Amazon Cognito Sync.

## Android
<a name="handling-callbacks-1.android"></a>

**SyncCallback Interface**

En mettant en œuvre l'interface `SyncCallback`, vous pouvez recevoir des notifications concernant la synchronisation de l'ensemble de données dans votre application. Cette dernière peut ensuite prendre des décisions actives sur la suppression des données locales, la fusion des profils non authentifiés et authentifiés et la résolution des conflits de synchronisation. Vous devez implémenter les méthodes suivantes, qui sont requises par l'interface :
+ `onSuccess()`
+ `onFailure()`
+ `onConflict()`
+ `onDatasetDeleted()`
+ `onDatasetsMerged()`

Notez que, si vous ne voulez pas spécifier tous les rappels, vous pouvez également utiliser la classe `DefaultSyncCallback` qui fournit des implémentations vides par défaut pour chacun d'eux.

**onSuccess**

Le rappel `onSuccess()` est déclenché quand un ensemble de données est téléchargé avec succès depuis l'espace de synchronisation.

```
@Override
public void onSuccess(Dataset dataset, List<Record> newRecords) {
}
```

**onFailure**

onFailure() est appelé si une exception s'est produite lors de la synchronisation.

```
@Override
public void onFailure(DataStorageException dse) {
}
```

**onConflict**

Des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. La méthode `onConflict()` gère la résolution des conflits. Si vous n'implémentez pas cette méthode, le client Amazon Cognito Sync utilise par défaut la modification la plus récente.

```
@Override
public boolean onConflict(Dataset dataset, final List<SyncConflict> conflicts) {
    List<Record> resolvedRecords = new ArrayList<Record>();
    for (SyncConflict conflict : conflicts) {
        /* resolved by taking remote records */
        resolvedRecords.add(conflict.resolveWithRemoteRecord());

        /* alternately take the local records */
        // resolvedRecords.add(conflict.resolveWithLocalRecord());

        /* or customer logic, say concatenate strings */
        // String newValue = conflict.getRemoteRecord().getValue()
        //     + conflict.getLocalRecord().getValue();
        // resolvedRecords.add(conflict.resolveWithValue(newValue);
    }
    dataset.resolve(resolvedRecords);

    // return true so that synchronize() is retried after conflicts are resolved
    return true;
}
```

**onDatasetDeleted**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise l'interface `SyncCallback` pour vérifier si la version locale mise en cache doit également être supprimée. Implémentez la méthode `onDatasetDeleted()` pour que le kit SDK du client sache quoi faire avec les données locales.

```
@Override
public boolean onDatasetDeleted(Dataset dataset, String datasetName) {
    // return true to delete the local copy of the dataset
    return true;
}
```

**onDatasetMerged**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais de la méthode `onDatasetsMerged()` :

```
@Override
public boolean onDatasetsMerged(Dataset dataset, List<String> datasetNames) {
    // return false to handle Dataset merge outside the synchronization callback
    return false;
}
```

## iOS : Objective-C
<a name="handling-callbacks-1.ios-objc"></a>

**Notifications de synchronisation**

Le client Amazon Cognito émet un certain nombre d'événements `NSNotification` lors d'un appel de synchronisation. Vous pouvez demander à surveiller ces notifications via le `NSNotificationCenter` standard :

```
[NSNotificationCenter defaultCenter]
  addObserver:self
  selector:@selector(myNotificationHandler:)
  name:NOTIFICATION_TYPE
  object:nil];
```

Amazon Cognito prend en charge les cinq types de notifications énumérés ci-dessous.

**AWSCognitoDidStartSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation commence. L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation.

**AWSCognitoDidEndSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation se termine (avec succès ou non). L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation.

**AWSCognitoDidFailToSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation échoue. L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation, et l'erreur de clé qui contient l'erreur qui a provoqué l'échec.

**AWSCognitoDidChangeRemoteValueNotification**

Appelé lorsque les modifications locales sont correctement transmises à Amazon Cognito. Le `userInfo` contiendra le jeu de données clé, qui est le nom de l'ensemble de données synchronisé, et les clés, qui contiendront les clés NSArray d'enregistrement qui ont été poussées.

**AWSCognitoDidChangeLocalValueFromRemoteNotification**

Appelé lorsqu'une valeur locale change en raison d'une opération de synchronisation. Le `userInfo` contiendra le jeu de données clé, qui est le nom de l'ensemble de données synchronisé, et les clés, qui contiendront les clés NSArray d'enregistrement modifiées.

**Gestionnaire de résolution des conflits**

Lors d'une opération de synchronisation, des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. Si vous n'avez pas défini un gestionnaire de résolution des conflits, Amazon Cognito choisit par défaut la mise à jour la plus récente.

En implémentant et en attribuant un, AWSCognito RecordConflictHandler vous pouvez modifier la résolution des conflits par défaut. Le AWSCognito conflit de paramètres d'entrée Conflict contient un objet AWSCognito Record à la fois pour les données mises en cache locales et pour l'enregistrement en conflit dans le magasin de synchronisation. À l'aide du AWSCognito conflit, vous pouvez résoudre le conflit avec l'enregistrement local : [ resolveWithLocalenregistrement du conflit], l'enregistrement distant : [ resolveWithRemoteenregistrement du conflit] ou une toute nouvelle valeur : [ resolveWithValueconflict:valeur]. Le renvoi de la valeur nulle à partir de cette méthode empêche la synchronisation de se poursuivre et les conflits seront présentés à nouveau la prochaine fois que le processus de synchronisation démarrera.

Vous pouvez définir le gestionnaire de résolution des conflits au niveau du client :

```
client.conflictHandler = ^AWSCognitoResolvedConflict* (NSString *datasetName, AWSCognitoConflict *conflict) {
    // always choose local changes
    return [conflict resolveWithLocalRecord];
};
```

Ou au niveau de l'ensemble de données :

```
dataset.conflictHandler = ^AWSCognitoResolvedConflict* (NSString *datasetName, AWSCognitoConflict *conflict) {
    // override and always choose remote changes
    return [conflict resolveWithRemoteRecord];
};
```

**Gestionnaire de suppression de l'ensemble de données**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise l'`AWSCognitoDatasetDeletedHandler` pour vérifier si la version locale mise en cache doit également être supprimée. Si aucun gestionnaire `AWSCognitoDatasetDeletedHandler` n'est mis en œuvre, les données locales seront purgées automatiquement. Implémentez un gestionnaire `AWSCognitoDatasetDeletedHandler` si vous souhaitez conserver une copie des données locales avant l'effacement ou si vous souhaitez conserver les données locales.

Vous pouvez définir le gestionnaire de suppression de l'ensemble de données au niveau du client :

```
client.datasetDeletedHandler = ^BOOL (NSString *datasetName) {
    // make a backup of the data if you choose
    ...
    // delete the local data (default behavior)
    return YES;
};
```

Ou au niveau de l'ensemble de données :

```
dataset.datasetDeletedHandler = ^BOOL (NSString *datasetName) {
    // override default and keep the local data
    return NO;
};
```

**Gestionnaire de fusion de l'ensemble de données**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais du gestionnaire `DatasetMergeHandler`. Le gestionnaire reçoit le nom de l'ensemble de données racine, ainsi qu'un tableau de noms d'ensembles de données qui sont marqués comme étant des fusions de l'ensemble de données racine.

Si aucun gestionnaire `DatasetMergeHandler` n'est mis en œuvre, ces ensembles de données seront ignorés, mais continueront à utiliser l'espace autorisant un maximum de 20 ensembles de données.

Vous pouvez définir le gestionnaire de fusion de l'ensemble de données au niveau du client :

```
client.datasetMergedHandler = ^(NSString *datasetName, NSArray *datasets) {
    // Blindly delete the datasets
    for (NSString *name in datasets) {
        AWSCognitoDataset *merged = [[AWSCognito defaultCognito] openOrCreateDataset:name];
       [merged clear];
       [merged synchronize];
    }
};
```

Ou au niveau de l'ensemble de données :

```
dataset.datasetMergedHandler = ^(NSString *datasetName, NSArray *datasets) {
    // Blindly delete the datasets
    for (NSString *name in datasets) {
        AWSCognitoDataset *merged = [[AWSCognito defaultCognito] openOrCreateDataset:name];
        // do something with the data if it differs from existing dataset
        ...
        // now delete it
        [merged clear];
        [merged synchronize];
    }
};
```

## iOS : Swift
<a name="handling-callbacks-1.ios-swift"></a>

**Notifications de synchronisation**

Le client Amazon Cognito émet un certain nombre d'événements `NSNotification` lors d'un appel de synchronisation. Vous pouvez demander à surveiller ces notifications via le `NSNotificationCenter` standard :

```
NSNotificationCenter.defaultCenter().addObserver(observer: self,
   selector: "myNotificationHandler",
   name:NOTIFICATION_TYPE,
   object:nil)
```

Amazon Cognito prend en charge les cinq types de notifications énumérés ci-dessous.

**AWSCognitoDidStartSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation commence. L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation.

**AWSCognitoDidEndSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation se termine (avec succès ou non). L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation.

**AWSCognitoDidFailToSynchronizeNotification**

Appelé lorsqu'une opération de synchronisation échoue. L'objet `userInfo` contient l'ensemble de données de la clé, qui correspond au nom de l'ensemble de données en cours de synchronisation, et l'erreur de clé qui contient l'erreur qui a provoqué l'échec.

**AWSCognitoDidChangeRemoteValueNotification**

Appelé lorsque les modifications locales sont correctement transmises à Amazon Cognito. Le `userInfo` contiendra le jeu de données clé, qui est le nom de l'ensemble de données synchronisé, et les clés, qui contiendront les clés NSArray d'enregistrement qui ont été poussées.

**AWSCognitoDidChangeLocalValueFromRemoteNotification**

Appelé lorsqu'une valeur locale change en raison d'une opération de synchronisation. Le `userInfo` contiendra le jeu de données clé, qui est le nom de l'ensemble de données synchronisé, et les clés, qui contiendront les clés NSArray d'enregistrement modifiées.

**Gestionnaire de résolution des conflits**

Lors d'une opération de synchronisation, des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. Si vous n'avez pas défini un gestionnaire de résolution des conflits, Amazon Cognito choisit par défaut la mise à jour la plus récente.

L'implémentation et l'attribution d'un gestionnaire `AWSCognitoRecordConflictHandler` vous permet de modifier la résolution des conflits par défaut. Le conflit du paramètre d'entrée `AWSCognitoConflict` contient un objet `AWSCognitoRecord` pour les données locales mises en cache, ainsi que pour l'enregistrement conflictuel dans l'espace de synchronisation. À l'aide du, `AWSCognitoConflict` vous pouvez résoudre le conflit avec l'enregistrement local : [ resolveWithLocalenregistrement du conflit], l'enregistrement distant : [ resolveWithRemoteenregistrement du conflit] ou une toute nouvelle valeur : [ resolveWithValueconflict:valeur]. Le renvoi de la valeur nulle à partir de cette méthode empêche la synchronisation de se poursuivre et les conflits seront présentés à nouveau la prochaine fois que le processus de synchronisation démarrera.

Vous pouvez définir le gestionnaire de résolution des conflits au niveau du client :

```
client.conflictHandler = {
    (datasetName: String?, conflict: AWSCognitoConflict?) -> AWSCognitoResolvedConflict? in
    return conflict.resolveWithLocalRecord()
}
```

Ou au niveau de l'ensemble de données :

```
dataset.conflictHandler = {
    (datasetName: String?, conflict: AWSCognitoConflict?) -> AWSCognitoResolvedConflict? in
    return conflict.resolveWithLocalRecord()
}
```

**Gestionnaire de suppression de l'ensemble de données**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise l'`AWSCognitoDatasetDeletedHandler` pour vérifier si la version locale mise en cache doit également être supprimée. Si aucun gestionnaire `AWSCognitoDatasetDeletedHandler` n'est mis en œuvre, les données locales seront purgées automatiquement. Implémentez un gestionnaire `AWSCognitoDatasetDeletedHandler` si vous souhaitez conserver une copie des données locales avant l'effacement ou si vous souhaitez conserver les données locales.

Vous pouvez définir le gestionnaire de suppression de l'ensemble de données au niveau du client :

```
client.datasetDeletedHandler = {
      (datasetName: String!) -> Bool in
      // make a backup of the data if you choose
      ...
      // delete the local data (default behaviour)
      return true
}
```

Ou au niveau de l'ensemble de données :

```
dataset.datasetDeletedHandler = {
      (datasetName: String!) -> Bool in
      // make a backup of the data if you choose
      ...
      // delete the local data (default behaviour)
      return true
}
```

**Gestionnaire de fusion des jeux de données**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais du gestionnaire `DatasetMergeHandler`. Le gestionnaire reçoit le nom de l'ensemble de données racine, ainsi qu'un tableau de noms d'ensembles de données qui sont marqués comme étant des fusions de l'ensemble de données racine.

Si aucun gestionnaire `DatasetMergeHandler` n'est mis en œuvre, ces ensembles de données seront ignorés, mais continueront à utiliser l'espace autorisant un maximum de 20 ensembles de données.

Vous pouvez définir le gestionnaire de fusion de l'ensemble de données au niveau du client :

```
client.datasetMergedHandler = {
    (datasetName: String!, datasets: [AnyObject]!) -> Void in
    for nameObject in datasets {
        if let name = nameObject as? String {
            let merged = AWSCognito.defaultCognito().openOrCreateDataset(name)
            merged.clear()
            merged.synchronize()
        }
    }
}
```

Ou au niveau de l'ensemble de données :

```
dataset.datasetMergedHandler = {
    (datasetName: String!, datasets: [AnyObject]!) -> Void in
    for nameObject in datasets {
        if let name = nameObject as? String {
            let merged = AWSCognito.defaultCognito().openOrCreateDataset(name)
            // do something with the data if it differs from existing dataset
              ...
              // now delete it
            merged.clear()
            merged.synchronize()
        }
    }
}
```

## JavaScript
<a name="handling-callbacks-1.javascript"></a>

**Rappels de synchronisation**

Lorsque vous effectuez une opération synchronize() au niveau d'un ensemble de données, vous pouvez spécifier des rappels pour gérer chacun des états suivants :

```
dataset.synchronize({

   onSuccess: function(dataset, newRecords) {
      //...
   },

   onFailure: function(err) {
      //...
   },

   onConflict: function(dataset, conflicts, callback) {
      //...
   },

   onDatasetDeleted: function(dataset, datasetName, callback) {
      //...
   },

  onDatasetMerged: function(dataset, datasetNames, callback) {
      //...
  }

});
```

**onSuccess()**

Le rappel `onSuccess()` est déclenché quand un ensemble de données est mis à jour avec succès depuis l'espace de synchronisation. Si vous ne définissez pas un rappel, la synchronisation aboutit en mode silencieux.

```
onSuccess: function(dataset, newRecords) {
   console.log('Successfully synchronized ' + newRecords.length + ' new records.');
}
```

**onFailure()**

`onFailure()` est appelé si une exception s'est produite lors de la synchronisation. Si vous ne définissez pas un rappel, la synchronisation échoue en mode silencieux.

```
onFailure: function(err) {
   console.log('Synchronization failed.');
   console.log(err);
}
```

**onConflict()**

Des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. La méthode `onConflict()` gère la résolution des conflits. Si vous n'implémentez cette méthode, la synchronisation est interrompue quand il y a un conflit.

```
onConflict: function(dataset, conflicts, callback) {

   var resolved = [];

   for (var i=0; i<conflicts.length; i++) {

      // Take remote version.
      resolved.push(conflicts[i].resolveWithRemoteRecord());

      // Or... take local version.
      // resolved.push(conflicts[i].resolveWithLocalRecord());

      // Or... use custom logic.
      // var newValue = conflicts[i].getRemoteRecord().getValue() + conflicts[i].getLocalRecord().getValue();
      // resolved.push(conflicts[i].resovleWithValue(newValue);

   }

   dataset.resolve(resolved, function() {
      return callback(true);
   });

   // Or... callback false to stop the synchronization process.
   // return callback(false);

}
```

**onDatasetDeleted()**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise le rappel `onDatasetDeleted()` pour décider si la version locale mise en cache doit également être supprimée. Par défaut, l'ensemble de données n'est pas supprimé.

```
onDatasetDeleted: function(dataset, datasetName, callback) {

   // Return true to delete the local copy of the dataset.
   // Return false to handle deleted datasets outside the synchronization callback.

   return callback(true);

}
```

**onDatasetMerged()**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais du rappel `onDatasetsMerged()`.

```
onDatasetMerged: function(dataset, datasetNames, callback) {

   // Return true to continue the synchronization process.
   // Return false to handle dataset merges outside the synchronization callback.

   return callback(false);

}
```

## Unity
<a name="handling-callbacks-1.unity"></a>

Une fois que vous ouvrez ou créez un ensemble de données, vous pouvez définir différentes rappels qui se déclencheront lorsque vous utilisez la méthode de synchronisation. Voici comment enregistrer ces rappels :

```
dataset.OnSyncSuccess += this.HandleSyncSuccess;
dataset.OnSyncFailure += this.HandleSyncFailure;
dataset.OnSyncConflict = this.HandleSyncConflict;
dataset.OnDatasetMerged = this.HandleDatasetMerged;
dataset.OnDatasetDeleted = this.HandleDatasetDeleted;
```

Notez que `SyncSuccess` et `SyncFailure` utilisent \$1= au lieu de =. Vous pouvez donc vous abonner à plusieurs rappels.

**OnSyncSuccess**

Le rappel `OnSyncSuccess` est déclenché quand un ensemble de données est mis à jour avec succès depuis le cloud. Si vous ne définissez pas un rappel, la synchronisation aboutit en mode silencieux.

```
private void HandleSyncSuccess(object sender, SyncSuccessEvent e)
{
    // Continue with your game flow, display the loaded data, etc.
}
```

**OnSyncFailure**

`OnSyncFailure` est appelé si une exception s'est produite lors de la synchronisation. Si vous ne définissez pas un rappel, la synchronisation échoue en mode silencieux.

```
private void HandleSyncFailure(object sender, SyncFailureEvent e)
{
    Dataset dataset = sender as Dataset;
    if (dataset.Metadata != null) {
        Debug.Log("Sync failed for dataset : " + dataset.Metadata.DatasetName);
    } else {
        Debug.Log("Sync failed");
    }
    // Handle the error
    Debug.LogException(e.Exception);
}
```

**OnSyncConflict**

Des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. Le rappel `OnSyncConflict` gère la résolution des conflits. Si vous n'implémentez cette méthode, la synchronisation est interrompue quand il y a un conflit.

```
private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Debug.LogWarning("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Debug.LogWarning("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}
```

**OnDatasetDeleted**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise le rappel `OnDatasetDeleted` pour décider si la version locale mise en cache doit également être supprimée. Par défaut, l'ensemble de données n'est pas supprimé.

```
private bool HandleDatasetDeleted(Dataset dataset)
  {
      Debug.Log(dataset.Metadata.DatasetName + " Dataset has been deleted");
      // Do clean up if necessary
      // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
      return true;
  }
```

**OnDatasetMerged**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais du rappel `OnDatasetsMerged`.

```
public bool HandleDatasetMerged(Dataset localDataset, List<string> mergedDatasetNames)
{
    foreach (string name in mergedDatasetNames)
    {
        Dataset mergedDataset = syncManager.OpenOrCreateDataset(name);
        //Lambda function to delete the dataset after fetching it
        EventHandler<SyncSuccessEvent> lambda;
        lambda = (object sender, SyncSuccessEvent e) => {
            ICollection<string> existingValues = localDataset.GetAll().Values;
            ICollection<string> newValues = mergedDataset.GetAll().Values;

            //Implement your merge logic here

            mergedDataset.Delete(); //Delete the dataset locally
            mergedDataset.OnSyncSuccess -= lambda; //We don't want this callback to be fired again
            mergedDataset.OnSyncSuccess += (object s2, SyncSuccessEvent e2) => {
                localDataset.Synchronize(); //Continue the sync operation that was interrupted by the merge
            };
            mergedDataset.Synchronize(); //Synchronize it as deleted, failing to do so will leave us in an inconsistent state
        };
        mergedDataset.OnSyncSuccess += lambda;
        mergedDataset.Synchronize(); //Asnchronously fetch the dataset
    }

    // returning true allows the Synchronize to continue and false stops it
    return false;
}
```

## Xamarin
<a name="handling-callbacks-1.xamarin"></a>

Une fois que vous ouvrez ou créez un ensemble de données, vous pouvez définir différentes rappels qui se déclencheront lorsque vous utilisez la méthode de synchronisation. Voici comment enregistrer ces rappels :

```
dataset.OnSyncSuccess += this.HandleSyncSuccess;
dataset.OnSyncFailure += this.HandleSyncFailure;
dataset.OnSyncConflict = this.HandleSyncConflict;
dataset.OnDatasetMerged = this.HandleDatasetMerged;
dataset.OnDatasetDeleted = this.HandleDatasetDeleted;
```

Notez que `SyncSuccess` et `SyncFailure` utilisent \$1= au lieu de =. Vous pouvez donc vous abonner à plusieurs rappels.

**OnSyncSuccess**

Le rappel `OnSyncSuccess` est déclenché quand un ensemble de données est mis à jour avec succès depuis le cloud. Si vous ne définissez pas un rappel, la synchronisation aboutit en mode silencieux.

```
private void HandleSyncSuccess(object sender, SyncSuccessEventArgs e)
{
    // Continue with your game flow, display the loaded data, etc.
}
```

**OnSyncFailure**

`OnSyncFailure` est appelé si une exception s'est produite lors de la synchronisation. Si vous ne définissez pas un rappel, la synchronisation échoue en mode silencieux.

```
private void HandleSyncFailure(object sender, SyncFailureEventArgs e)
{
    Dataset dataset = sender as Dataset;
    if (dataset.Metadata != null) {
        Console.WriteLine("Sync failed for dataset : " + dataset.Metadata.DatasetName);
    } else {
        Console.WriteLine("Sync failed");
    }
}
```

**OnSyncConflict**

Des conflits peuvent survenir si la même clé a été modifiée sur le stockage local et dans l'espace de synchronisation. Le rappel `OnSyncConflict` gère la résolution des conflits. Si vous n'implémentez cette méthode, la synchronisation est interrompue quand il y a un conflit.

```
private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Console.WriteLine("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Console.WriteLine("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}
```

**OnDatasetDeleted**

Lorsqu'un jeu de données est supprimé, le client Amazon Cognito utilise le rappel `OnDatasetDeleted` pour décider si la version locale mise en cache doit également être supprimée. Par défaut, l'ensemble de données n'est pas supprimé.

```
private bool HandleDatasetDeleted(Dataset dataset)
{
    Console.WriteLine(dataset.Metadata.DatasetName + " Dataset has been deleted");
    // Do clean up if necessary
    // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
    return true;
}
```

**OnDatasetMerged**

Lorsque deux identités qui n'étaient pas connectées sont liées, tous les ensembles de données sont fusionnés. Les applications sont informées de la fusion par le biais du rappel `OnDatasetsMerged`.

```
public bool HandleDatasetMerged(Dataset localDataset, List<string> mergedDatasetNames)
{
    foreach (string name in mergedDatasetNames)
    {
        Dataset mergedDataset = syncManager.OpenOrCreateDataset(name);

            //Implement your merge logic here

        mergedDataset.OnSyncSuccess += lambda;
        mergedDataset.SynchronizeAsync(); //Asnchronously fetch the dataset
    }

    // returning true allows the Synchronize to continue and false stops it
    return false;
}
```