Créer une application Amazon Simple Notification Service (Amazon SNS)Activer la synchronisation en mode Push via la console Amazon Cognito.Utilisation de la synchronisation en mode Push dans votre application : Android Utilisation de la synchronisation en mode Push dans votre application : iOS - Objective-C Utilisation de la synchronisation en mode Push dans votre application : iOS - Swift

Synchronisation en mode Push

Si vous débutez avec Amazon Cognito Sync, utilisez AWS AppSync. Comme Amazon Cognito Sync, AWS AppSync est un service permettant de synchroniser des données d'application sur différents appareils.

Il permet de synchroniser les données utilisateur telles que des préférences de l'application ou l'état d'un jeu. Il étend également ces capacités en permettant à plusieurs utilisateurs de se synchroniser et de collaborer en temps réel sur des données partagées.

Amazon Cognito suit automatiquement l'association entre l'identité et les appareils. La fonctionnalité de synchronisation en mode push vous permet de vous assurer que chaque instance d'une identité donnée est informée en cas de modification de ses données. Tous les dispositifs associés à cette identité reçoivent une notification push silencieuse chaque fois que ses données changent dans l'espace de synchronisation.

Note

La synchronisation en mode Push n'est pas prise en charge par JavaScript, Unity ou Xamarin.

Pour pouvoir utiliser la synchronisation en mode Push, vous devez au préalable configurer votre compte en ce sens et activer la synchronisation en mode Push dans la console Amazon Cognito.

Créez et configurez une application Amazon SNS pour les plateformes prises en charge, comme décrit dans le Guide du développeur SNS.

Activer la synchronisation en mode Push via la console Amazon Cognito.

Vous pouvez activer la synchronisation en mode Push via la console Amazon Cognito. A partir de la page d'accueil de la console :

Cliquez sur le nom du groupe d'identités pour lequel vous souhaitez activer la synchronisation en mode Push. La page Dashboard (Tableau de bord) correspondant à votre groupe d'identités s'affiche.
Dans l'angle supérieur droit de la page Dashboard (Tableau de bord), cliquez sur Manage Identity Pools (Gérer les groupes d'identités). La page Identités fédérées s'ouvre.
Faites défiler l'écran vers le bas et cliquez sur Push synchronization (Synchronisation Push) pour développer cette option.
Dans le menu déroulant Service role (Rôle de service), sélectionnez le rôle IAM qui autorise Cognito à envoyer une notification SNS. Cliquez sur Create role (Créer un rôle) afin de créer ou de modifier les rôles associés à votre groupe d'identités dans la console AWS IAM.
Sélectionnez une application de plateforme, puis cliquez sur Save Changes (Enregistrer les modifications).
Autorisez SNS à accéder à votre application.

Dans la console AWS Identity and Access Management, configurez les rôles IAM pour qu'ils aient un accès Amazon SNS complet ou créez un rôle qui dispose d'un accès SNS complet. L'exemple suivant de politique d'approbation de rôle permet à Amazon Cognito Sync d'assumer un rôle IAM limité. Amazon Cognito Sync ne peut assumer le rôle que lorsqu'il le fait au nom du groupe d'identités dans la condition aws:SourceArn et du compte dans la condition aws:SourceAccount.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "cognito-sync.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "AWS:SourceAccount": "123456789012"
                },
                "ArnLike": {
                    "AWS:SourceArn": "arn:aws:cognito-identity:us-east-1:123456789012:identitypool/us-east-1:177a950c-2c08-43f0-9983-28727EXAMPLE"
                }
            }
        }
    ]
}

Pour en savoir plus sur les rôles IAM, consultez la section Rôles (délégation et fédération).

Utilisation de la synchronisation en mode Push dans votre application : Android

Votre application doit importer les services Google Play. Vous pouvez télécharger la dernière version du kit SDK Google Play via le gestionnaire Android SDK. Pour enregistrer votre application et recevoir un ID d'enregistrement de GCM, reportez-vous à la documentation Android relative à l'implémentation Android. Une fois que vous avez l'ID d'enregistrement, enregistrez l'appareil auprès d'Amazon Cognito, comme illustré dans l'extrait de code ci-dessous :


