Compartilhar via

Adicionar notificações por push ao aplicativo Xamarin.Forms

Visão geral

Neste tutorial, você adicionará notificações por push a todos os projetos resultantes do início rápido do Xamarin.Forms. Isso significa que uma notificação por push é enviada a todos os clientes multiplataforma sempre que um registro é inserido.

Se você não usar o projeto de servidor de início rápido baixado, precisará do pacote de extensão de notificação por push. Para mais informações, consulte Uso do SDK de servidor .NET para aplicativos móveis do Azure.

Pré-requisitos

Para iOS, você precisará de uma associação Programa de Desenvolvedores da Apple e um dispositivo iOS físico. O simulador iOS não dá suporte a notificações por push.

Configurar um hub de notificação

O recurso Aplicativos Móveis do Serviço de Aplicativo do Azure usa hubs de notificação do Azure para enviar pushes, portanto, você estará configurando um hub de notificação para seu aplicativo móvel.

  1. No portal do Azure, vá para Serviços de Aplicativose selecione o back-end do seu aplicativo. Em Configurações, selecione Push.

  2. Para adicionar um recurso de hub de notificações ao aplicativo, selecione Conectar. Você pode criar um hub ou conectar-se a um existente.

    Configurar um hub

Agora você conectou um hub de notificação ao seu projeto de back-end dos Aplicativos Móveis. Posteriormente, você configurará esse hub de notificação para se conectar a um PNS (sistema de notificação de plataforma) para enviar por push para dispositivos.

Atualizar o projeto do servidor para enviar notificações por push

Nesta seção, você atualizará o código em seu projeto de back-end de Aplicativos Móveis existente para enviar uma notificação por push sempre que um novo item for adicionado. Esse processo é impulsionado pelo recurso de modelo dos Hubs de Notificação do Azure, que permite notificações multi-plataforma. Diversos clientes são registrados para notificações por push usando modelos, e um único push universal pode ser enviado para todas as plataformas de cliente.

Escolha um dos seguintes procedimentos que corresponda ao tipo do seu projeto de back-end — back-end do .NET ou back-end Node.js.

Projeto de back-end do .NET

  1. No Visual Studio, clique com o botão direito do mouse no projeto do servidor. Em seguida, selecione Gerenciar Pacotes NuGet. Pesquise Microsoft.Azure.NotificationHubse selecione Instalar. Esse processo instala a biblioteca Hubs de Notificação para enviar notificações do back-end.

  2. No projeto do servidor, abra controladores de >TodoItemController.cs. Em seguida, adicione o seguinte usando instruções:

    using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;

  3. No método PostTodoItem, adicione o seguinte código após a chamada para InsertAsync:

    // Get the settings for the server project.
HttpConfiguration config = this.Configuration;
MobileAppSettingsDictionary settings =
    this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();

// Get the Notification Hubs credentials for the mobile app.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
    .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

// Create a new Notification Hub client.
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

// Send the message so that all template registrations that contain "messageParam"
// receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
Dictionary<string,string> templateParams = new Dictionary<string,string>();
templateParams["messageParam"] = item.Text + " was added to the list.";

try
{
    // Send the push notification and log the results.
    var result = await hub.SendTemplateNotificationAsync(templateParams);

    // Write the success result to the logs.
    config.Services.GetTraceWriter().Info(result.State.ToString());
}
catch (System.Exception ex)
{
    // Write the failure result to the logs.
    config.Services.GetTraceWriter()
        .Error(ex.Message, null, "Push.SendAsync Error");
}

    Esse processo envia uma notificação de modelo que contém o item.Text quando um novo item é inserido.

  4. Republice o projeto do servidor.

projeto de back-end Node.js

  1. Configure seu projeto de back-end.

  2. Substitua o código existente no todoitem.js pelo seguinte código:

    var azureMobileApps = require('azure-mobile-apps'),
promises = require('azure-mobile-apps/src/utilities/promises'),
logger = require('azure-mobile-apps/src/logger');

var table = azureMobileApps.table();

table.insert(function (context) {
// For more information about the Notification Hubs JavaScript SDK,
// see https://aka.ms/nodejshubs.
logger.info('Running TodoItem.insert');

// Define the template payload.
var payload = '{"messageParam": "' + context.item.text + '" }';  

// Execute the insert. The insert returns the results as a promise.
// Do the push as a post-execute action within the promise flow.
return context.execute()
    .then(function (results) {
        // Only do the push if configured.
        if (context.push) {
            // Send a template notification.
            context.push.send(null, payload, function (error) {
                if (error) {
                    logger.error('Error while sending push notification: ', error);
                } else {
                    logger.info('Push notification sent successfully!');
                }
            });
        }
        // Don't forget to return the results from the context.execute().
        return results;
    })
    .catch(function (error) {
        logger.error('Error while running context.execute: ', error);
    });
});

module.exports = table;

    Esse processo envia uma notificação de modelo que contém o item.text quando um novo item é inserido.

  3. Depois de editar o arquivo no computador local, republicar o projeto no servidor.

Configurar e executar o projeto do Android (opcional)

Conclua esta seção para habilitar notificações por push para o projeto Droid do Xamarin.Forms para Android.

