Tratamento de retornos de chamada de eventos - Amazon Cognito
AndroidiOS – Objective-CiOS – SwiftJavaScriptUnityXamarin

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tratamento de retornos de chamada de eventos

Se você for novo com o Amazon Cognito Sync, use o AWS AppSync. Assim como o Amazon Cognito Sync, AWS AppSync é um serviço para sincronizar dados de aplicativos entre dispositivos.

Ele permite que dados do usuário, como preferências de aplicações ou estado de jogos, sejam sincronizados. Ele também amplia essas capacidades ao permitir que vários usuários sincronizem e colaborem em tempo real com dados compartilhados.

Como desenvolvedor do Amazon Cognito Sync, você pode implementar vários retornos de chamada para lidar com diferentes eventos e cenários de sincronização. A SyncCallback interface do Android SDK configura notificações sobre a sincronização do conjunto de dados, inclusive onSuccess() quando um conjunto de dados é baixado com sucesso, onFailure() quando ocorre uma exceção e onConflict() para resolver conflitos entre dados locais e remotos.

No iOSSDK, você pode se registrar para receber notificações semelhantes AWSCognitoDidStartSynchronizeNotification e definir manipuladores como o AWSCognitoRecordConflictHandler para resolução de conflitos. As JavaScript plataformas Unity e Xamarin têm mecanismos de retorno de chamada análogos. Quando você implementa esses retornos de chamada, seu aplicativo pode lidar perfeitamente com os vários eventos e cenários de sincronização que podem ocorrer ao usar o Amazon Cognito Sync.

Android

SyncCallback Interface

Ao implementar a interface SyncCallback, você poderá receber notificações sobre a sincronização de conjuntos de dados em seu aplicativo. O aplicativo poderá, então, tomar decisões ativas sobre a exclusão de dados locais, mesclando perfis autenticados e não autenticados e resolvendo conflitos de sincronização. Você deverá implementar os seguintes métodos, que são exigidos pela interface:

  • onSuccess()

  • onFailure()

  • onConflict()

  • onDatasetDeleted()

  • onDatasetsMerged()

Observe que, se você não especificar todos os retornos de chamada, também poderá usar a classe DefaultSyncCallback, que fornece implementações vazias padrão para todos eles.

onSuccess

O retorno de chamada onSuccess() é acionado quando um conjunto de dados é obtido por download no repositório de sincronização.

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

onFailure

onFailure() é chamado se ocorrer uma exceção durante a sincronização.

@Override
public void onFailure(DataStorageException dse) {
}

onConflict

Podem surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. O método onConflict() se encarrega da resolução de conflitos. Se você não implementar esse método, o cliente do Amazon Cognito Sync adotará como comportamento padrão o uso da alteração mais recente.

@Override
public boolean onConflict(Dataset dataset, final List<SyncConflict> conflicts) {
    List<Record> resolvedRecords = new ArrayList<Record>();
    for (SyncConflict conflict : conflicts) {
        /* resolved by taking remote records */
        resolvedRecords.add(conflict.resolveWithRemoteRecord());

        /* alternately take the local records */
        // resolvedRecords.add(conflict.resolveWithLocalRecord());

        /* or customer logic, say concatenate strings */
        // String newValue = conflict.getRemoteRecord().getValue()
        //     + conflict.getLocalRecord().getValue();
        // resolvedRecords.add(conflict.resolveWithValue(newValue);
    }
    dataset.resolve(resolvedRecords);

    // return true so that synchronize() is retried after conflicts are resolved
    return true;
}

onDatasetDeleted

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa a interface SyncCallback para confirmar se a cópia do conjunto de dados armazenada em cache local também será excluída. Implemente o onDatasetDeleted() método para dizer ao cliente SDK o que fazer com os dados locais.

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

onDatasetMerged

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do 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

Notificações de sincronização

O cliente do Amazon Cognito emitirá diversos eventos de NSNotification durante uma chamada de sincronização. Você pode se registrar para monitorar essas notificações por meio do NSNotificationCenter padrão:

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

