Gestione dei callback - Amazon Cognito
AndroidiOS - Objective-CiOS - SwiftJavaScriptUnitàXamarin

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Gestione dei callback

Se non hai mai usato Amazon Cognito Sync, utilizza AWS AppSync. Come Amazon Cognito Sync, AWS AppSync è un servizio che consente la sincronizzazione dei dati delle applicazioni tra più dispositivi.

Consente di sincronizzare i dati dell'utente come le preferenze dell'app o lo stato del gioco. Inoltre estende queste funzionalità consentendo a più utenti di sincronizzare e collaborare in tempo reale su dati condivisi.

Questa sezione descrive come gestire le callback.

Android

Interfaccia SyncCallback

Se implementi l'interfaccia SyncCallback, puoi ricevere notifiche sulla tua app riguardanti la sincronizzazione del set di dati. La tua app può quindi prendere decisioni attive sull'eliminazione di dati locali, sull'unione di profili autenticati e non autenticati e la risoluzione di conflitti di sincronizzazione. È consigliabile implementare i seguenti metodi, che sono richiesti dall'interfaccia:

  • onSuccess()

  • onFailure()

  • onConflict()

  • onDatasetDeleted()

  • onDatasetsMerged()

Nota che, se non desideri specificare tutti le callback, puoi anche utilizzare la classe DefaultSyncCallback, che fornisce implementazioni predefinite e vuote per ognuna di esse.

onSuccess

La callback onSuccess() viene attivata quando un set di dati è stato scaricato con successo dall'archivio di sincronizzazione.

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

onFailure

onFailure() viene chiamata se si verifica un'eccezione durante la sincronizzazione.

@Override
public void onFailure(DataStorageException dse) {
}

onConflict

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. Il metodo onConflict() gestisce la risoluzione dei conflitti. Se non implementi questo metodo, il client Amazon Cognito Sync utilizza per impostazione predefinita la modifica più recente.

@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

Quando un set di dati viene eliminato, il client Amazon Cognito usa l'interfaccia SyncCallback per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Implementa il metodo onDatasetDeleted() per comunicare all'SDK del client che cosa fare con i dati locali.

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

onDatasetMerged

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite il metodo 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

Notifiche di sincronizzazione

Il client Amazon Cognito durante una chiamata di sincronizzazione emetterà un numero di eventi di NSNotification. Puoi registrarti per monitorare queste notifiche attraverso lo standard NSNotificationCenter:

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

Amazon Cognito supporta cinque tipi di notifica, elencati di seguito.

AWSCognitoDidStartSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione è in fase di avvio. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

AWSCognitoDidStartSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione viene completata (correttamente o meno). La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

AWSCognitoDidFailToSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione non va a buon fine. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e l'errore chiave, che conterrà l'errore che ha causato il fallimento.

AWSCognitoDidChangeRemoteValueNotification

Chiamato quando le modifiche locali vengono inviate correttamente ad Amazon Cognito. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e le chiavi chiave, che conterranno un NSArray di chiavi record che sono state trasmesse.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Viene chiamato quando un valore locale si modifica a causa di un'operazione di sincronizzazione. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e le chiavi principali, che conterranno un NSArray di chiavi record modificate.

Gestore della risoluzione del conflitto

Durante un'operazione di sincronizzazione, possono sorgere dei conflitti se la stessa chiave è stata modificata nell'archivio locale e in quello di sincronizzazione. Se non hai impostato un gestore della risoluzione dei conflitti, Amazon Cognito sceglierà di default l'aggiornamento più recente.

Con l'implementazione e l'assegnazione di un AWSCognitoRecordConflictHandler puoi modificare la risoluzione dei conflitti predefiniti. Il conflitto del parametro di input AWSCognitoConflict contiene un oggetto AWSCognitoRecord sia per i dati memorizzati nella cache locale, sia per i record di conflitto nello store di sincronizzazione. Se usi AWSCognitoConflict puoi risolvere il conflitto con il record locale: [conflitto resolveWithLocalRecord], il record remoto: [conflitto resolveWithRemoteRecord] o con il valore di un nuovo marchio: [conflitto resolveWithValue: valore]. Il ritorno a zero da questo metodo impedisce alla sincronizzazione di continuare e il conflitto verrà presentato ancora, la prossima volta che il processo di sincronizzazione si riavvierà.

Puoi impostare il gestore della risoluzione del conflitto al livello del client:

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

Oppure a livello del set di dati:

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

Gestore dell'eliminazione del set di dati

Quando un set di dati viene eliminato, il client Amazon Cognito usa AWSCognitoDatasetDeletedHandler per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Se non è stato implementato alcun AWSCognitoDatasetDeletedHandler, i dati locali saranno rimossi automaticamente. Implementa un AWSCognitoDatasetDeletedHandler se desideri mantenere una copia dei dati locali prima della cancellazione, o mantenere i dati locali.

Puoi impostare il gestore dell'eliminazione del set di dati a livello del client:

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

Oppure a livello del set di dati:

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

Gestore dell'unione del set di dati

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le i vengono avvisate dell'unione tramite DatasetMergeHandler. Il gestore riceverà il nome del set di dati radice, nonché una vasta gamma di nomi di set di dati contrassegnati come unioni dei set di dati root.

In caso contrario, DatasetMergeHandler viene implementato, questi set di dati saranno ignorati ma continueranno a consumare lo spazio nei set di dati con un totale di massimo 20 identità.