Habilitar FCM (Firebase Cloud Messaging)

  1. Faça logon no console do Firebase. Crie um novo projeto do Firebase se você ainda não tiver um.

  2. Depois de criar seu projeto, selecione Adicionar Firebase ao seu aplicativo Android.

    Adicione o Firebase ao seu aplicativo Android

  3. Siga estas etapas na página Adicionar Firebase ao seu aplicativo Android:

    1. Para Nome do pacote Android, copie o valor de applicationId no arquivo build.gradle do aplicativo. Neste exemplo, é com.fabrikam.fcmtutorial1app.

      Especificar o nome do pacote

    2. Selecione Registrar aplicativo.

  4. Selecione Baixar google-services.json, salve o arquivo na pasta app do projeto e, em seguida, selecione Avançar.

    Baixar google-services.json

  5. Faça as seguintes alterações na configuração do seu projeto no Android Studio.

    1. No arquivo project-level build.gradle (<project>/build.gradle), adicione a seguinte instrução à seção de dependências.

      classpath 'com.google.gms:google-services:4.0.1'

    2. No arquivo build.gradle no nível do aplicativo (<project>/<app-module>/build.gradle), adicione as instruções a seguir à seção de dependências.

      implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'

    3. Adicione a seguinte linha ao final do arquivo build.gradle no nível do aplicativo após a seção de dependências.

      apply plugin: 'com.google.gms.google-services'

    4. Selecione Sincronizar agora na barra de ferramentas.

      Alterações na configuração de build.gradle

  6. Selecione Avançar.

  7. Selecione Ignorar esta etapa.

    Ignorar a última etapa

  8. No console do Firebase, selecione a engrenagem para seu projeto. Em seguida, selecione Configurações do Projeto.

    Selecione Configurações do Projeto

  9. Se você não tiver baixado o arquivo google-services.json para a pasta aplicativo do projeto do Android Studio, será possível fazer isso nesta página.

  10. Altere para a aba Mensagens na Nuvem na parte superior.

  11. Copie e salve a Chave do servidor para uso posterior. Use esse valor para configurar o hub.

Configurar o back-end dos Aplicativos Móveis para enviar solicitações por push usando FCM

  1. No portal do Azure, selecione Procurar Todos os Serviços de Aplicativo>. Em seguida, selecione o back-end dos Aplicativos Móveis.
  2. Em Configurações, selecione Push. Em seguida, selecione Configurar serviços de notificação por push.
  3. Vá para do Google (GCM). Insira a chave do servidor herdado do FCM obtida no console do Firebase e selecione Salvar.

Seu serviço agora está configurado para funcionar com o Firebase Cloud Messaging.

Adicionar notificações por push ao projeto do Android

Com o back-end configurado com FCM, você pode adicionar componentes e códigos ao cliente para se registrar no FCM. Você também pode se registrar para notificações por push com os Hubs de Notificação do Azure por meio do back-end dos Aplicativos Móveis e receber notificações.

  1. No projeto Droid, clique com o botão direito do mouse em Referências > Gerenciar Pacotes NuGet....
  2. Na janela do Gerenciador de Pacotes NuGet, pesquise o pacote Xamarin.Firebase.Messaging e adicione-o ao projeto.
  3. Nas propriedades do projeto para o projeto Droid, defina o aplicativo para compilar usando o Android versão 7.0 ou superior.
  4. Adicione o arquivo google-services.json, baixado do console do Firebase, à raiz do projeto Droid e defina sua ação de build para GoogleServicesJson. Para obter mais informações, consulte Adicionar o arquivo JSON do Google Services.

Registrando-se no Firebase Cloud Messaging

  1. Abra o arquivo AndroidManifest.xml e insira os seguintes elementos <receiver> no elemento <application>:

    <receiver android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver" android:exported="false" />
<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="${applicationId}" />
    </intent-filter>
</receiver>

Implementando o Serviço de Identificador de Instância do Firebase

  1. Adicione uma nova classe ao projeto Droid chamado FirebaseRegistrationServicee verifique se as seguintes instruções using estão presentes na parte superior do arquivo:

    using System.Threading.Tasks;
using Android.App;
using Android.Util;
using Firebase.Iid;
using Microsoft.WindowsAzure.MobileServices;

  2. Substitua a classe de FirebaseRegistrationService vazia pelo seguinte código:

    [Service]
[IntentFilter(new[] { "com.google.firebase.INSTANCE_ID_EVENT" })]
public class FirebaseRegistrationService : FirebaseInstanceIdService
{
    const string TAG = "FirebaseRegistrationService";

    public override void OnTokenRefresh()
    {
        var refreshedToken = FirebaseInstanceId.Instance.Token;
        Log.Debug(TAG, "Refreshed token: " + refreshedToken);
        SendRegistrationTokenToAzureNotificationHub(refreshedToken);
    }

