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](https://aws.amazon.com/appsync/). Wie Amazon Cognito Sync AWS AppSync ist es ein Dienst zur geräteübergreifenden Synchronisation von Anwendungsdaten.
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` Schnittstelle im 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.
Im iOS-SDK können Sie sich für ähnliche Benachrichtigungen registrieren `AWSCognitoDidStartSynchronizeNotification` und Handler wie den `AWSCognitoRecordConflictHandler` für die Konfliktlösung einrichten. Die Plattformen Unity JavaScript, Xamarin und Unity 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 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 conflicts) {
List resolvedRecords = new ArrayList();
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 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 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 ü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 Implementierung und Zuweisung eines können AWSCognito RecordConflictHandler Sie die standardmäßige Konfliktlösung ändern. Der AWSCognito Konflikt mit den Eingabeparametern Conflict enthält ein AWSCognito Record-Objekt sowohl für die lokal zwischengespeicherten Daten als auch für den widersprüchlichen Datensatz im Synchronisierungsspeicher. Mithilfe von AWSCognito Conflict können Sie den Konflikt mit dem lokalen Datensatz: [Conflict resolveWithLocal Record], dem Remote-Datensatz: [Conflict resolveWithRemote Record] oder einem brandneuen Wert: [ resolveWithValueconflict:value] lösen. 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
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` \$1= 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 mergedDatasetNames)
{
foreach (string name in mergedDatasetNames)
{
Dataset mergedDataset = syncManager.OpenOrCreateDataset(name);
//Lambda function to delete the dataset after fetching it
EventHandler lambda;
lambda = (object sender, SyncSuccessEvent e) => {
ICollection existingValues = localDataset.GetAll().Values;
ICollection 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` \$1= 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 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;
}
```