Umgang mit Callbacks

Wenn Amazon Cognito Sync für Sie neu ist, verwenden Sie zuerst AWS AppSync. Wie Amazon Cognito Sync ist AWS AppSync ein Service zum Synchronisieren von Anwendungsdaten zwischen verschiedenen Geräten.

Es ermöglicht Benutzerdaten wie App-Einstellungen oder Spielstatus synchronisiert werden. Darüber hinaus erweitert es diese Möglichkeiten, indem mehrere Benutzer gemeinsam genutzte Daten synchronisieren und diese in Echtzeit zusammen nutzen können.

In diesem Abschnitt wird beschrieben, wie Sie Callbacks verarbeiten.

Android

SyncCallback-Schnittstelle

Durch die Implementierung der SyncCallback-Schnittstelle können Sie auf Ihrer App Benachrichtigungen über die Datensatz- Synchronisierung empfangen. Ihre App kann dann aktive Entscheidungen zum Löschen von lokalen Daten, zum Zusammenführen authentifizierter und nicht authentifizierter Profile und zum Beheben von Konflikten treffen. Sie sollten die folgenden Methoden implementieren, die von der Schnittstelle benötigt werden:

• onSuccess()

• onFailure()

• onConflict()

• onDatasetDeleted()

• onDatasetsMerged()

Beachten Sie, dass, Sie auch die Klasse DefaultSyncCallback verwenden, können, wenn Sie nicht alle Callbacks angeben möchten. Diese bietet standardmäßige, leere Implementierungen für alle.

onSuccess

Der onSuccess()-Callback wird ausgelöst, wenn ein Datensatz erfolgreich vom Sync Store heruntergeladen wird.

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

onFailure

onFailure() wird aufgerufen, wenn während der Synchronisierung eine Ausnahmebedingung eintritt.

@Override
public void onFailure(DataStorageException dse) {
}

onConflict

Konflikte können auftreten, wenn der gleiche Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Die onConflict()-Methode erledigt die Konfliktlösung. Wenn Sie diese Methode nicht implementieren, wird der Amazon-Cognito-Sync-Client standardmäßig auf die letzte Änderung zurückgesetzt.

@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

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand der SyncCallback-Schnittstelle, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Implementieren Sie die onDatasetDeleted()-Methode, um dem Client-SDK mitzuteilen, was mit den lokalen Daten geschehen soll.

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

onDatasetMerged

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über die onDatasetsMerged()-Methode benachrichtigt:

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

iOS – Objective-C

Sync-Benachrichtigungen

Der Amazon-Cognito-Client gibt eine Reihe von NSNotification-Ereignissen während eines Synchronisierungsaufrufs aus. Sie können sich registrieren, um diese Benachrichtigungen über das standardmäßige zu überwachen NSNotificationCenter:

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

Amazon Cognito unterstützt fünf Benachrichtigungstypen, die nachstehend aufgeführt sind.

AWSCognitoDidStartSynchronizeNotification

Wird aufgerufen, wenn eine Synchronisierung gestartet wird. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes.

AWSCognitoDidEndSynchronizeNotification

Wird aufgerufen, wenn ein Synchronisierungsvorgang abgeschlossen wird (erfolgreich oder nicht). Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes.

AWSCognitoDidFailToSynchronizeNotification

Wird aufgerufen, wenn eine Synchronisierung fehlschlägt. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und den Schlüsselfehler mit dem Fehler, der den Ausfall verursacht hat.

AWSCognitoDidChangeRemoteValueNotification

Wird aufgerufen, wenn lokale Änderungen erfolgreich im Push-Verfahren auf Amazon Cognito übertragen wurden. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und die Schlüssel, die einen NSArray der Datensatzschlüssel enthalten, die im Push-Verfahren übertragen wurden.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Wird aufgerufen, wenn ein lokaler Wert sich aufgrund eines Synchronisationsvorgangs ändert. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und die Schlüssel, die einen NSArray der Datensatzschlüssel enthalten, die geändert wurden.

Konfliktlösung-Handler

Während einer Synchronisierungsoperation können Konflikte auftreten, wenn der gleichen Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Wenn Sie keinen Konfliktauflösung-Handler festgelegt haben, wählt Amazon Cognito standardmäßig die letzte Aktualisierung.

Durch die Implementierung und Zuweisung eines AWSCognitoRecordConflictHandler können Sie die Standard-Konfliktauflösung ändern. Der AWSCognitoConflict-Eingabeparameterkonflikt enthält ein AWSCognitoRecord-Objekt für die lokal zwischengespeicherten Daten und für den im Konflikt stehenden Datensatz im Sync Store. AWSCognitoConflict dient zur Konfliktauflösung mit dem lokalen Datensatz: [conflict resolveWithLocalRecord], dem Remote-Datensatz: [conflict resolveWithRemoteRecord] oder einem neuen Wert: [conflict resolveWithValue:value]. Wenn von dieser Methode nil zurückgegeben wird, kann die Synchronisierung nicht fortfahren, und die Konflikte treten erneut auf, wenn Sie den Sync-Prozess das nächste Mal starten.

Sie können den Konfliktlösung-Handler auf der Client-Ebene festlegen:

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

Oder auf Datensatzebene:

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

Dataset gelöscht-Handler

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand des AWSCognitoDatasetDeletedHandler, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Wenn kein AWSCognitoDatasetDeletedHandler implementiert ist, werden die lokalen Daten automatisch gelöscht. Implementieren Sie einen AWSCognitoDatasetDeletedHandler, wenn Sie eine Kopie der lokalen Daten aufbewahren möchten, bevor Sie diese löschen, oder um die lokalen Daten beizubehalten.

Sie können den Datensatz gelöscht-Handler auf der Client-Ebene festlegen:

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

Oder auf Datensatzebene:

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

Dataset zusammenfügen-Handler

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über die -Methode benachrichtigt DatasetMergeHandler. Der Handler erhält den Namen des Root-Datensatzes sowie eine Reihe von Datensatzamen, die als Zusammenführungen des Root-Datensatzes markiert sind.

Wenn kein DatasetMergeHandler implementiert ist, werden diese Datensätze ignoriert, nehmen jedoch weiterhin Platz in den maximal 20 Datensätzen der Identität ein.

Sie können den Datensatz zusammenführen-Handler auf der Client-Ebene festlegen:

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];
    }
};

Oder auf Datensatzebene:

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

Sync-Benachrichtigungen

Der Amazon-Cognito-Client gibt eine Reihe von NSNotification-Ereignissen während eines Synchronisierungsaufrufs aus. Sie können sich registrieren, um diese Benachrichtigungen über das standardmäßige zu überwachen NSNotificationCenter:

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

Amazon Cognito unterstützt fünf Benachrichtigungstypen, die nachstehend aufgeführt sind.

AWSCognitoDidStartSynchronizeNotification

Wird aufgerufen, wenn eine Synchronisierung gestartet wird. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes.

AWSCognitoDidEndSynchronizeNotification

Wird aufgerufen, wenn ein Synchronisierungsvorgang abgeschlossen wird (erfolgreich oder nicht). Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes.

AWSCognitoDidFailToSynchronizeNotification

Wird aufgerufen, wenn eine Synchronisierung fehlschlägt. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und den Schlüsselfehler mit dem Fehler, der den Ausfall verursacht hat.

AWSCognitoDidChangeRemoteValueNotification

Wird aufgerufen, wenn lokale Änderungen erfolgreich im Push-Verfahren auf Amazon Cognito übertragen wurden. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und die Schlüssel, die einen NSArray der Datensatzschlüssel enthalten, die im Push-Verfahren übertragen wurden.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Wird aufgerufen, wenn ein lokaler Wert sich aufgrund eines Synchronisationsvorgangs ändert. Die userInfo enthalten den Schlüssel-Datensatz, d. h. den Namen des synchronisierten Datensatzes, und die Schlüssel, die einen NSArray der Datensatzschlüssel enthalten, die geändert wurden.

Konfliktlösung-Handler

Während einer Synchronisierungsoperation können Konflikte auftreten, wenn der gleichen Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Wenn Sie keinen Konfliktauflösung-Handler festgelegt haben, wählt Amazon Cognito standardmäßig die letzte Aktualisierung.

Durch die Implementierung und Zuweisung eines AWSCognitoRecordConflictHandler können Sie die Standard-Konfliktauflösung ändern. Der AWSCognitoConflict-Eingabeparameterkonflikt enthält ein AWSCognitoRecord-Objekt für die lokal zwischengespeicherten Daten und für den im Konflikt stehenden Datensatz im Sync Store. AWSCognitoConflict dient zur Konfliktauflösung mit dem lokalen Datensatz: [conflict resolveWithLocalRecord], dem Remote-Datensatz: [conflict resolveWithRemoteRecord] oder einem neuen Wert: [conflict resolveWithValue:value]. Wenn von dieser Methode nil zurückgegeben wird, kann die Synchronisierung nicht fortfahren, und die Konflikte treten erneut auf, wenn Sie den Sync-Prozess das nächste Mal starten.

Sie können den Konfliktlösung-Handler auf der Client-Ebene festlegen:

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

Oder auf Datensatzebene:

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

Dataset gelöscht-Handler

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand des AWSCognitoDatasetDeletedHandler, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Wenn kein AWSCognitoDatasetDeletedHandler implementiert ist, werden die lokalen Daten automatisch gelöscht. Implementieren Sie einen AWSCognitoDatasetDeletedHandler, wenn Sie eine Kopie der lokalen Daten aufbewahren möchten, bevor Sie diese löschen, oder um die lokalen Daten beizubehalten.