    void SendRegistrationTokenToAzureNotificationHub(string token)
    {
        // Update notification hub registration
        Task.Run(async () =>
        {
            await AzureNotificationHubService.RegisterAsync(TodoItemManager.DefaultManager.CurrentClient.GetPush(), token);
        });
    }
}

    A classe FirebaseRegistrationService é responsável por gerar tokens de segurança que autorizam o aplicativo a acessar o FCM. O método OnTokenRefresh é invocado quando o aplicativo recebe um token de registro do FCM. O método recupera o token da propriedade FirebaseInstanceId.Instance.Token, que é atualizada de forma assíncrona pelo FCM. O método OnTokenRefresh é invocado com pouca frequência, pois o token só é atualizado quando o aplicativo é instalado ou desinstalado, quando o usuário exclui dados do aplicativo, quando o aplicativo apaga a ID da Instância ou quando a segurança do token é comprometida. Além disso, o serviço FCM Instance ID solicitará que o aplicativo atualize seu token periodicamente, normalmente a cada 6 meses.

    O método OnTokenRefresh também invoca o método SendRegistrationTokenToAzureNotificationHub, que é usado para associar o token de registro do usuário ao Hub de Notificação do Azure.

Registrando-se no Hub de Notificação do Azure

  1. Adicione uma nova classe ao projeto Droid chamado AzureNotificationHubServicee verifique se as seguintes instruções using estão presentes na parte superior do arquivo:

    using System;
using System.Threading.Tasks;
using Android.Util;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;

  2. Substitua a classe de AzureNotificationHubService vazia pelo seguinte código:

    public class AzureNotificationHubService
{
    const string TAG = "AzureNotificationHubService";

    public static async Task RegisterAsync(Push push, string token)
    {
        try
        {
            const string templateBody = "{\"data\":{\"message\":\"$(messageParam)\"}}";
            JObject templates = new JObject();
            templates["genericMessage"] = new JObject
            {
                {"body", templateBody}
            };

            await push.RegisterAsync(token, templates);
            Log.Info("Push Installation Id: ", push.InstallationId.ToString());
        }
        catch (Exception ex)
        {
            Log.Error(TAG, "Could not register with Notification Hub: " + ex.Message);
        }
    }
}

    O método RegisterAsync cria um modelo de mensagem de notificação simples como JSON e se registra para receber notificações de modelo do hub de notificação usando o token de registro do Firebase. Isso garante que todas as notificações enviadas do Hub de Notificação do Azure sejam direcionadas ao dispositivo representado pelo token de registro.

Exibindo o conteúdo de uma notificação por push

  1. Adicione uma nova classe ao projeto Droid chamado FirebaseNotificationServicee verifique se as seguintes instruções using estão presentes na parte superior do arquivo:

    using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V7.App;
using Android.Util;
using Firebase.Messaging;

  2. Substitua a classe de FirebaseNotificationService vazia pelo seguinte código:

    [Service]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class FirebaseNotificationService : FirebaseMessagingService
{
    const string TAG = "FirebaseNotificationService";

    public override void OnMessageReceived(RemoteMessage message)
    {
        Log.Debug(TAG, "From: " + message.From);

        // Pull message body out of the template
        var messageBody = message.Data["message"];
        if (string.IsNullOrWhiteSpace(messageBody))
            return;

        Log.Debug(TAG, "Notification message body: " + messageBody);
        SendNotification(messageBody);
    }

    void SendNotification(string messageBody)
    {
        var intent = new Intent(this, typeof(MainActivity));
        intent.AddFlags(ActivityFlags.ClearTop);
        //Unique request code to avoid PendingIntent collision.
        var requestCode = new Random().Next();
        var pendingIntent = PendingIntent.GetActivity(this, requestCode, intent, PendingIntentFlags.OneShot);
        var notificationBuilder = new NotificationCompat.Builder(this)
            .SetSmallIcon(Resource.Drawable.ic_stat_ic_notification)
            .SetContentTitle("New Todo Item")
            .SetContentText(messageBody)
            .SetContentIntent(pendingIntent)
            .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Notification))
            .SetAutoCancel(true);

        var notificationManager = NotificationManager.FromContext(this);
        notificationManager.Notify(0, notificationBuilder.Build());
    }
}

    O método OnMessageReceived, que é invocado quando um aplicativo recebe uma notificação do FCM, extrai o conteúdo da mensagem e chama o método SendNotification. Esse método converte o conteúdo da mensagem em uma notificação local que é iniciada enquanto o aplicativo está em execução, com a notificação aparecendo na área de notificação.

Agora, você está pronto para testar notificações por push no aplicativo em execução em um dispositivo Android ou no emulador.

Testar notificações por push em seu aplicativo Android

As duas primeiras etapas são necessárias somente quando você está testando em um emulador.

  1. Verifique se você está implantando ou depurando em um dispositivo ou emulador configurado com o Google Play Services. Isso pode ser verificado verificando se os aplicativos do Play estão instalados no dispositivo ou no emulador.
  2. Adicione uma conta do Google ao dispositivo Android clicando Apps>Settings>Add account. Em seguida, siga os prompts para adicionar uma conta existente do Google ao dispositivo ou para criar uma nova.
  3. No Visual Studio ou no Xamarin Studio, clique com o botão direito do mouse no projeto Droid e clique em Definir como projeto de inicialização.
  4. Clique em Executar para criar o projeto e iniciar o aplicativo em seu dispositivo Android ou emulador.
  5. No aplicativo, digite uma tarefa e clique no ícone de mais (+).
  6. Verifique se uma notificação é recebida quando um item é adicionado.