String registrationId = "MY_GCM_REGISTRATION_ID";
try {
    client.registerDevice("GCM", registrationId);
} catch (RegistrationFailedException rfe) {
    Log.e(TAG, "Failed to register device for silent sync", rfe);
} catch (AmazonClientException ace) {
    Log.e(TAG, "An unknown error caused registration for silent sync to fail", ace);
}

Vous pouvez désormais abonner un dispositif pour recevoir les mises à jour à partir d'un ensemble de données particulier :


Dataset trackedDataset = client.openOrCreateDataset("myDataset");
if (client.isDeviceRegistered()) {
    try {
        trackedDataset.subscribe();
    } catch (SubscribeFailedException sfe) {
        Log.e(TAG, "Failed to subscribe to datasets", sfe);
    } catch (AmazonClientException ace) {
        Log.e(TAG, "An unknown error caused the subscription to fail", ace);
    }
}

Pour arrêter de recevoir des notifications push à partir d'un ensemble de données, il vous suffit d'appeler la méthode de désinscription. Pour vous abonner à tous les ensembles de données (ou à un sous-ensemble spécifique) dans l'objet CognitoSyncManager, utilisez subscribeAll() :


if (client.isDeviceRegistered()) {
    try {
        client.subscribeAll();
    } catch (SubscribeFailedException sfe) {
        Log.e(TAG, "Failed to subscribe to datasets", sfe);
    } catch (AmazonClientException ace) {
        Log.e(TAG, "An unknown error caused the subscription to fail", ace);
    }
}

Dans votre implémentation de l'objet BroadcastReceiver Android, vous pouvez vérifier la dernière version de l'ensemble de données modifié et décider si votre application a besoin de procéder à une nouvelle synchronisation :


@Override
public void onReceive(Context context, Intent intent) {

    PushSyncUpdate update = client.getPushSyncUpdate(intent);

    // The update has the source (cognito-sync here), identityId of the
    // user, identityPoolId in question, the non-local sync count of the
    // data set and the name of the dataset. All are accessible through
    // relevant getters.

    String source = update.getSource();
    String identityPoolId = update.getIdentityPoolId();
    String identityId = update.getIdentityId();
    String datasetName = update.getDatasetName;
    long syncCount = update.getSyncCount;

    Dataset dataset = client.openOrCreateDataset(datasetName);

    // need to access last sync count. If sync count is less or equal to
    // last sync count of the dataset, no sync is required.

    long lastSyncCount = dataset.getLastSyncCount();
    if (lastSyncCount < syncCount) {
        dataset.synchronize(new SyncCallback() {
            // ...
        });
    }

}

Les clés suivantes sont disponibles dans la charge utile des notifications push :

source: synchronisation Cognito. Cette clé peut servir de facteur de différenciation entre les notifications.
identityPoolId : ID du groupe d'identités. Cette clé peut être utilisée pour la validation ou pour plus d'informations, bien qu'elle ne soit pas intégrale du point de vue du destinataire.
identityId : ID d'identité dans le groupe.
datasetName : nom de l'ensemble de données qui a été mis à jour. Cette clé est disponible pour l'appel openOrCreateDataset.
syncCount : nombre de synchronisations pour l'ensemble données distant. Vous pouvez utiliser cette clé comme méthode pour vous assurer que l'ensemble de données local est obsolète et que la synchronisation entrante est nouvelle.

Utilisation de la synchronisation en mode Push dans votre application : iOS - Objective-C

Pour obtenir un jeton de dispositif pour votre application, reportez-vous à la documentation Apple sur les demandes de notifications à distance. Une fois que vous recevez le jeton de l'appareil comme objet NSData à partir de l'APN, vous devez enregistrer l'appareil auprès d'Amazon Cognito à l'aide de la méthode registerDevice: du client de synchronisation, comme ci-dessous :


