Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Sincronización de datos entre clientes
****
Si es la primera vez que utiliza Amazon Cognito Sync, utilice [AWS AppSync](https://aws.amazon.com/appsync/). Al igual que Amazon Cognito Sync, AWS AppSync es un servicio para sincronizar los datos de las aplicaciones en todos los 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.
Con Amazon Cognito, puede guardar los datos de usuarios en conjuntos de datos que contienen pares clave-valor. Amazon Cognito asocia estos datos a una entidad en el grupo de identidades, de modo que su aplicación puede acceder a ella a través de los inicios de sesión y los dispositivos. Para sincronizar estos datos entre el servicio de Amazon Cognito y los dispositivos de un usuario final, invoque el método de sincronización. Cada conjunto de datos puede tener un tamaño máximo de 1 MB. Puede asociar hasta 20 conjuntos de datos a una identidad.
El cliente de Amazon Cognito Sync crea una memoria caché local para los datos de identidad. Cuando la aplicación lee y escribe claves se comunica con la memoria caché local. Esta comunicación garantiza que todos los cambios realizados en el dispositivo estén disponibles inmediatamente en el dispositivo, incluso si está sin conexión. Cuando se llama al método de sincronización, los cambios que provienen del servicio se envían al dispositivo, mientras que todos los cambios locales se transmiten al servicio. Ahora los cambios ya se podrán sincronizar con otros dispositivos.
## Inicialización del cliente de Amazon Cognito Sync
Para inicializar el cliente de Amazon Cognito Sync, primero debe crear un proveedor de credenciales. El proveedor de credenciales adquiere AWS credenciales temporales para que su aplicación pueda acceder a sus AWS recursos. También debe importar los archivos de encabezado necesarios. Ejecute los pasos siguientes para inicializar el cliente de Amazon Cognito Sync.
### Android
1. Cree un proveedor de credenciales siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Importe el paquete de Amazon Cognito del siguiente modo: `import com.amazonaws.mobileconnectors.cognito.*;`
1. Inicialice Amazon Cognito Sync. Transfiera el contexto de la aplicación para Android, el ID del grupo de identidades, un Región de AWS y un proveedor de credenciales de Amazon Cognito inicializado de la siguiente manera:
```
CognitoSyncManager client = new CognitoSyncManager(
getApplicationContext(),
Regions.YOUR_REGION,
credentialsProvider);
```
### iOS - Objective-C
1. Cree un proveedor de credenciales siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Importe `AWSCore` y `Cognito` e inicialice `AWSCognito` de la siguiente manera:
```
#import
#import
AWSCognito *syncClient = [AWSCognito defaultCognito];
```
1. Si la estás usando CocoaPods, `` sustitúyela por`AWSCore.h`. Siga la misma sintaxis para la importación de Amazon Cognito.
### iOS - Swift
1. Cree un proveedor de credenciales siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Importe e inicialice `AWSCognito` de la siguiente manera:
```
import AWSCognito
let syncClient = AWSCognito.default()!
```
### JavaScript
1. Descargue [Amazon Cognito Sync Manager para](https://github.com/aws/amazon-cognito-js). JavaScript
1. Incluya la biblioteca del administrador de sincronización en el proyecto.
1. Cree un proveedor de credenciales siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Inicialice el administrador de sincronizaciones de la siguiente manera:
```
var syncManager = new AWS.CognitoSyncManager();
```
### Unity
1. Cree una instancia de `CognitoAWSCredentials`, siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Cree una instancia de `CognitoSyncManager`. Transfiera el objeto `CognitoAwsCredentials` y un `AmazonCognitoSyncConfig`, e incluya al menos el conjunto Región, de la siguiente manera:
```
AmazonCognitoSyncConfig clientConfig = new AmazonCognitoSyncConfig { RegionEndpoint = REGION };
CognitoSyncManager syncManager = new CognitoSyncManager(credentials, clientConfig);
```
### Xamarin
1. Cree una instancia de `CognitoAWSCredentials`, siguiendo las instrucciones descritas en [Obtención de credenciales](getting-credentials.md).
1. Cree una instancia de `CognitoSyncManager`. Transfiera el objeto `CognitoAwsCredentials` y un `AmazonCognitoSyncConfig`, e incluya al menos el conjunto Región, de la siguiente manera:
```
AmazonCognitoSyncConfig clientConfig = new AmazonCognitoSyncConfig { RegionEndpoint = REGION };
CognitoSyncManager syncManager = new CognitoSyncManager(credentials, clientConfig);
```
## Descripción de los conjuntos de datos
Amazon Cognito organiza los datos del perfil del usuario en conjuntos de datos. Cada conjunto de datos puede contener hasta 1 MB de datos en forma de pares de clave-valor. Un conjunto de datos es la entidad más precisa que puede sincronizar. Las operaciones de lectura y escritura realizadas en un conjunto de datos solo afectan al almacén local mientras no se invoque el método de sincronización. Amazon Cognito identifica un conjunto de datos mediante una cadena única. Puede crear un conjunto de datos nuevo o abrir uno existente, tal como se muestra a continuación.
### Android
```
Dataset dataset = client.openOrCreateDataset("datasetname");
```
Para eliminar un conjunto de datos, primero tiene que llamar al método que lo eliminará del almacenamiento local y, a continuación, al método `synchronize` a fin de eliminar el conjunto de datos de Amazon Cognito del siguiente modo:
```
dataset.delete();
dataset.synchronize(syncCallback);
```
### iOS - Objective-C
```
AWSCognitoDataset *dataset = [syncClient openOrCreateDataset:@"myDataSet"];
```
Para eliminar un conjunto de datos, primero tiene que llamar al método que lo eliminará del almacenamiento local y, a continuación, al método `synchronize` a fin de eliminar el conjunto de datos de Amazon Cognito del siguiente modo:
```
[dataset clear];
[dataset synchronize];
```
### iOS - Swift
```
let dataset = syncClient.openOrCreateDataset("myDataSet")!
```
Para eliminar un conjunto de datos, primero tiene que llamar al método que lo eliminará del almacenamiento local y, a continuación, al método `synchronize` a fin de eliminar el conjunto de datos de Amazon Cognito del siguiente modo:
```
dataset.clear()
dataset.synchronize()
```
### JavaScript
```
syncManager.openOrCreateDataset('myDatasetName', function(err, dataset) {
// ...
});
```
### Unity
```
string myValue = dataset.Get("myKey");
dataset.Put("myKey", "newValue");
```
Para eliminar una clave de un conjunto de datos, utilice `Remove` de la siguiente manera:
```
dataset.Remove("myKey");
```
### Xamarin
```
Dataset dataset = syncManager.OpenOrCreateDataset("myDatasetName");
```
Para eliminar un conjunto de datos, primero tiene que llamar al método que lo eliminará del almacenamiento local y, a continuación, al método `synchronize` a fin de eliminar el conjunto de datos de Amazon Cognito del siguiente modo:
```
dataset.Delete();
dataset.SynchronizeAsync();
```
## Lectura y escritura de datos en conjuntos de datos
Los conjuntos de datos de Amazon Cognito funcionan como diccionarios, con valores accesibles por clave: Puede leer, añadir o modificar las claves y los valores de un conjunto de datos como si el conjunto de datos fuese un diccionario, tal como se muestra en el ejemplo.
Tenga en cuenta que los valores escritos en un conjunto de datos solo afectan a la copia local de los datos almacenada en la caché hasta que llame al método de sincronización.
### Android
```
String value = dataset.get("myKey");
dataset.put("myKey", "my value");
```
### iOS - Objective-C
```
[dataset setString:@"my value" forKey:@"myKey"];
NSString *value = [dataset stringForKey:@"myKey"];
```
### iOS - Swift
```
dataset.setString("my value", forKey:"myKey")
let value = dataset.stringForKey("myKey")
```
### JavaScript
```
dataset.get('myKey', function(err, value) {
console.log('myRecord: ' + value);
});
dataset.put('newKey', 'newValue', function(err, record) {
console.log(record);
});
dataset.remove('oldKey', function(err, record) {
console.log(success);
});
```
### Unity
```
string myValue = dataset.Get("myKey");
dataset.Put("myKey", "newValue");
```
### Xamarin
```
//obtain a value
string myValue = dataset.Get("myKey");
// Create a record in a dataset and synchronize with the server
dataset.OnSyncSuccess += SyncSuccessCallback;
dataset.Put("myKey", "myValue");
dataset.SynchronizeAsync();
void SyncSuccessCallback(object sender, SyncSuccessEventArgs e) {
// Your handler code here
}
```
### Android
Para eliminar claves de un conjunto de datos, utilice el método `remove` del siguiente modo:
```
dataset.remove("myKey");
```
### iOS - Objective-C
Para eliminar una clave de un conjunto de datos, utilice `removeObjectForKey` de la siguiente manera:
```
[dataset removeObjectForKey:@"myKey"];
```
### iOS - Swift
Para eliminar una clave de un conjunto de datos, utilice `removeObjectForKey` de la siguiente manera:
```
dataset.removeObjectForKey("myKey")
```
### Unity
Para eliminar una clave de un conjunto de datos, utilice `Remove` de la siguiente manera:
```
dataset.Remove("myKey");
```
### Xamarin
Puede utilizar `Remove` para eliminar una clave de un conjunto de datos:
```
dataset.Remove("myKey");
```
## Sincronización de datos locales con el almacén de sincronización
### Android
Mediante el método `synchronize`, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
```
dataset.synchronize(syncCallback);
```
El método `synchronize` recibe una implementación de la interfaz `SyncCallback`, tratada a continuación.
El método `synchronizeOnConnectivity()` intenta realizar la sincronización cuando la conectividad está disponible. Si la conectividad está disponible inmediatamente, `synchronizeOnConnectivity()` se comporta como `synchronize()`. De lo contrario, supervisará los cambios de conectividad y realizará la sincronización cuando la conectividad esté disponible. Si se llama varias veces a `synchronizeOnConnectivity()`, solo se mantendrá la última solicitud de sincronización y solo se desencadenará la última devolución de llamada. Si el conjunto de datos o la devolución de llamada se limpia de la memoria, este método no realizará una sincronización, y la devolución de llamada no se iniciará.
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).
### iOS - Objective-C
Mediante el método `synchronize`, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
El método `synchronize` es asíncrono y devuelve un objeto `AWSTask` para tratar la respuesta:
```
[[dataset synchronize] continueWithBlock:^id(AWSTask *task) {
if (task.isCancelled) {
// Task cancelled.
} else if (task.error) {
// Error while executing task.
} else {
// Task succeeded. The data was saved in the sync store.
}
return nil;
}];
```
El método `synchronizeOnConnectivity` intenta realizar la sincronización cuando el dispositivo dispone de conectividad. En primer lugar, `synchronizeOnConnectivity` comprueba la conectividad y, si el dispositivo está online, invoca inmediatamente a synchronize y devuelve el objeto `AWSTask` asociado al intento.
Si el dispositivo está sin conexión, `synchronizeOnConnectivity` 1) programa una sincronización para la siguiente vez que el dispositivo esté online y 2) devuelve un `AWSTask` con un resultado nulo. La sincronización programada solo es válida durante el ciclo de vida del objeto del conjunto de datos. Los datos no se sincronizan si se cierra la aplicación antes de recuperar la conectividad. Si quiere recibir una notificación cuando se producen eventos en la sincronización programada, debe añadir observadores de notificaciones encontradas en `AWSCognito`.
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).
### iOS - Swift
Mediante el método `synchronize`, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
El método `synchronize` es asíncrono y devuelve un objeto `AWSTask` para tratar la respuesta:
```
dataset.synchronize().continueWith(block: { (task) -> AnyObject? in
if task.isCancelled {
// Task cancelled.
} else if task.error != nil {
// Error while executing task
} else {
// Task succeeded. The data was saved in the sync store.
}
return task
})
```
El método `synchronizeOnConnectivity` intenta realizar la sincronización cuando el dispositivo dispone de conectividad. En primer lugar, `synchronizeOnConnectivity` comprueba la conectividad y, si el dispositivo está online, invoca inmediatamente a `synchronize` y devuelve el objeto `AWSTask` asociado al intento.
Si el dispositivo está sin conexión, `synchronizeOnConnectivity` 1) programa una sincronización para la siguiente vez que el dispositivo esté online y 2) devuelve un objeto `AWSTask` con un resultado nulo. La sincronización programada solo es válida durante el ciclo de vida del objeto del conjunto de datos. Los datos no se sincronizan si se cierra la aplicación antes de recuperar la conectividad. Si quiere recibir una notificación cuando se producen eventos en la sincronización programada, debe añadir observadores de notificaciones encontradas en `AWSCognito`.
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).
### JavaScript
Mediante el método `synchronize`, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
```
dataset.synchronize();
```
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).
### Unity
Con el método synchronize, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
```
dataset.Synchronize();
```
La sincronización se ejecutará de forma asíncrona y acabará llamando a una de las diversas devoluciones de llamadas que puede especificar en el conjunto de datos.
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).
### Xamarin
Mediante el método `synchronize`, se comparan los datos locales almacenados en la memoria caché con los datos guardados en el almacén de Amazon Cognito Sync. Los cambios remotos se extraen del almacén de Amazon Cognito Sync. Si se produce algún conflicto, se invoca la resolución de conflictos y los valores actualizados en el dispositivo se envían al servicio. Para sincronizar un conjunto de datos, llame a su método `synchronize`:
```
dataset.SynchronizeAsync();
```
Para obtener más información acerca de la sincronización de datos y las diversas devoluciones de llamada, consulte [Gestión de las devoluciones de llamada de eventos](handling-callbacks.md).