Configurar e executar o projeto do iOS (opcional)

Esta seção destina-se à execução do projeto Xamarin iOS para dispositivos iOS. Você pode ignorar esta seção se não estiver trabalhando com dispositivos iOS.

Gerar o arquivo de solicitação de assinatura de certificado

As APNs (Serviço de Notificação por Push) da Apple usam certificados para autenticar suas notificações por push. Siga estas instruções para criar o certificado de push necessário para enviar e receber notificações. Para obter mais informações sobre esses conceitos, consulte a documentação oficial do Apple Push Notification Service.

Gere o arquivo CSR (Solicitação de Autenticação de Certificado), que a Apple usa para gerar um certificado por push assinado.

  1. Em seu Mac, execute a ferramenta Acesso às Chaves. Ela pode ser aberta na pasta Utilitários ou na pasta Outros no Launchpad.

  2. Selecione Acesso do Conjunto de Chaves, expanda Assistente de Certificado e selecione Solicitar um Certificado de uma Autoridade de Certificação.

    usar o Acesso ao Conjunto de Chaves para solicitar um novo certificado

    Observação

    Por padrão, o Acesso às Chaves seleciona o primeiro item na lista. Isso pode ser um problema se você estiver na categoria Certificados e a Autoridade de Certificação de Relacionamentos do Desenvolvedor Mundial da Apple não for o primeiro item da lista. Verifique se você tem um item não chave ou se a chave Autoridade de Certificação de Relacionamentos do Desenvolvedor Mundial da Apple está selecionada antes de gerar o CSR (Solicitação de Assinatura de Certificado).

  3. Selecione seu Endereço de Email do Usuário, insira o valor do seu Nome Comum, verifique se você especificou Salvo em disco e, em seguida, selecione Continuar. Deixe Endereço de Email de AC em branco, pois isso não é necessário.

    informações de certificado necessárias

  4. Insira um nome para o arquivo CSR em Salvar Como, selecione o local em Onde e, em seguida, selecione Salvar.

    Escolha um nome de arquivo para o certificado

    Essa ação salva o arquivo CSR no local selecionado. O local padrão é a área de trabalho. Lembre-se do local escolhido para o arquivo.

Em seguida, registre seu aplicativo na Apple, habilite as notificações por push e carregue o CSR exportado para criar um certificado de push.

Registrar seu aplicativo para notificações por push

Para enviar notificações por push para um aplicativo iOS, registre seu aplicativo na Apple e também registre-se para notificações por push.

  1. Se você ainda não tiver registrado seu aplicativo, navegue até o Portal de provisionamento iOS no Apple Developer Center. Conecte-se ao portal com sua ID da Apple e selecione Identificadores. Em seguida, selecione + para registrar um novo aplicativo.

    página de IDs de App do Portal de Provisionamento do iOS

  2. Na tela Registrar um Novo Identificador, selecione o botão de rádio IDs do App. Em seguida, selecione Continuar.

    Portal de Provisionamento do iOS registrar nova página de ID

  3. Atualize os três valores a seguir para o novo aplicativo e selecione Continuar:

    • Descrição: Digite um nome descritivo para o seu aplicativo.

    • ID do Pacote: Digite uma ID do Pacote no formulário Identificador da Organização.Nome do Produto conforme mencionado no Guia de Distribuição de Aplicativos. Os valores Identificador de Organização e Nome do Produto deverão corresponder ao identificador da organização e o nome do produto usados quando você criar seu projeto Xcode. Na captura de tela abaixo, o valor NotificationHubs é usado como um identificador de organização e o valor GetStarted é usado como o nome do produto. Verifique se o valor de Identificador de Pacote corresponde ao valor em seu projeto do Xcode, para que o Xcode use o perfil de publicação correto.

      página de registro de ID do aplicativo do Portal de Provisionamento do iOS

    • Notificações por Push: Marque a opção Notificações por Push na seção Funcionalidades.

      Formulário para registrar uma nova ID do aplicativo

      Essa ação gerará sua ID do Aplicativo e solicitará que você confirme as informações. Selecione Continuar e, em seguida, selecione Registrar para confirmar a nova ID do Aplicativo.

      confirmar nova ID do aplicativo

      Depois de selecionar Registrar, você verá a nova ID do aplicativo como um item de linha na página Certificados, Identificadores & Perfis.

  4. Na página Certificados, Identificadores e Perfis, em Identificadores, localize o item de linha da ID do Aplicativo que você acabou de criar e selecione sua linha para exibir a tela Editar sua Configuração de ID do Aplicativo.

Criando um certificado para hubs de notificação

Um certificado é necessário para habilitar que o hub de notificação funcione com APNs. Isso pode ser feito de uma das seguintes maneiras:

  1. Crie um .p12 que possa ser carregado diretamente no Hub de Notificação.
  2. Crie um .p8 que pode ser usado para autenticação baseada em token (a abordagem mais recente).

A abordagem mais recente tem uma série de benefícios (em comparação com o uso de certificados), conforme documentado na autenticação HTTP/2 (baseada em token) para APNS. No entanto, foram fornecidas etapas para ambas as abordagens.