AWSCognito *syncClient = [AWSCognito defaultCognito];
    [[syncClient registerDevice: devToken] continueWithBlock:^id(AWSTask *task) {
        if(task.error){
            NSLog(@"Unable to registerDevice: %@", task.error);
        } else {
            NSLog(@"Successfully registered device with id: %@", task.result);
        }
        return nil;
      }
    ];

En mode débogage, le dispositif s'enregistre avec le sandbox APN. En mode release, il s'enregistrera avec des APN. Pour recevoir les mises à jour à partir d'une ensemble de données particulier, utilisez la méthode subscribe :


[[[syncClient openOrCreateDataset:@"MyDataset"] subscribe] continueWithBlock:^id(AWSTask *task) {
        if(task.error){
            NSLog(@"Unable to subscribe to dataset: %@", task.error);
        } else {
            NSLog(@"Successfully subscribed to dataset: %@", task.result);
        }
        return nil;
      }
    ];

Pour arrêter de recevoir des notifications push à partir d'un ensemble de données, il vous suffit d'appeler la méthode unsubscribe :


[[[syncClient openOrCreateDataset:@”MyDataset”] unsubscribe] continueWithBlock:^id(AWSTask *task) {
        if(task.error){
            NSLog(@"Unable to unsubscribe from dataset: %@", task.error);
        } else {
            NSLog(@"Successfully unsubscribed from dataset: %@", task.result);
        }
        return nil;
      }
    ];

Pour vous abonner à tous les ensembles de données dans l'objet AWSCognito, appelez subscribeAll :


[[syncClient subscribeAll] continueWithBlock:^id(AWSTask *task) {
        if(task.error){
            NSLog(@"Unable to subscribe to all datasets: %@", task.error);
        } else {
            NSLog(@"Successfully subscribed to all datasets: %@", task.result);
        }
        return nil;
      }
    ];

Avant d'appeler subscribeAll, veillez à effectuer une synchronisation au moins une fois au niveau de chaque ensemble de données pour qu'ils soient tous sur le serveur.

Pour répondre aux notifications push, vous devez implémenter la méthode didReceiveRemoteNotification dans le délégué d'application :


- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
    {
        [[NSNotificationCenter defaultCenter] postNotificationName:@"CognitoPushNotification" object:userInfo];
    }

Si vous publiez une notification à l'aide d'un gestionnaire de notification, vous pouvez y répondre ailleurs dans l'application où se trouve ce gestionnaire. Si vous vous abonnez à la notification comme ceci...


[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceivePushSync:)
    name: :@"CognitoPushNotification" object:nil];

… vous pouvez répondre à la notification comme suit :


- (void)didReceivePushSync:(NSNotification*)notification
    {
        NSDictionary * data = [(NSDictionary *)[notification object] objectForKey:@"data"];
        NSString * identityId = [data objectForKey:@"identityId"];
        NSString * datasetName = [data objectForKey:@"datasetName"];
        if([self.dataset.name isEqualToString:datasetName] && [self.identityId isEqualToString:identityId]){
            [[self.dataset synchronize] continueWithBlock:^id(AWSTask *task) {
                if(!task.error){
                    NSLog(@"Successfully synced dataset");
                }
                return nil;
            }];
        }
    }

Les clés suivantes sont disponibles dans la charge utile des notifications push :

source: synchronisation Cognito. Cette clé peut servir de facteur de différenciation entre les notifications.
identityPoolId : ID du groupe d'identités. Cette clé peut être utilisée pour la validation ou pour plus d'informations, bien qu'elle ne soit pas intégrale du point de vue du destinataire.
identityId : ID d'identité dans le groupe.
datasetName : nom de l'ensemble de données qui a été mis à jour. Cette clé est disponible pour l'appel openOrCreateDataset.
syncCount : nombre de synchronisations pour l'ensemble données distant. Vous pouvez utiliser cette clé comme méthode pour vous assurer que l'ensemble de données local est obsolète et que la synchronisation entrante est nouvelle.

Utilisation de la synchronisation en mode Push dans votre application : iOS - Swift

