Gestionar las devoluciones de llamadas de eventos

Si es la primera vez que utiliza Amazon Cognito Sync, utilice AWS AppSync. Al igual que Amazon Cognito Sync, AWS AppSync es un servicio para sincronizar los datos de las aplicaciones entre dispositivos.

Con este, se pueden sincronizar los datos de usuarios, como las preferencias de aplicación o el estado del juego. También amplía estas funcionalidades, ya que permite que varios usuarios se sincronicen y colaboren en tiempo real sobre los datos compartidos.

Como desarrollador de Amazon Cognito Sync, puede implementar varias devoluciones de llamada para gestionar diferentes eventos y escenarios de sincronización. La SyncCallback interfaz de Android SDK configura las notificaciones sobre la sincronización de conjuntos de datos, incluso onSuccess() cuando un conjunto de datos se descarga correctamente, onFailure() cuando se produce una excepción y onConflict() para resolver conflictos entre los datos locales y remotos.

En iOSSDK, puedes registrarte para recibir notificaciones similares AWSCognitoDidStartSynchronizeNotification y configurar controladores como el AWSCognitoRecordConflictHandler para la resolución de conflictos. Las JavaScript plataformas Unity y Xamarin tienen mecanismos de devolución de llamadas análogos. Al implementar estas devoluciones de llamada, la aplicación puede gestionar sin problemas los distintos eventos y escenarios de sincronización que se pueden producir al utilizar Amazon Cognito Sync.

Android

SyncCallback Interfaz

Si implementa la interfaz SyncCallback, puede recibir en la aplicación notificaciones acerca de la sincronización del conjunto de datos. De esta manera, la aplicación puede tomar decisiones activas acerca de la eliminación de datos locales, la combinación o no de perfiles autenticados y la solución de los conflictos de sincronización. Debe aplicar los métodos siguientes, obligatorios en la interfaz:

• onSuccess()

• onFailure()

• onConflict()

• onDatasetDeleted()

• onDatasetsMerged()

Tenga en cuenta que, si no quiere especificar todas las devoluciones de llamadas, también puede utilizar la clase DefaultSyncCallback, que proporciona implementaciones vacías de forma predeterminada para todos ellas.

onSuccess

La devolución de llamada onSuccess() se activa cuando se descarga correctamente un conjunto de datos desde el almacén de sincronización.

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

onFailure

onFailure() se invoca si se produce una excepción durante la sincronización.

@Override
public void onFailure(DataStorageException dse) {
}

onConflict

Pueden producirse conflictos si la misma clave se ha modificado en el almacén local y en el almacén de sincronización. El método onConflict() se encarga de la resolución de conflictos. Si no implementa este método, el cliente de Amazon Cognito Sync utiliza de forma predeterminada el cambio más reciente.

@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

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza la interfaz SyncCallback para confirmar si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. Implemente el onDatasetDeleted() método para decirle al cliente SDK qué hacer con los datos locales.

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

onDatasetMerged

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación a través del método 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

Notificaciones de sincronización

El cliente de Amazon Cognito generará una serie de eventos NSNotification durante una llamada de sincronización. Puede registrar la supervisión de dichas notificaciones mediante el NSNotificationCenter estándar:

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

Amazon Cognito es compatible con cinco tipos de notificaciones, que se indican a continuación.

AWSCognitoDidStartSynchronizeNotification

Se llamada cuando se inicia una operación se sincronización. El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado.

AWSCognitoDidEndSynchronizeNotification

Se llama cuando finaliza una operación de sincronización (correctamente o no). El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado.

AWSCognitoDidFailToSynchronizeNotification

Se llama cuando una operación de sincronización falla. El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado, y el error de clave que contiene el error que ha provocado el error.

AWSCognitoDidChangeRemoteValueNotification

Se llama cuando los cambios locales se envían de forma correcta a Amazon Cognito. userInfoContendrá el conjunto de datos clave, que es el nombre del conjunto de datos que se está sincronizando, y las claves clave, que contendrán una NSArray de las claves de registro que se ingresaron.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Se llama cuando un valor local cambia debido a una operación de sincronización. userInfoContendrá el conjunto de datos clave, que es el nombre del conjunto de datos que se está sincronizando, y las claves clave, que contendrán una serie de claves NSArray de registro que se han modificado.

Gestor de resolución de conflictos

Durante una operación de sincronización, pueden producirse conflictos si se ha modificado la misma clave en el almacén local y en el almacén de sincronización. Si no ha definido un gestor de resolución de conflictos, Amazon Cognito elige de forma predeterminada la actualización más reciente.