OPÇÃO 1: Criando um certificado push .p12 que pode ser carregado diretamente no Hub de Notificação

  1. Role para baixo até a opção marcada Notificações por Push e, em seguida, selecione Configurar para criar o certificado.

    página de edição de ID do aplicativo

  2. A janela Certificados SSL do Apple Push Notification service é exibida. Selecione o botão Criar Certificado na seção Certificado SSL de Desenvolvimento.

    Criar certificado para botão de ID do aplicativo

    A tela Criar um novo Certificado é exibida.

    Observação

    Este tutorial usa um certificado de desenvolvimento. O mesmo processo é usado para registrar um certificado de produção. Apenas certifique-se de usar o mesmo tipo de certificado ao enviar notificações.

  3. Selecione Escolher Arquivo, navegue até o local onde você salvou o arquivo CSR na primeira tarefa e clique duas vezes no nome do certificado para carregá-lo. Em seguida, selecione Continuar.

  4. Depois que o portal cria o certificado, selecione o botão Baixar. Salve o certificado e lembre-se do local em que ele foi salvo.

    página de download de certificado gerado

    O certificado é baixado e salvo em seu computador na pasta Downloads.

    Localizar arquivo de certificado na pasta Downloads

    Observação

    Por padrão, o certificado de desenvolvimento baixado é denominado aps_development.cer.

  5. Clique duas vezes no certificado de push baixado, aps_development.cer. Essa ação instala o novo certificado no conjunto de chaves, conforme mostrado na imagem a seguir:

    lista de certificados de acesso de conjunto de chaves mostrando o novo certificado

    Observação

    Embora o nome em seu certificado possa ser diferente, o nome será prefixado com Apple Development iOS Push Services.

  6. No Acesso ao Conjunto de Chaves, clique com o botão direito do mouse no novo certificado push criado na categoria Certificados . Selecione Exportar, nomeie o arquivo, selecione o formato .p12 e selecione Salvar.

    Exportar certificado no formato p12

    Você pode optar por proteger o certificado com uma senha, mas isso é opcional. Clique em OK caso deseje ignorar a criação de senha. Anote o nome do arquivo e o local do certificado .p12 exportado. Eles são usados para habilitar a autenticação com APNs.

    Observação

    O nome e o local do arquivo. p12 podem ser diferentes do que foi mostrado neste tutorial.

OPÇÃO 2: Criando um certificado .p8 que pode ser usado para autenticação baseada em token

  1. Anote os seguintes detalhes:

    • O Prefixo da ID do Aplicativo (Isso é uma ID da Equipe)
    • ID do Pacote

  2. Novamente em Certificados, Identificadores e Perfis, clique em Chaves.

    Observação

    Caso já tenha uma chave configurada para APNs, você pode usar novamente o certificado .p8 que você baixou logo depois de criá-lo. Nesse caso, você pode ignorar as etapas 3 até 5.

  3. Clique no botão + (ou no botão Criar uma chave) para criar uma chave.

  4. Forneça um Nome de Chave adequado e, em seguida, verifique a opção do serviço de Notificações por Push (APNs) da Apple e clique em Continuar, seguido por Registrar na próxima tela.

  5. Clique em Baixar e, em seguida, mova o .p8 arquivo (prefixado com AuthKey_) para um diretório local seguro, e depois clique em Concluído.

    Observação

    Verifique se o arquivo .p8 está em um local seguro (e salve um backup). Depois de baixar a chave, ela não pode ser baixada novamente, pois a cópia do servidor é removida.

  6. Em Chaves, clique na chave que você acabou de criar (ou em uma já existente caso você tenha optado por usá-la em vez disso).

  7. Anote o valor da ID da Chave.

  8. Abra o certificado .p8 em um aplicativo adequado de sua escolha, como Visual Studio Code anote o valor da chave. Esse é o valor entre -----BEGIN PRIVATE KEY----- e -----END PRIVATE KEY----- .

    -----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----

    Observação

    Este é o valor do token que será usado posteriormente para configurar o Hub de Notificação .

Ao final dessas etapas, você deve ter as seguintes informações para uso posteriormente no Configurar seu hub de notificação com informações de APNs:

  • ID da Equipe (veja a etapa 1)
  • ID do Bundle (veja a etapa 1)
  • ID da chave (ver etapa 7)
  • valor do token ou seja, o valor da chave .p8 (consulte a etapa 8)

