Crie um aplicativo Amazon Simple Notification Service (AmazonSNS)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

Implementando a sincronização push

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.

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

A sincronização push não é compatível com Unity ou Xamarin. JavaScript

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 um SNS aplicativo da Amazon para suas plataformas compatíveis, conforme descrito no Guia do SNS desenvolvedor.

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 Função de serviço, selecione a IAM função que concede permissão ao Cognito para enviar uma notificação. SNS Clique em Criar função para criar ou modificar as funções associadas ao seu grupo de identidades no AWS IAMconsole.
Selecione um aplicativo de plataforma e clique em Save Changes.
Conceda SNS acesso ao seu aplicativo

No AWS Identity and Access Management console, configure suas IAM funções para ter SNS acesso total à Amazon ou crie uma nova função que tenha SNS acesso total à Amazon. O exemplo a seguir de política de confiança de funções concede ao Amazon Cognito Sync uma capacidade limitada de assumir uma IAM função. 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 IAM funções, 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 baixar a versão mais recente do Google Play SDK por meio do SDKgerenciador do Android. Siga a documentação do Android sobre a implementação do Android para registrar seu aplicativo e receber uma ID de registro deGCM. 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 BroadcastReceiver objeto Android, você pode verificar a versão mais recente do conjunto de dados modificado e decidir se seu aplicativo precisa ser sincronizado 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. Isso está disponível para fins de chamada do openOrCreate conjunto de dados.
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. Depois de receber o token do dispositivo como um NSData objeto doAPNs, você precisará registrar o dispositivo no Amazon Cognito usando o registerDevice: método 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, seu dispositivo será registrado na APNs sandbox; no modo de lançamento, ele será registrado com. 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. Depois de receber o token do dispositivo como um NSData objeto doAPNs, você precisará registrar o dispositivo no Amazon Cognito usando o métodoregisterDevice: 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

Tratamento de retornos de chamada de eventos

Implementação de streams do Amazon Cognito Sync