Gestion des rappels d'événements - Amazon Cognito
AndroidiOS : Objective-CiOS : SwiftJavaScriptUnityXamarin

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

Si vous débutez avec Amazon Cognito Sync, utilisez AWS 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'SyncCallbackinterface d'Android SDK 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 iOSSDK, 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

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 se produit 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 onDatasetDeleted() méthode pour indiquer au client SDK ce qu'il doit 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

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, AWSCognitoRecordConflictHandler vous pouvez modifier la résolution des conflits par défaut. Le conflit de paramètres AWSCognitoConflict d'entrée contient un AWSCognitoRecord objet à la fois pour les données mises en cache locales et pour l'enregistrement en conflit dans le magasin 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 = ^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

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

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

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 += 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

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 += 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;
}