Criar um perfil de provisionamento para o aplicativo

  1. Retorne ao Portal de Provisionamento do iOS, selecione Certificados, Identificadores e Perfis, selecione Perfis no menu à esquerda e selecione + para criar um novo perfil. A tela Registrar um Novo Perfil de Provisionamento é exibida.

  2. Selecione Desenvolvimento de Aplicativos do iOS em Desenvolvimento como o tipo de perfil de provisionamento e selecione Continuar.

    lista de perfis de provisionamento

  3. Em seguida, selecione a ID do aplicativo que você criou na lista suspensa ID do Aplicativo e selecione Continuar.

    selecione a ID do aplicativo

  4. Na janela Selecionar certificados, selecione o certificado de desenvolvimento que você usa para assinatura de código e selecione Continuar. Esse certificado não é o certificado push que você criou. Se não houver um, você deverá criá-lo. Se houver um certificado, pule para a próxima etapa. Para criar um certificado de desenvolvimento, caso não exista um:

    1. Se você vir Nenhum certificado disponível, selecione Criar Certificado.
    2. Na seção Software, selecione Desenvolvimento da Apple. Em seguida, selecione Continuar.
    3. Na tela Criar um Novo Certificado, selecione Escolher Arquivo.
    4. Navegue até o certificado Solicitação de Assinatura de Certificado criado anteriormente, selecione-o e, em seguida, selecione Abrir.
    5. Selecione Continuar.
    6. Baixe o certificado de desenvolvimento e lembre-se do local para o qual ele foi salvo.

  5. Retorne à página Certificados, Identificadores e Perfis, selecione Perfis no menu à esquerda e selecione + para criar um novo perfil. A tela Registrar um Novo Perfil de Provisionamento é exibida.

  6. Na janela Selecionar certificados, selecione o certificado de desenvolvimento que você acabou de criar. Em seguida, selecione Continuar.

  7. Em seguida, selecione os dispositivos a serem usados para teste e selecione Continuar.

  8. Por fim, escolha um nome para o perfil no nome do perfil de provisionamentoe selecione Gerar.

    Escolha um nome de perfil de provisionamento

  9. Quando o novo perfil de provisionamento for criado, selecione Baixar. Lembre-se do local em que foi salvo.

  10. Navegue até o local do perfil de provisionamento e clique duas vezes nele para instalá-lo em seu computador de desenvolvimento do Xcode.

Criar um hub de notificação

Nesta seção, você criará um hub de notificação e configurará a autenticação com APNs usando o certificado push .p12 ou a autenticação baseada em token. Se você quiser usar um hub de notificação já criado, passe diretamente à etapa 5.

  1. Entre no portal do Azure.

  2. Selecione Todos os serviços no menu à esquerda e Hubs de Notificação na seção Móvel. Selecione o ícone de estrela ao lado do nome do serviço para adicionar o serviço na seção FAVORITOS no menu à esquerda. Depois de adicionar Hubs de Notificação aos FAVORITOS, selecione-o no menu à esquerda.

    portal do Azure – selecione Hubs de Notificação

  3. Na página Hubs de Notificação, selecione Adicionar na barra de ferramentas.

    Hubs de Notificação - Adicionar Botão da Barra de Ferramentas

  4. Na página do Hub de Notificação, execute as seguintes etapas:

    1. Insira um nome em Hub de Notificação.

    2. Insira um nome em Criar um namespace. Um namespace contém um ou mais hubs.

    3. Selecione um valor da lista suspensa Local. Esse valor especifica a localização na qual você deseja criar o hub.

    4. Selecione um grupo de recursos existente em grupo de recursosou crie um nome para um novo grupo de recursos.

    5. Selecione Criar.

      portal do Azure – definir propriedades do hub de notificação

  5. Selecione Notificações (ícone de sino) e selecione Acessar recurso. Atualize também a lista na página Hubs de Notificação e, em seguida, selecione seu hub.

    portal do Azure – notificações –> Ir para recurso

  6. Selecione Políticas de Acesso na lista. Observe que estão disponíveis para você duas cadeias de conexão. Você precisará delas para manipular notificações por push mais tarde.

    Importante

    Não use a política DefaultFullSharedAccessSignature em seu aplicativo. Isto é destinado a ser usado apenas em seu back-end.

    portal do Azure – cadeias de conexão do hub de notificação

Configurar seu hub de notificação com informações de APNs

Em Serviços de Notificação , selecione Apple (APNS) e siga as etapas apropriadas com base na abordagem escolhida anteriormente na seção Criação de um Certificado para Hubs de Notificação.

Observação

Use o de Produção para Modo de Aplicativo somente se você quiser enviar notificações por push para os usuários que compraram seu aplicativo da loja.

OPÇÃO 1: Usando um certificado push .p12

  1. Selecione Certificado.

  2. Selecione o ícone arquivo.

  3. Selecione o arquivo .p12 que você exportou anteriormente e, em seguida, clique em Abrir.

  4. Caso seja necessário, especifique a senha correta.

  5. Selecione o modo Sandbox.

    Configurar a certificação de APNs no portal do Azure

  6. Clique em Salvar.

OPÇÃO 2: Usando a autenticação baseada em token

  1. Selecione Token.

  2. Insira os seguintes valores que você adquiriu antes:

    • ID da Chave
    • ID do Pacote
    • ID da Equipe
    • Símbolo

  3. Selecione Sandbox

  4. Clique em Salvar.

Agora você configurou o hub de notificação com APNs. Você também tem as strings de conexão para registrar seu aplicativo e enviar notificações push.