Al implementar y asignar una, AWSCognitoRecordConflictHandler puede modificar la resolución de conflictos predeterminada. El conflicto AWSCognitoConflict de parámetros de entrada contiene un AWSCognitoRecord objeto tanto para los datos en caché local como para el registro conflictivo del almacén de sincronización. AWSCognitoConflict Si lo usa, puede resolver el conflicto con el registro local: [registro de conflicto], el resolveWithLocal registro remoto: [registro de conflicto resolveWithRemote] o un valor completamente nuevo: [ resolveWithValueconflict:valor]. La devolución de un valor nulo a partir de este método, impide que prosiga la sincronización y los conflictos volverán a producirse la siguiente vez que se inicie el proceso de sincronización.

Puede configurar el gestor de resolución de conflictos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Gestor de supresión de conjuntos de datos

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza el AWSCognitoDatasetDeletedHandler para confirmar si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. Si no hay un AWSCognitoDatasetDeletedHandler implementado, los datos locales se purgarán automáticamente. Implemente un AWSCognitoDatasetDeletedHandler si desea conservar una copia de los datos locales antes de borrar o si desea conservar los datos locales.

Puede configurar el gestor de supresión del conjunto de datos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Gestor de combinación del conjuntos de datos

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación mediante DatasetMergeHandler. El gestor recibirá el nombre del conjunto de datos raíz, así como una gama de nombres de conjuntos de datos que están marcados como combinaciones del conjunto de datos raíz.

Si el DatasetMergeHandler no se implementa, no se tendrán en cuenta estos conjuntos de datos, pero se seguirá usando espacio hasta un máximo de 20 conjuntos de datos en total.

Puede configurar el gestor de combinación de conjuntos de datos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Notificaciones de sincronización

El cliente de Amazon Cognito generará una serie de eventos NSNotification durante una llamada de sincronización. Puede registrar la supervisión de dichas notificaciones mediante el NSNotificationCenter estándar:

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

Amazon Cognito es compatible con cinco tipos de notificaciones, que se indican a continuación.

AWSCognitoDidStartSynchronizeNotification

Se llamada cuando se inicia una operación se sincronización. El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado.

AWSCognitoDidEndSynchronizeNotification

Se llama cuando finaliza una operación de sincronización (correctamente o no). El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado.

AWSCognitoDidFailToSynchronizeNotification

Se llama cuando una operación de sincronización falla. El objeto userInfo contendrá el conjunto de datos de la clave, que corresponde al nombre del conjunto de datos sincronizado, y el error de clave que contiene el error que ha provocado el error.

AWSCognitoDidChangeRemoteValueNotification

Se llama cuando los cambios locales se envían de forma correcta a Amazon Cognito. userInfoContendrá el conjunto de datos clave, que es el nombre del conjunto de datos que se está sincronizando, y las claves clave, que contendrán una NSArray de las claves de registro que se presionaron.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Se llama cuando un valor local cambia debido a una operación de sincronización. userInfoContendrá el conjunto de datos clave, que es el nombre del conjunto de datos que se está sincronizando, y las claves clave, que contendrán una serie de claves NSArray de registro que se han modificado.

Gestor de resolución de conflictos

Durante una operación de sincronización, pueden producirse conflictos si se ha modificado la misma clave en el almacén local y en el almacén de sincronización. Si no ha definido un gestor de resolución de conflictos, Amazon Cognito elige de forma predeterminada la actualización más reciente.

La implementación y la asignación de un gestor AWSCognitoRecordConflictHandler le permite modificar la resolución de conflictos predeterminada. El conflicto del parámetro de entrada AWSCognitoConflict contiene un objeto AWSCognitoRecord para los datos almacenados en la memoria caché local y para el registro de conflicto en el almacén de sincronización. AWSCognitoConflictSi lo usa, puede resolver el conflicto con el registro local: [conflict resolveWithLocal Record], el registro remoto: [conflict resolveWithRemote Record] o un valor completamente nuevo: [ resolveWithValueconflict:value]. La devolución de un valor nulo a partir de este método, impide que prosiga la sincronización y los conflictos volverán a producirse la siguiente vez que se inicie el proceso de sincronización.

Puede configurar el gestor de resolución de conflictos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Gestor de supresión de conjuntos de datos

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza el AWSCognitoDatasetDeletedHandler para confirmar si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. Si no hay un AWSCognitoDatasetDeletedHandler implementado, los datos locales se purgarán automáticamente. Implemente un AWSCognitoDatasetDeletedHandler si desea conservar una copia de los datos locales antes de borrar o si desea conservar los datos locales.

Puede configurar el gestor de supresión del conjunto de datos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Gestor de combinación del conjuntos de datos

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación mediante DatasetMergeHandler. El gestor recibirá el nombre del conjunto de datos raíz, así como una gama de nombres de conjuntos de datos que están marcados como combinaciones del conjunto de datos raíz.

Si el DatasetMergeHandler no se implementa, no se tendrán en cuenta estos conjuntos de datos, pero se seguirá usando espacio hasta un máximo de 20 conjuntos de datos en total.

Puede configurar el gestor de combinación de conjuntos de datos en el nivel de cliente:

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

O en el nivel de conjunto de datos:

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

Devoluciones de llamadas de sincronización

Cuando ejecute synchronize() en un conjunto de datos, tiene la posibilidad de especificar devoluciones de llamadas para abordar cada uno de los estados siguientes:

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 devolución de llamada onSuccess() se activa cuando se actualiza correctamente un conjunto de datos desde el almacén de sincronización. Si no define una devolución de llamada, la sincronización se logrará silenciosamente.

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

onFailure()

Se llama a onFailure() si se produce una excepción durante la sincronización. Si no define una devolución de llamada, la sincronización fallará silenciosamente.

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

onConflict()

Pueden producirse conflictos si la misma clave se ha modificado en el almacén local y en el almacén de sincronización. El método onConflict() se encarga de la resolución de conflictos. Si no implementa este método, la sincronización se anulará cuando exista un conflicto.

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

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza la devolución de llamada onDatasetDeleted() para decidir si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. De forma predeterminada, no se eliminará el conjunto de datos.

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

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación mediante la devolución de llamada onDatasetsMerged().

onDatasetMerged: function(dataset, datasetNames, callback) {

   // Return true to continue the synchronization process.
   // Return false to handle dataset merges outside the synchronization callback.

   return callback(false);

}

Unity

Después de abrir o crear un conjunto de datos, puede configurar diferentes devoluciones de llamadas al conjunto de datos, que se activarán cuando use el método Synchronize. A continuación, indicamos la forma de registrar las devoluciones de llamadas en ellos:

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

Tenga en cuenta que SyncSuccess y SyncFailure usan += en vez de = para que les pueda suscribir más de una devolución de llamada.

OnSyncSuccess

La devolución de llamada OnSyncSuccess se activa cuando se actualiza correctamente un conjunto de datos desde la nube. Si no define una devolución de llamada, la sincronización se logrará silenciosamente.

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

OnSyncFailure

Se llama a OnSyncFailure si se produce una excepción durante la sincronización. Si no define una devolución de llamada, la sincronización fallará silenciosamente.

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

Pueden producirse conflictos si la misma clave se ha modificado en el almacén local y en el almacén de sincronización. La devolución de llamada OnSyncConflict se encarga de la resolución de conflictos. Si no implementa este método, la sincronización se anulará cuando exista un conflicto.

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

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza la devolución de llamada OnDatasetDeleted para decidir si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. De forma predeterminada, no se eliminará el conjunto de datos.

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

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación mediante la devolución de llamada 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

Después de abrir o crear un conjunto de datos, puede configurar diferentes devoluciones de llamadas al conjunto de datos, que se activarán cuando use el método Synchronize. A continuación, indicamos la forma de registrar las devoluciones de llamadas en ellos:

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

Tenga en cuenta que SyncSuccess y SyncFailure usan += en vez de = para que les pueda suscribir más de una devolución de llamada.

OnSyncSuccess

La devolución de llamada OnSyncSuccess se activa cuando se actualiza correctamente un conjunto de datos desde la nube. Si no define una devolución de llamada, la sincronización se logrará silenciosamente.

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

OnSyncFailure

Se llama a OnSyncFailure si se produce una excepción durante la sincronización. Si no define una devolución de llamada, la sincronización fallará silenciosamente.

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

Pueden producirse conflictos si la misma clave se ha modificado en el almacén local y en el almacén de sincronización. La devolución de llamada OnSyncConflict se encarga de la resolución de conflictos. Si no implementa este método, la sincronización se anulará cuando exista un conflicto.

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

Cuando se elimina un conjunto de datos, el cliente de Amazon Cognito utiliza la devolución de llamada OnDatasetDeleted para decidir si la copia del conjunto de datos que está almacenada en la memoria caché local se tiene que eliminar también. De forma predeterminada, no se eliminará el conjunto de datos.

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

Cuando se vinculan dos identidades que anteriormente no estaban conectadas, todos sus conjuntos de datos se combinan. Las aplicaciones reciben una notificación de la combinación mediante la devolución de llamada 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;
}