Criar uma aplicação do Amazon Simple Notification Service (Amazon SNS)Habilitar a sincronização por push no console do Amazon Cognito Usar sincronização por push em sua aplicação: Android Usar sincronização por push em sua aplicação: iOS - Objective-C Usar sincronização por push em sua aplicação: iOS - Swift

Sincronização por push

Se você for novo com o Amazon Cognito Sync, use o AWS AppSync. Como o Amazon Cognito Sync, o AWS AppSync é um serviço para sincronizar dados de aplicações 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.

O Amazon Cognito rastreia automaticamente a associação entre identidade e dispositivos. Usando o recurso de sincronização por push, você pode garantir que cada instância de uma identidade específica será notificada quando os dados da identidade forem alterados. A sincronização por push garante que, sempre que os dados do repositório de sincronização forem alterados para uma identidade específica, todos os dispositivos associados a essa identidade receberão uma notificação por push silenciosa informando-os da alteração.

nota

Não há suporte para a sincronização por push em JavaScript, Unity ou Xamarin.

Para que você possa usar a sincronização por push, primeiro configure a conta da sincronização por push e habilite a sincronização por push no console do Amazon Cognito.

Crie e configure uma aplicação do Amazon SNS para suas plataformas compatíveis, conforme descrito no Guia do desenvolvedor do SNS.

Habilitar a sincronização por push no console do Amazon Cognito

Você pode habilitar a sincronização por push por meio do console do Amazon Cognito. Na página inicial do console:

Clique no nome do grupo de identidades para o qual deseja habilitar a sincronização por push. A página Dashboard (Painel) do grupo de identidades será exibida.
No canto superior direito da página Dashboard (Painel), clique em Manage Identity Pools (Gerenciar grupos de identidades). A página Federated Identities (Identidades federadas) é exibida.
Role para baixo e clique em Push synchronization para expandi-lo.
No menu suspenso Service role, selecione a função do IAM que concede ao Cognito permissão para enviar uma notificação SNS. Clique em Create role (Criar função) para criar ou modificar as funções associadas ao grupo de identidades no console do AWS IAM.
Selecione um aplicativo de plataforma e clique em Save Changes.
Concessão de acesso ao SNS ao aplicativo

No console do AWS Identity and Access Management, configure suas funções do IAM para ter acesso completo ao Amazon SNS ou crie uma nova função que tenha acesso completo ao Amazon SNS. A política de confiança da função do exemplo a seguir concede ao Amazon Cognito Sync uma capacidade limitada de assumir uma função do IAM. O Amazon Cognito Sync só pode assumir a função quando fizer isso em nome de ambos o grupo de identidades na condição aws:SourceArn e a conta na condição 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"
                }
            }
        }
    ]
}

Para saber mais sobre as funções do IAM, consulte Funções (delegação e federação).

Usar sincronização por push em sua aplicação: Android

O aplicativo precisará importar o Google Play serviços. Você pode fazer download da versão mais recente do Google Play SDK por meio do Android SDK Manager. Siga a documentação do Android sobre a implementação do Android para registrar seu aplicativo e receber um ID de registro do GCM. Assim que você tiver o ID do registro, será necessário registrar o dispositivo no Amazon Cognito, conforme mostrado no trecho abaixo:


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

Agora você pode inscrever um dispositivo para receber atualizações de um conjunto de dados específico:


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

Para interromper o recebimento de notificações por push de um conjunto de dados, basta chamar o método unsubscribe. Para inscrever-se em todos os conjuntos de dados (ou em um subconjunto específico) do objeto CognitoSyncManager, use 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);
    }
}

Na implementação do objeto Android BroadcastReceiver, você pode verificar a versão mais recente do conjunto de dados modificados e decidir se seu aplicativo precisa se sincronizar novamente:


@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() {
            // ...
        });
    }

}

As chaves a seguir estão disponíveis na carga útil de notificação por push:

source: cognito-sync. Pode atuar como um fator de diferenciação entre notificações.
identityPoolId: o ID do grupo de identidades. Pode ser usado para validação ou informações adicionais, embora não seja parte integrante do ponto de vista do receptor.
identityId: o ID da identidade no grupo.
datasetName: o nome do conjunto de dados atualizado. É disponibilizado graças à chamada de openOrCreateDataset.
syncCount: a contagem de sincronização do conjunto de dados remoto. Você pode usar esse recurso como certificar-se de que o conjunto de dados local está desatualizado e a sincronização de entrada é nova.

Usar sincronização por push em sua aplicação: iOS - Objective-C

Para obter um token de dispositivo para o aplicativo, siga a documentação da Apple sobre registro de notificações remotas. Assim que você receber o token do dispositivo como um objeto NSData dos APNs, precisará registrar o dispositivo no Amazon Cognito usando o método registerDevice: do cliente de sincronização, conforme mostrado abaixo:


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

No modo de depuração, o dispositivo será registrado por meio do sandbox dos APNs; no modo de lançamento, ele será registrado por meio dos APNs. Para receber atualizações de um conjunto de dados específico, use o método 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;
      }
    ];

Para interromper o recebimento de notificações por push de um conjunto de dados, basta chamar o método 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;
      }
    ];

Para inscrever-se em todos os conjuntos de dados do objeto AWSCognito, chame 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;
      }
    ];

Antes de chamar subscribeAll, sincronize-se pelo menos uma vez em cada conjunto de dados, para que estes passem a existir no servidor.

Para reagir às notificações por push, é necessário implementar o método didReceiveRemoteNotification no aplicativo delegado:


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

Se você publicar uma notificação usando o handler de notificação, poderá responder à notificação em qualquer outro lugar do aplicativo no qual há um handler para o conjunto de dados. Se você inscrever-se na notificação desta forma...


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

...poderá reagir à notificação desta forma:


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

As chaves a seguir estão disponíveis na carga útil de notificação por push:

source: cognito-sync. Pode atuar como um fator de diferenciação entre notificações.
identityPoolId: o ID do grupo de identidades. Pode ser usado para validação ou informações adicionais, embora não seja parte integrante do ponto de vista do receptor.
identityId: o ID da identidade no grupo.
datasetName: o nome do conjunto de dados atualizado. É disponibilizado graças à chamada de openOrCreateDataset.
syncCount: a contagem de sincronização do conjunto de dados remoto. Você pode usar esse recurso como certificar-se de que o conjunto de dados local está desatualizado e a sincronização de entrada é nova.

Usar sincronização por push em sua aplicação: iOS - Swift

Para obter um token de dispositivo para o aplicativo, siga a documentação da Apple sobre registro de notificações remotas. Assim que você receber o token do dispositivo como um objeto NSData dos APNs, precisará registrar o dispositivo no Amazon Cognito usando o método registerDevice: do cliente de sincronização, conforme mostrado abaixo:


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

Para interromper o recebimento de notificações por push de um conjunto de dados, chame o método 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
})

Para inscrever-se em todos os conjuntos de dados do objeto AWSCognito, chame 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
})

Antes de chamar subscribeAll, sincronize-se pelo menos uma vez em cada conjunto de dados, para que estes passem a existir no servidor.

Para reagir às notificações por push, é necessário implementar o método didReceiveRemoteNotification no aplicativo delegado:


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)

...poderá reagir à notificação desta forma:


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

As chaves a seguir estão disponíveis na carga útil de notificação por push:

source: cognito-sync. Pode atuar como um fator de diferenciação entre notificações.
identityPoolId: o ID do grupo de identidades. Pode ser usado para validação ou informações adicionais, embora não seja parte integrante do ponto de vista do receptor.
identityId: o ID da identidade no grupo.
datasetName: o nome do conjunto de dados atualizado. É disponibilizado graças à chamada de openOrCreateDataset.
syncCount: a contagem de sincronização do conjunto de dados remoto. Você pode usar esse recurso como certificar-se de que o conjunto de dados local está desatualizado e a sincronização de entrada é nova.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Como manipular retornos de chamada

Amazon Cognito Streams