Configurar o hub de notificação para APNS

  1. Em seu Mac, inicie Acesso às Chaves. Na barra de navegação à esquerda, em Categoria, abra Meus Certificados. Localize o certificado SSL que você baixou na seção anterior e, em seguida, divulgue seu conteúdo. Selecione apenas o certificado (não selecione a chave privada). Em seguida, exporte-o.
  2. No portal do Azure, selecione Procurar Todos os Serviços de Aplicativo>. Em seguida, selecione o back-end dos Aplicativos Móveis.
  3. Em Configurações, selecione Push do Serviço de Aplicativo. Em seguida, selecione o nome do hub de notificação.
  4. Vá para Serviços de Notificação por Push da Apple>Fazer upload de Certificado. Carregue o arquivo .p12, selecionando o modo correto (dependendo de se o certificado SSL do cliente utilizado anteriormente é de produção ou sandbox). Salve as alterações.

Seu serviço agora está configurado para funcionar com notificações por push no iOS.

Em seguida, você definirá a configuração do projeto do iOS no Xamarin Studio ou no Visual Studio.

Configurar o projeto do iOS no Xamarin Studio

  1. No Xamarin.Studio, abra info.pliste atualize o identificador de pacote com a ID do pacote que você criou anteriormente com sua nova ID do aplicativo.

  2. Role para baixo até modos de tela de fundo. Selecione a caixa Habilitar Modos em Segundo Plano e a caixa de notificações remotas.

  3. Clique duas vezes no projeto no Painel de Soluções para abrir Opções do Projeto.

  4. Em Criar, escolha Assinatura de Pacote do iOSe selecione a identidade e o perfil de provisionamento correspondentes que você acabou de configurar para este projeto.

    Isso garante que o projeto use o novo perfil para assinatura de código. Para ver a documentação oficial de Provisionamento de Dispositivos Xamarin, consulte .

Configurar o projeto do iOS no Visual Studio

  1. No Visual Studio, clique com o botão direito do mouse no projeto e clique em Propriedades.

  2. Nas páginas de propriedades, clique na guia Aplicativo iOS e atualize o Identificador com o ID que você criou anteriormente.

  3. Na guia Assinatura de Pacote do iOS, , selecione a identidade e o perfil de provisionamento correspondentes que você acabou de configurar para este projeto.

    Isso garante que o projeto use o novo perfil para assinatura de código. Para ver a documentação oficial de Provisionamento de Dispositivos Xamarin, consulte .

  4. Clique duas vezes em Info.plist para abri-lo e, em seguida, habilite RemoteNotifications em Modos em Segundo Plano.

Adicionar notificações por push ao seu aplicativo iOS

  1. No projeto iOS, abra AppDelegate.cs e adicione a instrução a seguir à parte superior do arquivo de código.

    using Newtonsoft.Json.Linq;

  2. Na classe AppDelegate, adicione uma substituição para o evento RegisteredForRemoteNotifications para se registrar para notificações:

    public override void RegisteredForRemoteNotifications(UIApplication application,
    NSData deviceToken)
{
    const string templateBodyAPNS = "{\"aps\":{\"alert\":\"$(messageParam)\"}}";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
        {
            {"body", templateBodyAPNS}
        };

    // Register for push with your mobile app
    Push push = TodoItemManager.DefaultManager.CurrentClient.GetPush();
    push.RegisterAsync(deviceToken, templates);
}

  3. Em AppDelegate, adicione também a seguinte substituição para o manipulador de eventos DidReceiveRemoteNotification:

    public override void DidReceiveRemoteNotification(UIApplication application,
    NSDictionary userInfo, Action<UIBackgroundFetchResult> completionHandler)
{
    NSDictionary aps = userInfo.ObjectForKey(new NSString("aps")) as NSDictionary;

    string alert = string.Empty;
    if (aps.ContainsKey(new NSString("alert")))
        alert = (aps[new NSString("alert")] as NSString).ToString();

    //show alert
    if (!string.IsNullOrEmpty(alert))
    {
        UIAlertView avAlert = new UIAlertView("Notification", alert, null, "OK", null);
        avAlert.Show();
    }
}

    Esse método manipula as notificações de entrada enquanto o aplicativo está em execução.

  4. Na classe AppDelegate, adicione o seguinte código ao método FinishedLaunching:

    // Register for push notifications.
var settings = UIUserNotificationSettings.GetSettingsForTypes(
    UIUserNotificationType.Alert
    | UIUserNotificationType.Badge
    | UIUserNotificationType.Sound,
    new NSSet());

UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
UIApplication.SharedApplication.RegisterForRemoteNotifications();

    Isso habilita o suporte para notificações remotas e solicitações de registro por push.

Seu aplicativo agora é atualizado para dar suporte a notificações por push.

Testar notificações por push em seu aplicativo iOS

  1. Clique com o botão direito do mouse no projeto iOS e clique em Definir como Projeto Inicial.

  2. Pressione o botão Executar ou F5 no Visual Studio para criar o projeto e iniciar o aplicativo em um dispositivo iOS. Em seguida, clique em OK para aceitar notificações por push.

    Observação

    Você deve aceitar explicitamente as notificações por push do seu aplicativo. Essa solicitação ocorre apenas na primeira vez em que o aplicativo é executado.

  3. No aplicativo, digite uma tarefa e clique no ícone de mais (+).

  4. Verifique se uma notificação foi recebida e clique em OK para ignorar a notificação.

Configurar e executar projetos do Windows (opcional)