Puoi impostare il gestore dell'unione del set di dati a livello del 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];
    }
};

Oppure a livello del set di dati:

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

Notifiche di sincronizzazione

Il client Amazon Cognito durante una chiamata di sincronizzazione emetterà un numero di eventi di NSNotification. Puoi registrarti per monitorare queste notifiche attraverso lo standard NSNotificationCenter:

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

Amazon Cognito supporta cinque tipi di notifica, elencati di seguito.

AWSCognitoDidStartSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione è in fase di avvio. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

AWSCognitoDidStartSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione viene completata (correttamente o meno). La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

AWSCognitoDidFailToSynchronizeNotification

Viene chiamato quando un'operazione di sincronizzazione non va a buon fine. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e l'errore chiave, che conterrà l'errore che ha causato il fallimento.

AWSCognitoDidChangeRemoteValueNotification

Chiamato quando le modifiche locali vengono inviate correttamente ad Amazon Cognito. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e le chiavi chiave, che conterranno un NSArray di chiavi record che sono state trasmesse.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Viene chiamato quando un valore locale si modifica a causa di un'operazione di sincronizzazione. La userInfo conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e le chiavi principali, che conterranno un NSArray di chiavi record modificate.

Gestore della risoluzione del conflitto

Durante un'operazione di sincronizzazione, possono sorgere dei conflitti se la stessa chiave è stata modificata nell'archivio locale e in quello di sincronizzazione. Se non hai impostato un gestore della risoluzione dei conflitti, Amazon Cognito sceglierà per impostazione predefinita l'aggiornamento più recente.

Con l'implementazione e l'assegnazione di un AWSCognitoRecordConflictHandler puoi modificare la risoluzione dei conflitti predefiniti. Il conflitto del parametro di input AWSCognitoConflict contiene un oggetto AWSCognitoRecord sia per i dati memorizzati nella cache locale, sia per i record di conflitto nello store di sincronizzazione. Se usi AWSCognitoConflict puoi risolvere il conflitto con il record locale: [conflitto resolveWithLocalRecord], il record remoto: [conflitto resolveWithRemoteRecord] o con il valore di un nuovo marchio: [conflitto resolveWithValue: valore]. Il ritorno a zero da questo metodo impedisce alla sincronizzazione di continuare e il conflitto verrà presentato ancora, la prossima volta che il processo di sincronizzazione si riavvierà.

Puoi impostare il gestore della risoluzione del conflitto al livello del client:

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

Oppure a livello del set di dati:

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

Gestore dell'eliminazione del set di dati

Quando un set di dati viene eliminato, il client Amazon Cognito usa AWSCognitoDatasetDeletedHandler per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Se non è stato implementato alcun AWSCognitoDatasetDeletedHandler, i dati locali saranno rimossi automaticamente. Implementa un AWSCognitoDatasetDeletedHandler se desideri mantenere una copia dei dati locali prima della cancellazione, o mantenere i dati locali.

Puoi impostare il gestore dell'eliminazione del set di dati a livello del client:

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

Oppure a livello del set di dati:

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

Handler dell'unione dei set di dati

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le i vengono avvisate dell'unione tramite DatasetMergeHandler. Il gestore riceverà il nome del set di dati radice, nonché una vasta gamma di nomi di set di dati contrassegnati come unioni dei set di dati root.

In caso contrario, DatasetMergeHandler viene implementato, questi set di dati saranno ignorati ma continueranno a consumare lo spazio nei set di dati con un totale di massimo 20 identità.

Puoi impostare il gestore dell'unione del set di dati a livello del 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()
        }
    }
}

Oppure a livello del set di dati:

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

Callback di sincronizzazione

Quando esegui una sincronizzazione() su un set di dati, puoi, a tua discrezione, specificare le callback per gestire ciascuno dei seguenti stati:

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()

La callback onSuccess() viene attivata quando un set di dati è stato aggiornato con successo dallo store di sincronizzazione. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

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

onFailure()

onFailure() viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

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

onConflict()

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. Il metodo onConflict() gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

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()

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata onDatasetDeleted() per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

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()

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata 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);

}

Unità

Dopo che hai aperto o creato un set di dati, puoi impostare su questo diverse callback che vengono attivate quando si utilizza il metodo Synchronize. Questo è il modo per registrarvi le tue callback:

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

Nota che SyncSuccess e SyncFailure usano += invece di = pertanto puoi sottoscrivervi più di una callback.

OnSyncSuccess

La callback OnSyncSuccess viene attivata quando un set di dati è stato aggiornato correttamente dal cloud. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

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

OnSyncFailure

OnSyncFailure viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

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

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. La callback OnSyncConflict gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

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

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata OnDatasetDeleted per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

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

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata 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

Dopo che hai aperto o creato un set di dati, puoi impostare su questo diverse callback che vengono attivate quando si utilizza il metodo Synchronize. Questo è il modo per registrarvi le tue callback:

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

Nota che SyncSuccess e SyncFailure usano += invece di = pertanto puoi sottoscrivervi più di una callback.

OnSyncSuccess

La callback OnSyncSuccess viene attivata quando un set di dati è stato aggiornato correttamente dal cloud. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

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

OnSyncFailure

OnSyncFailure viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

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

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. La callback OnSyncConflict gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

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

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata OnDatasetDeleted per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

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

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata 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;
}