Pour obtenir un jeton de dispositif pour votre application, reportez-vous à la documentation Apple sur les demandes de notifications à distance. Une fois que vous recevez le jeton de l'appareil comme objet NSData à partir de l'APN, vous devez enregistrer l'appareil auprès d'Amazon Cognito à l'aide de la méthode registerDevice: du client de synchronisation, comme ci-dessous :


let syncClient = AWSCognito.default()
syncClient.registerDevice(devToken).continueWith(block: { (task: AWSTask!) -> AnyObject! in
    if (task.error != nil) {
        print("Unable to register device: " + task.error.localizedDescription)

    } else {
        print("Successfully registered device with id: \(task.result)")
    }
    return task
})


syncClient.openOrCreateDataset("MyDataset").subscribe().continueWith(block: { (task: AWSTask!) -> AnyObject! in
  if (task.error != nil) {
      print("Unable to subscribe to dataset: " + task.error.localizedDescription)

  } else {
      print("Successfully subscribed to dataset: \(task.result)")
  }
  return task
})

Pour arrêter de recevoir des notifications push à partir d'un ensemble de données, appelez la méthode unsubscribe :


syncClient.openOrCreateDataset("MyDataset").unsubscribe().continueWith(block: { (task: AWSTask!) -> AnyObject! in
  if (task.error != nil) {
      print("Unable to unsubscribe to dataset: " + task.error.localizedDescription)

  } else {
      print("Successfully unsubscribed to dataset: \(task.result)")
  }
  return task
})

Pour vous abonner à tous les ensembles de données dans l'objet AWSCognito, appelez subscribeAll :


syncClient.openOrCreateDataset("MyDataset").subscribeAll().continueWith(block: { (task: AWSTask!) -> AnyObject! in
  if (task.error != nil) {
      print("Unable to subscribe to all datasets: " + task.error.localizedDescription)

  } else {
      print("Successfully subscribed to all datasets: \(task.result)")
  }
  return task
})

Avant d'appeler subscribeAll, veillez à effectuer une synchronisation au moins une fois au niveau de chaque ensemble de données pour qu'ils soient tous sur le serveur.

Pour répondre aux notifications push, vous devez implémenter la méthode didReceiveRemoteNotification dans le délégué d'application :


func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject],
  fetchCompletionHandler completionHandler: (UIBackgroundFetchResult) -> Void) {
        NSNotificationCenter.defaultCenter().postNotificationName("CognitoPushNotification", object: userInfo)
})


NSNotificationCenter.defaultCenter().addObserver(observer:self,
   selector:"didReceivePushSync:",
   name:"CognitoPushNotification",
   object:nil)

… vous pouvez répondre à la notification comme suit :


func didReceivePushSync(notification: NSNotification) {
    if let data = (notification.object as! [String: AnyObject])["data"] as? [String: AnyObject] {
        let identityId = data["identityId"] as! String
        let datasetName = data["datasetName"] as! String

        if self.dataset.name == datasetName && self.identityId == identityId {
          dataset.synchronize().continueWithBlock {(task) -> AnyObject! in
              if task.error == nil {
                print("Successfully synced dataset")
              }
              return nil
          }
        }
    }
}

Les clés suivantes sont disponibles dans la charge utile des notifications push :

source: synchronisation Cognito. Cette clé peut servir de facteur de différenciation entre les notifications.
identityPoolId : ID du groupe d'identités. Cette clé peut être utilisée pour la validation ou pour plus d'informations, bien qu'elle ne soit pas intégrale du point de vue du destinataire.
identityId : ID d'identité dans le groupe.
datasetName : nom de l'ensemble de données qui a été mis à jour. Cette clé est disponible pour l'appel openOrCreateDataset.
syncCount : nombre de synchronisations pour l'ensemble données distant. Vous pouvez utiliser cette clé comme méthode pour vous assurer que l'ensemble de données local est obsolète et que la synchronisation entrante est nouvelle.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Gestion des rappels

Flux Amazon Cognito