O Amazon Cognito é compatível com os cinco tipos de notificação listados a seguir.

AWSCognitoDidStartSynchronizeNotification

Chamado quando uma operação de sincronização está iniciando. O userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado.

AWSCognitoDidEndSynchronizeNotification

Chamado quando uma operação de sincronização é concluída (seja ela bem-sucedida ou não). O userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado.

AWSCognitoDidFailToSynchronizeNotification

Chamado quando uma operação de sincronização apresenta falha. userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado, e o erro de chave, que conterá o erro que ocasionou a falha.

AWSCognitoDidChangeRemoteValueNotification

Chamado quando alterações locais são enviadas com êxito ao Amazon Cognito. Eles userInfo conterão o conjunto de dados chave, que é o nome do conjunto de dados que está sendo sincronizado, e as chaves principais, que conterão as chaves NSArray de registro enviadas.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Chamado quando um valor local é alterado devido a uma operação de sincronização. Eles userInfo conterão o conjunto de dados chave, que é o nome do conjunto de dados que está sendo sincronizado, e as chaves principais, que conterão uma NSArray das chaves de registro que foram alteradas.

Handler de resolução de conflitos

Durante uma operação de sincronização, poderão surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. Se você não definir um handler de resolução de conflitos, o Amazon Cognito assumirá como comportamento padrão a atualização mais recente.

Ao implementar e atribuir um, AWSCognitoRecordConflictHandler você pode alterar a resolução padrão de conflitos. O conflito AWSCognitoConflict de parâmetros de entrada contém um AWSCognitoRecord objeto para os dados em cache locais e para o registro conflitante no armazenamento de sincronização. Usando o, AWSCognitoConflict você pode resolver o conflito com o registro local: [conflict resolveWithLocal Record], o registro remoto: [conflict resolveWithRemote Record] ou um valor totalmente novo: [ resolveWithValueconflict:value]. O resultado nil retornado por esse método impede que a sincronização continue, e os conflitos serão apresentados novamente na próxima vez que o processo de sincronização for iniciado.

Você pode definir o handler de resolução de conflitos no nível do cliente:

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

Ou no nível do conjunto de dados:

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

Handler de conjunto de dados excluído

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa o AWSCognitoDatasetDeletedHandler para confirmar se a cópia do conjunto de dados armazenada em cache local também será excluída. Se nenhum AWSCognitoDatasetDeletedHandler for implementado, os dados locais serão removidos automaticamente. Implemente um AWSCognitoDatasetDeletedHandler se quiser manter uma cópia dos dados locais antes da limpeza ou os próprios dados locais.

Você pode definir o handler de conjunto de dados excluído no nível do cliente:

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

Ou no nível do conjunto de dados:

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

Handler de mesclagem do conjunto de dados

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do método DatasetMergeHandler. O handler receberá o nome do conjunto de dados raiz, bem como uma matriz de nomes de conjunto de dados que são marcados como mesclagens do conjunto de dados raiz.

Se nenhum DatasetMergeHandler for implementado, esses conjuntos de dados serão ignorados, mas continuarão utilizando o espaço dos 20 conjuntos de dados da identidade.

Você pode definir o handler de mesclagem no nível do 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];
    }
};

Ou no nível do conjunto de dados:

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

Notificações de sincronização

O cliente do Amazon Cognito emitirá diversos eventos de NSNotification durante uma chamada de sincronização. Você pode se registrar para monitorar essas notificações por meio do NSNotificationCenter padrão:

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

O Amazon Cognito é compatível com os cinco tipos de notificação listados a seguir.

AWSCognitoDidStartSynchronizeNotification

Chamado quando uma operação de sincronização está iniciando. O userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado.

AWSCognitoDidEndSynchronizeNotification

Chamado quando uma operação de sincronização é concluída (seja ela bem-sucedida ou não). O userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado.

AWSCognitoDidFailToSynchronizeNotification