Esta seção destina-se à execução dos projetos WinApp do Xamarin.Forms e WinPhone81 para dispositivos Windows. Essas etapas também dão suporte a projetos da Plataforma Universal do Windows (UWP). Você pode ignorar esta seção se não estiver trabalhando com dispositivos Windows.

Registrar seu aplicativo do Windows para notificações por push com o Serviço de Notificação do Windows (WNS)

  1. No Gerenciador de Soluções do Visual Studio, clique com o botão direito do mouse no projeto de aplicativo da Windows Store. Em seguida, selecione Store>Associar Aplicativo à Loja.

    Associar aplicativo ao da Windows Store

  2. No assistente, selecione Seguinte. Em seguida, entre com sua conta da Microsoft. Em Reserve um novo nome de aplicativo, digite um nome para seu aplicativo e selecione Reserve.

  3. Depois que o registro do aplicativo for criado com êxito, selecione o novo nome do aplicativo. Selecione Próximoe selecione Associar. Esse processo adiciona as informações de registro necessárias da Windows Store ao manifesto do aplicativo.

  4. Repita as etapas 1 e 3 para o projeto de aplicativo da Windows Phone Store usando o mesmo registro criado anteriormente para o aplicativo da Windows Store.

  5. Vá para o do Centro de Desenvolvimento do Windows e entre com sua conta da Microsoft. Em Meus aplicativos, selecione o novo registro do aplicativo. Em seguida, expanda Serviços>notificações por push.

  6. Na página de notificações por push, em os Serviços de Notificação por Push do Windows (WNS) e os Aplicativos Móveis do Microsoft Azure, selecione site do Live Services. Anote os valores do SID do pacote e o valor atual no Secret de Aplicação .

    configuração do aplicativo no centro de desenvolvedores

    Importante

    O segredo do aplicativo e o SID do pacote são credenciais de segurança importantes. Não compartilhe esses valores com ninguém nem distribua-os com seu aplicativo.

Configurar o hub de notificação para WNS

  1. No portal do Azure, selecione Procurar Todos os Serviços de Aplicativo>. Em seguida, selecione o back-end dos Aplicativos Móveis. Em Configurações, selecione Push do Serviço de Aplicativo. Em seguida, selecione o nome do hub de notificação.

  2. Vá para Windows (WNS). Em seguida, insira a chave de segurança ( segredo do cliente) e o SID do pacote que você obteve no site do Live Services. Em seguida, selecione Salvar.

    Definir a chave WNS no portal

Seu back-end agora está configurado para usar o WNS para enviar notificações por push.

Adicionar notificações por push ao seu aplicativo do Windows

  1. No Visual Studio, abra App.xaml.cs em um projeto do Windows e adicione as instruções a seguir.

    using Newtonsoft.Json.Linq;
using Microsoft.WindowsAzure.MobileServices;
using System.Threading.Tasks;
using Windows.Networking.PushNotifications;
using <your_TodoItemManager_portable_class_namespace>;

    Substitua <your_TodoItemManager_portable_class_namespace> pelo namespace do projeto portátil que contém a classe TodoItemManager.

  2. Em App.xaml.cs, adicione o seguinte método InitNotificationsAsync:

    private async Task InitNotificationsAsync()
{
    var channel = await PushNotificationChannelManager
        .CreatePushNotificationChannelForApplicationAsync();

    const string templateBodyWNS =
        "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(messageParam)</text></binding></visual></toast>";

    JObject headers = new JObject();
    headers["X-WNS-Type"] = "wns/toast";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
    {
        {"body", templateBodyWNS},
        {"headers", headers} // Needed for WNS.
    };

    await TodoItemManager.DefaultManager.CurrentClient.GetPush()
        .RegisterAsync(channel.Uri, templates);
}

    Esse método obtém o canal de notificação por push e registra um template para receber notificações de templates do seu hub de notificação. Um modelo de notificação que suporta messageParam será entregue a este cliente.

  3. Em App.xaml.cs, atualize a definição do método de manipulador de eventos onLaunched adicionando o modificador de async. Em seguida, adicione a seguinte linha de código no final do método:

    await InitNotificationsAsync();

    Isso garante que o registro de notificação por push seja criado ou atualizado sempre que o aplicativo for iniciado. É importante fazer isso para garantir que o canal de push do WNS esteja sempre ativo.

  4. No Gerenciador de Soluções para Visual Studio, abra o arquivo Package.appxmanifest e defina Toast Capable como Sim em Notificações.

  5. Crie o aplicativo e verifique se você não tem erros. Agora, seu aplicativo cliente deve se registrar para as notificações de template do backend dos Aplicativos Móveis. Repita esta seção para cada projeto do Windows em sua solução.

Testar notificações por push em seu aplicativo do Windows

  1. No Visual Studio, clique com o botão direito do mouse em um projeto do Windows e clique em Definir como projeto de inicialização.
  2. Pressione o botão Executar para criar o projeto e iniciar o aplicativo.
  3. No aplicativo, digite um nome para um novo todoitem e clique no ícone de adição (+) para adicioná-lo.
  4. Verifique se uma notificação é recebida quando o item é adicionado.

Próximas etapas

Você pode saber mais sobre notificações por push:

Você também pode continuar em um dos seguintes tutoriais: