Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Bearbeitung von Rückrufen bei Ereignissen
Wenn Amazon Cognito Sync für Sie neu ist, verwenden Sie zuerst AWS AppSync
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.
Als Amazon Cognito Sync-Entwickler können Sie verschiedene Callbacks implementieren, um verschiedene Synchronisierungsereignisse und -szenarien zu behandeln. Die SyncCallback
Benutzeroberfläche in Android SDK konfiguriert Benachrichtigungen über die Datensatzsynchronisierung, z. B. onSuccess()
wenn ein Datensatz erfolgreich heruntergeladen wurde, onFailure()
wenn eine Ausnahme auftritt und onConflict()
um Konflikte zwischen lokalen und entfernten Daten zu lösen.
Unter iOS können Sie SDK sich für ähnliche Benachrichtigungen registrieren AWSCognitoDidStartSynchronizeNotification
und Handler wie die AWSCognitoRecordConflictHandler
für die Konfliktlösung einrichten. Die JavaScript Plattformen Unity und Xamarin verfügen über analoge Callback-Mechanismen. Wenn Sie diese Callbacks implementieren, kann Ihre Anwendung die verschiedenen Synchronisierungsereignisse und -szenarien, die bei der Verwendung von Amazon Cognito Sync auftreten können, problemlos 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 Synchronisation eine Ausnahme auftritt.
@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 mitzuteilen, SDK 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. Das userInfo
wird den Schlüsseldatensatz enthalten, der den Namen der zu synchronisierenden Datenmenge enthält, und die Schlüsselschlüssel, die NSArray alle Schlüssel enthalten, die übertragen wurden.
AWSCognitoDidChangeLocalValueFromRemoteNotification
Wird aufgerufen, wenn ein lokaler Wert sich aufgrund eines Synchronisationsvorgangs ändert. Das userInfo
wird den Schlüsseldatensatz enthalten, der den Namen der zu synchronisierenden Datenmenge enthält, und die Schlüsselschlüssel, die einen Teil NSArray der geänderten Datensatzschlüssel enthalten.
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 können AWSCognitoRecordConflictHandler Sie die standardmäßige Konfliktlösung ändern. Der AWSCognitoConflict Eingabeparameterkonflikt enthält ein AWSCognitoRecord Objekt sowohl für die lokal zwischengespeicherten Daten als auch für den widersprüchlichen Datensatz im Synchronisierungsspeicher. Mit dem können AWSCognitoConflict Sie den Konflikt mit dem lokalen Datensatz lösen: [Conflict resolveWithLocal Record], dem Remote-Datensatz: [Conflict resolveWithRemote Record] oder einem brandneuen Wert: [ resolveWithValueconflict: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. Der enthält userInfo
den Schlüsseldatensatz, der den Namen des zu synchronisierenden Datensatzes enthält, und die Schlüsselschlüssel, die eine Anzahl NSArray von Datensatzschlüsseln enthalten, die gedrückt wurden.
AWSCognitoDidChangeLocalValueFromRemoteNotification
Wird aufgerufen, wenn ein lokaler Wert sich aufgrund eines Synchronisationsvorgangs ändert. Das userInfo
wird den Schlüsseldatensatz enthalten, der den Namen der zu synchronisierenden Datenmenge enthält, und die Schlüsselschlüssel, die einen Teil NSArray der geänderten Datensatzschlüssel enthalten.
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. Mit dem können AWSCognitoConflict
Sie den Konflikt mit dem lokalen Datensatz lösen: [conflict resolveWithLocal Record], dem Remote-Datensatz: [conflict resolveWithRemote Record] oder einem brandneuen Wert: [conflict:value resolveWithValue]. 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; }