Chamado quando uma operação de sincronização apresenta falha. userInfo conterá o conjunto de dados de chaves, que equivale ao conjunto de dados que está sendo sincronizado, e o erro de chave, que conterá o erro que ocasionou a falha.

AWSCognitoDidChangeRemoteValueNotification

Chamado quando alterações locais são enviadas com êxito ao Amazon Cognito. Eles userInfo conterão o conjunto de dados chave, que é o nome do conjunto de dados que está sendo sincronizado, e as chaves principais, que conterão as chaves NSArray de registro enviadas.

AWSCognitoDidChangeLocalValueFromRemoteNotification

Chamado quando um valor local é alterado devido a uma operação de sincronização. Eles userInfo conterão o conjunto de dados chave, que é o nome do conjunto de dados que está sendo sincronizado, e as chaves principais, que conterão uma NSArray das chaves de registro que foram alteradas.

Handler de resolução de conflitos

Durante uma operação de sincronização, poderão surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. Se você não definir um handler de resolução de conflitos, o Amazon Cognito assumirá como comportamento padrão a atualização mais recente.

Ao implementar e atribuir um AWSCognitoRecordConflictHandler, você pode alterar a resolução de conflitos padrão. O parâmetro de entrada AWSCognitoConflict contém um objeto AWSCognitoRecord para os dados armazenados em cache local e para o registro conflitante no repositório de sincronização. Usando o, AWSCognitoConflict você pode resolver o conflito com o registro local: [conflict resolveWithLocal Record], o registro remoto: [conflict resolveWithRemote Record] ou um valor totalmente novo: [ resolveWithValueconflict:value]. O resultado nil retornado por esse método impede que a sincronização continue, e os conflitos serão apresentados novamente na próxima vez que o processo de sincronização for iniciado.

Você pode definir o handler de resolução de conflitos no nível do cliente:

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

Ou no nível do conjunto de dados:

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

Handler de conjunto de dados excluído

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa o AWSCognitoDatasetDeletedHandler para confirmar se a cópia do conjunto de dados armazenada em cache local também será excluída. Se nenhum AWSCognitoDatasetDeletedHandler for implementado, os dados locais serão removidos automaticamente. Implemente um AWSCognitoDatasetDeletedHandler se quiser manter uma cópia dos dados locais antes da limpeza ou os próprios dados locais.

Você pode definir o handler de conjunto de dados excluído no nível do cliente:

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

Ou no nível do conjunto de dados:

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

Manipulador de mesclagem do conjunto de dados

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do método DatasetMergeHandler. O handler receberá o nome do conjunto de dados raiz, bem como uma matriz de nomes de conjunto de dados que são marcados como mesclagens do conjunto de dados raiz.

Se nenhum DatasetMergeHandler for implementado, esses conjuntos de dados serão ignorados, mas continuarão utilizando o espaço dos 20 conjuntos de dados da identidade.

Você pode definir o handler de mesclagem no nível do 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()
        }
    }
}

Ou no nível do conjunto de dados:

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

Retornos de chamada de sincronização

Ao executar um synchronize() em um conjunto de dados, você poderá especificar retornos de chamada para lidar com cada um dos estados a seguir:

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

O retorno de chamada onSuccess() é acionado quando um conjunto de dados é atualizado com êxito no repositório de sincronização. Se você não definir um retorno de chamada, a sincronização será concluída com êxito silenciosamente.

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

onFailure()

onFailure() será chamado se ocorrer uma exceção durante a sincronização. Se você não definir um retorno de chamada, a sincronização apresentará falha silenciosamente.

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

onConflict()

Podem surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. O método onConflict() se encarrega da resolução de conflitos. Se você não implementar esse método, a sincronização será anulada quando houver um conflito.

onConflict: function(dataset, conflicts, callback) {

   var resolved = [];

   for (var i=0; i<conflicts.length; i++) {

      // Take remote version.
      resolved.push(conflicts[i].resolveWithRemoteRecord());

      // Or... take local version.
      // resolved.push(conflicts[i].resolveWithLocalRecord());

      // Or... use custom logic.
      // var newValue = conflicts[i].getRemoteRecord().getValue() + conflicts[i].getLocalRecord().getValue();
      // resolved.push(conflicts[i].resovleWithValue(newValue);

   }

   dataset.resolve(resolved, function() {
      return callback(true);
   });

   // Or... callback false to stop the synchronization process.
   // return callback(false);

}