Sie können den Datensatz gelöscht-Handler auf der Client-Ebene festlegen:

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

Oder auf Datensatzebene:

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

Datensatz-zusammenfügen-Handler

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über die -Methode benachrichtigt DatasetMergeHandler. Der Handler erhält den Namen des Root-Datensatzes sowie eine Reihe von Datensatzamen, die als Zusammenführungen des Root-Datensatzes markiert sind.

Wenn kein DatasetMergeHandler implementiert ist, werden diese Datensätze ignoriert, nehmen jedoch weiterhin Platz in den maximal 20 Datensätzen der Identität ein.

Sie können den Datensatz zusammenführen-Handler auf der Client-Ebene festlegen:

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

Oder auf Datensatzebene:

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

Synchronisierungs-Callbacks

Beim Synchronisieren () eines Datensatzes können Sie optional Callbacks für die folgenden Status festlegen:

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

Der onSuccess()-Callback wird ausgelöst, wenn ein Datensatz erfolgreich vom Sync Store aktualisiert wird. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer erfolgreichen Synchronisierung.

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

onFailure()

onFailure() wird aufgerufen, wenn während der Synchronisierung eine Ausnahmebedingung eintritt. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer fehlgeschlagenen Synchronisierung.

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

onConflict()

Konflikte können auftreten, wenn der gleiche Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Die onConflict()-Methode erledigt die Konfliktlösung. Wenn Sie diese Methode nicht implementieren, wird die Synchronisierung abgebrochen, wenn ein Konflikt auftritt.

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

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand des onDatasetDeleted()-Callback, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Standardmäßig wird der Datensatz nicht gelöscht.

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

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über den onDatasetsMerged()-Callback benachrichtigt:

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

Nachdem Sie einen Datensatz geöffnet oder erstellt haben, können Sie andere Callbacks festlegen, die ausgelöst werden, wenn Sie die Synchronisieren-Methode verwenden. Dies ist die Art und Weise, Ihre Callbacks zu registrieren:

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

Beachten Sie, dass SyncSuccess und SyncFailure += anstelle von = verwenden, sodass Sie mehrere Callbacks für sie abonnieren können.

OnSyncSuccess

Der OnSyncSuccess-Callback wird ausgelöst, wenn ein Datensatz erfolgreich von der Cloud aktualisiert wird. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer erfolgreichen Synchronisierung.

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

OnSyncFailure

OnSyncFailure wird aufgerufen, wenn während der Synchronisierung eine Ausnahmebedingung eintritt. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer fehlgeschlagenen Synchronisierung.

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

Konflikte können auftreten, wenn der gleiche Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Der OnSyncConflict-Callback erledigt die Konfliktlösung. Wenn Sie diese Methode nicht implementieren, wird die Synchronisierung abgebrochen, wenn ein Konflikt auftritt.

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

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand des OnDatasetDeleted-Callback, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Standardmäßig wird der Datensatz nicht gelöscht.

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

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über den OnDatasetsMerged-Callback benachrichtigt:

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

Nachdem Sie einen Datensatz geöffnet oder erstellt haben, können Sie andere Callbacks festlegen, die ausgelöst werden, wenn Sie die Synchronisieren-Methode verwenden. Dies ist die Art und Weise, Ihre Callbacks zu registrieren:

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

Beachten Sie, dass SyncSuccess und SyncFailure += anstelle von = verwenden, sodass Sie mehrere Callbacks für sie abonnieren können.

OnSyncSuccess

Der OnSyncSuccess-Callback wird ausgelöst, wenn ein Datensatz erfolgreich von der Cloud aktualisiert wird. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer erfolgreichen Synchronisierung.

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

OnSyncFailure

OnSyncFailure wird aufgerufen, wenn während der Synchronisierung eine Ausnahmebedingung eintritt. Wenn Sie keinen Callback definieren, erfolgt keine Benachrichtigung bei einer fehlgeschlagenen Synchronisierung.

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

Konflikte können auftreten, wenn der gleiche Schlüssel im lokalen Speicher und im Sync Store geändert wurde. Der OnSyncConflict-Callback erledigt die Konfliktlösung. Wenn Sie diese Methode nicht implementieren, wird die Synchronisierung abgebrochen, wenn ein Konflikt auftritt.

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

Wenn ein Datensatz gelöscht wird, ermittelt der Amazon-Cognito-Client anhand des OnDatasetDeleted-Callback, ob auch die lokal zwischengespeicherte Kopie des Datensatzes gelöscht werden sollte. Standardmäßig wird der Datensatz nicht gelöscht.

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

Wenn zwei zuvor unverbundene Identitäten verknüpft werden, werden alle ihre Datensätze zusammengeführt. Anwendungen werden von der Zusammenführung über den OnDatasetsMerged-Callback benachrichtigt:

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