onDatasetDeleted()

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa o retorno de chamada onDatasetDeleted() para decidir se a cópia do conjunto de dados armazenada em cache local também será excluída. Por padrão, o conjunto de dados não será excluído.

onDatasetDeleted: function(dataset, datasetName, callback) {

   // Return true to delete the local copy of the dataset.
   // Return false to handle deleted datasets outside the synchronization callback.

   return callback(true);

}

onDatasetMerged()

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do retorno de chamada 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

Depois que você abrir ou criar um conjunto de dados, poderá definir diferentes retornos de chamada para ele, que serão acionados quando você usar o método synchronize. Essa é a maneira de registrar os retornos de chamada neles:

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

Observe que SyncSuccess e SyncFailure usam +=, em vez de =, para que você possa inscrever mais de um retorno de chamada neles.

OnSyncSuccess

O retorno de chamada OnSyncSuccess é acionado quando um conjunto de dados é atualizado com êxito na nuvem. Se você não definir um retorno de chamada, a sincronização será concluída com êxito silenciosamente.

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

OnSyncFailure

OnSyncFailure será chamado se ocorrer uma exceção durante a sincronização. Se você não definir um retorno de chamada, a sincronização apresentará falha 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

Podem surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. O retorno de chamada OnSyncConflict se encarrega da resolução de conflitos. Se você não implementar esse método, a sincronização será anulada quando houver um conflito.

private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Debug.LogWarning("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Debug.LogWarning("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}

OnDatasetDeleted

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa o retorno de chamada OnDatasetDeleted para decidir se a cópia do conjunto de dados armazenada em cache local também será excluída. Por padrão, o conjunto de dados não será excluído.

private bool HandleDatasetDeleted(Dataset dataset)
  {
      Debug.Log(dataset.Metadata.DatasetName + " Dataset has been deleted");
      // Do clean up if necessary
      // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
      return true;
  }

OnDatasetMerged

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do retorno de chamada 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

Depois que você abrir ou criar um conjunto de dados, poderá definir diferentes retornos de chamada para ele, que serão acionados quando você usar o método synchronize. Essa é a maneira de registrar os retornos de chamada neles:

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

Observe que SyncSuccess e SyncFailure usam +=, em vez de =, para que você possa inscrever mais de um retorno de chamada neles.

OnSyncSuccess

O retorno de chamada OnSyncSuccess é acionado quando um conjunto de dados é atualizado com êxito na nuvem. Se você não definir um retorno de chamada, a sincronização será concluída com êxito silenciosamente.

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

OnSyncFailure

OnSyncFailure será chamado se ocorrer uma exceção durante a sincronização. Se você não definir um retorno de chamada, a sincronização apresentará falha 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

Podem surgir conflitos se a mesma chave for modificada no repositório local e no repositório de sincronização. O retorno de chamada OnSyncConflict se encarrega da resolução de conflitos. Se você não implementar esse método, a sincronização será anulada quando houver um conflito.

private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Console.WriteLine("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Console.WriteLine("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}

OnDatasetDeleted

Quando um conjunto de dados é excluído, o cliente do Amazon Cognito usa o retorno de chamada OnDatasetDeleted para decidir se a cópia do conjunto de dados armazenada em cache local também será excluída. Por padrão, o conjunto de dados não será excluído.

private bool HandleDatasetDeleted(Dataset dataset)
{
    Console.WriteLine(dataset.Metadata.DatasetName + " Dataset has been deleted");
    // Do clean up if necessary
    // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
    return true;
}

OnDatasetMerged

Quando duas identidades anteriormente não conectadas são vinculadas, todos os conjuntos de dados serão mesclados. Os aplicativos são notificados da mesclagem por meio do retorno de chamada 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;
}