Tutorial: Enviar notificações por push para aplicativos Xamarin.Forms usando hubs de notificação do Azure por meio de um serviço de back-end

Artigo
07/27/2020

Neste tutorial, você usará os Hubs de Notificação do Azure para enviar notificações por push para um aplicativo Xamarin.Forms direcionado ao Android e ao iOS.

Um back-end da API Web ASP.NET Core é usado para lidar com o registro de dispositivo para o cliente usando a abordagem de instalação mais recente e melhor. O serviço também enviará notificações por push de maneira multiplataforma.

Essas operações são tratadas usando o SDK dos Hubs de Notificação para operações de back-end. Mais detalhes sobre a abordagem geral são fornecidos na documentação Registrando do seu aplicativo back-end .

Este tutorial leva você pelas seguintes etapas:

Configure os Serviços de Notificação por Push e os Hubs de Notificação do Azure.
Crie um aplicativo de back-end da API Web ASP.NET Core.
Crie um aplicativo Xamarin.Forms multiplataforma.
Configure o projeto android nativo para notificações por push.
Configure o projeto nativo do iOS para notificações por push.
Teste a solução.

Pré-requisitos

Para acompanhar, você precisa de:

Uma assinatura do Azure em que você pode criar e gerenciar recursos.
Um Mac com Visual Studio para Mac instalado ou um computador executando o Visual Studio 2019.
Os usuários do Visual Studio 2019 também devem ter cargas de trabalho de desenvolvimento móvel com .NET e ASP.NET e desenvolvimento web instaladas.
A capacidade de executar o aplicativo em dispositivos Android (dispositivos físicos ou emuladores) ou iOS (somente dispositivos físicos).

Para Android, você deve ter:

Um dispositivo físico desbloqueado pelo desenvolvedor ou um emulador (executando a API 26 e superior com o Google Play Services instalado).

Para iOS, você deve ter:

Uma conta de desenvolvedor ativa da Apple.
Um dispositivo iOS físico registrado em sua conta de desenvolvedor(executando o iOS 13.0 e superior).
Um certificado de desenvolvimento.p12 instalado em seu keychain permitindo que você execute um aplicativo em um dispositivo físico.

Observação

O Simulador do iOS não dá suporte a notificações remotas e, portanto, um dispositivo físico é necessário ao explorar este exemplo no iOS. No entanto, você não precisa executar o aplicativo no Android e no iOS para concluir este tutorial.

Você pode seguir as etapas neste exemplo de primeiros princípios sem nenhuma experiência anterior. No entanto, você se beneficiará de ter familiaridade com os aspectos a seguir.

Importante

As etapas fornecidas são específicas para Visual Studio para Mac. É possível acompanhar usando o Visual Studio 2019 , mas pode haver algumas diferenças para reconciliar. Por exemplo, descrições de interface do usuário e fluxos de trabalho, nomes de modelo, configuração de ambiente e assim por diante.

Configurar os Serviços de Notificação por Push e o Hub de Notificação do Azure

Nesta seção, você configurará o Firebase Cloud Messaging (FCM) e o APNS (Apple Push Notification Services). Em seguida, você cria e configura um hub de notificação para trabalhar com esses serviços.

Criar um projeto do Firebase e habilitar o Firebase Cloud Messaging para Android

Entre no console do Firebase. Crie um novo projeto do Firebase inserindo PushDemo como o Nome do projeto.

Observação

Um nome exclusivo será gerado para você. Por padrão, isso é composto por uma variante minúscula do nome fornecido mais um número gerado separado por um traço. Você pode alterar isso se quiser, desde que ainda seja globalmente exclusivo.
Depois de criar seu projeto, selecione Adicionar Firebase ao seu aplicativo Android.
Na página Adicionar o Firebase ao seu aplicativo Android , execute as etapas a seguir.
1. Para o nome do pacote android, insira um nome para o pacote. Por exemplo: com.<organization_identifier>.<package_name>.
2. Selecione Registrar aplicativo.
3. Selecione Baixar google-services.json. Em seguida, salve o arquivo em uma pasta local para uso posterior e selecione Avançar.
4. Selecione Avançar.
5. Selecione Continuar no console
  
  Observação
  
  Se o botão Continuar no console não estiver habilitado, devido à marcar de instalação de verificação, escolha Ignorar esta etapa.
No console do Firebase, selecione a engrenagem do projeto. Em seguida, selecione Configurações do Projeto.

Observação

Se você não tiver baixado o arquivo google-services.json , poderá baixá-lo nesta página.
Alterne para a guia Mensagens na Nuvem na parte superior. Copie e salve a chave do servidor para uso posterior. Use esse valor para configurar o hub de notificação.

Registrar seu aplicativo iOS para notificações por push

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

Se você ainda não registrou seu aplicativo, navegue até o Portal de Provisionamento do iOS no Centro de Desenvolvedores da Apple. Entre no portal com sua ID da Apple, navegue até Certificados, Identificadores & Perfis e selecione Identificadores. Clique + para registrar um novo aplicativo.
Na tela Registrar um Novo Identificador , selecione o botão de opção IDs do aplicativo. Em seguida, selecione Continuar.
Atualize os três valores a seguir para o novo aplicativo e selecione Continuar:
- Descrição: digite um nome descritivo para seu aplicativo.
- ID do pacote: insira uma ID de pacote do formulário com.organization_identifier<.<>>product_name conforme mencionado no Guia de Distribuição de Aplicativos. Na captura de tela a seguir, o mobcat valor é usado como um identificador da organização e o valor PushDemo é usado como o nome do produto.
- Notificações por push: verifique a opção Notificações por Push na seção Funcionalidades .
  
  Essa ação gera a ID do aplicativo e solicita que você confirme as informações. Selecione Continuar e, em seguida, selecione Registrar para confirmar a 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 .
Na página Certificados, Identificadores & Perfis , em Identificadores, localize o item de linha ID do Aplicativo que você criou. Em seguida, selecione sua linha para exibir a tela Editar configuração de ID do aplicativo.

Criando um certificado para Hubs de Notificação

Um certificado é necessário para permitir que o hub de notificação funcione com o APNS (Serviços de Notificação por Push) da Apple e pode ser fornecido de duas maneiras:

Criando um certificado push p12 que pode ser carregado diretamente no Hub de Notificação (a abordagem original)
Criando um certificado p8 que pode ser usado para autenticação baseada em token (a abordagem mais recente e recomendada)

A abordagem mais recente tem uma série de benefícios, conforme documentado na autenticação baseada em token (HTTP/2) para APNS. Menos etapas são necessárias, mas também são obrigatórias para cenários específicos. No entanto, foram fornecidas etapas para ambas as abordagens, pois ambas funcionarão para fins deste tutorial.

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

No Mac, execute a ferramenta Acesso ao Conjunto de Chaves. Ele pode ser aberto na pasta Utilitários ou na pasta Outros no Launchpad.
Selecione Acesso ao Conjunto de Chaves, expanda Assistente de Certificado e, em seguida, selecione Solicitar um Certificado de uma Autoridade de Certificação.

Observação

Por padrão, o Acesso ao Conjunto de Chaves seleciona o primeiro item da lista. Isso pode ser um problema se você estiver na categoria Certificados e a Apple Worldwide Developer Relations Certification Authority não for o primeiro item da lista. Verifique se você tem um item não chave ou se a chave da Autoridade de Certificação de Relações com o Desenvolvedor Mundial da Apple está selecionada, antes de gerar o CSR (Solicitação de Assinatura de Certificado).
Selecione o Endereço Email de Usuário, insira o valor nome comum, especifique Salvo em disco e selecione Continuar. Deixe ca Email Endereço em branco, pois ele não é necessário.
Insira um nome para o arquivo CSR (Solicitação de Autenticação de Certificado) em Salvar como, selecione o local em Onde e, em seguida, selecione Salvar.

Essa ação salva o arquivo CSR no local selecionado. O local padrão é Área de Trabalho. Lembre-se do local escolhido para o arquivo.
De volta à página Certificados, Identificadores & Perfis no Portal de Provisionamento do iOS, role para baixo até a opção Notificações por Push marcadas e selecione Configurar para criar o certificado.
A janela Certificados TLS/SSL do serviço de Notificação por Push da Apple é exibida. Selecione o botão Criar Certificado na seção Certificado TLS/SSL de Desenvolvimento .

A tela Criar um novo Certificado é exibida.

Observação

Este tutorial usa um certificado de desenvolvimento. O mesmo processo é usado ao registrar um certificado de produção. Apenas certifique-se de usar o mesmo tipo de certificado ao enviar notificações.
Selecione Escolher Arquivo, navegue até o local onde você salvou o arquivo CSR e clique duas vezes no nome do certificado para carregá-lo. Em seguida, selecione Continuar.
Depois que o portal criar o certificado, selecione o botão Baixar . Salve o certificado e lembre-se do local no qual ele foi salvo.

O certificado é baixado e salvo no computador na pasta Downloads .

Observação

Por padrão, o certificado de desenvolvimento baixado é nomeado aps_development.cer.
Clique duas vezes no certificado por push baixado aps_development.cer. Essa ação instala o novo certificado no conjunto de chaves, conforme mostrado na imagem a seguir:

Observação

Embora o nome no certificado possa ser diferente, o nome será prefixado com o Apple Development iOS Push Services e terá o identificador de pacote apropriado associado a ele.
No Acesso ao Conjunto de Chaves,clique em Controlar + no novo certificado push que você criou na categoria Certificados. Selecione Exportar, nomeie o arquivo, selecione o formato p12 e, em seguida, selecione Salvar.

Você pode optar por proteger o certificado com uma senha, mas uma senha é opcional. Clique em OK se quiser 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 é retratado neste tutorial.

OPTION 2: Criando um certificado p8 que pode ser usado para autenticação baseada em token

Anote os seguintes detalhes:
- Prefixo da ID do aplicativo (ID da equipe)
- ID do pacote
De volta a Certificados, Identificadores & Perfis, clique em Chaves.

Observação

Se você já tiver uma chave configurada para APNS, poderá reutilize o certificado p8 baixado logo após sua criação. Nesse caso, você pode ignorar as etapas 3 a 5.
Clique no + botão (ou no botão Criar uma chave ) para criar uma nova chave.
Forneça um valor de Nome de Chave adequado e, em seguida, marcar a opção APNS (Serviço de Notificações por Push) da Apple e clique em Continuar, seguido por Registrar na próxima tela.
Clique em Baixar e, em seguida, mova o arquivo p8 (prefixado com AuthKey_) para um diretório local seguro e clique em Concluído.

Observação

Certifique-se de manter o arquivo p8 em um local seguro (e salvar um backup). Depois de baixar a chave, ela não pode ser baixada novamente, pois a cópia do servidor é removida.
Em Chaves, clique na chave que você criou (ou em uma chave existente se tiver escolhido usá-la).
Anote o valor da ID da chave .
Abra o certificado p8 em uma aplicação adequada de sua escolha, como Visual Studio Code. Anote o valor da chave (entre -----BEGIN PRIVATE KEY----- e -----END PRIVATE KEY-----).

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

Observação

Esse é 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 em Configurar o hub de notificação com informações de APNS:

ID da equipe (consulte a etapa 1)
ID do pacote (consulte a etapa 1)
ID da chave (consulte a etapa 7)
Valor do token (valor da chave p8 obtido na etapa 8)

Criar um perfil de provisionamento para o aplicativo

Retorne ao Portal de Provisionamento do iOS, selecione Certificados, Identificadores & Perfis, selecione Perfis no menu à esquerda e selecione + para criar um novo perfil. A tela Registrar um Novo Perfil de Provisionamento é exibida.
Selecione Desenvolvimento de Aplicativos do iOS em Desenvolvimento como o tipo de perfil de provisionamento e, em seguida, selecione Continuar.
Em seguida, selecione a ID do aplicativo que você criou na lista suspensa ID do aplicativo e selecione Continuar.
Na janela Selecionar certificados , selecione o certificado de desenvolvimento que você usa para assinatura de código e selecione Continuar.

Observação

Esse certificado não é o certificado push que você criou na etapa anterior. Esse é o certificado de desenvolvimento. Se não existir, você deverá criá-lo, pois este é um pré-requisito para este tutorial. Os certificados de desenvolvedor podem ser criados no Portal do Desenvolvedor da Apple, por meio do Xcode ou do Visual Studio.
Retorne à página Certificados, Identificadores & Perfis , selecione Perfis no menu à esquerda e, em seguida, selecione + para criar um novo perfil. A tela Registrar um Novo Perfil de Provisionamento é exibida.
Na janela Selecionar certificados , selecione o certificado de desenvolvimento que você criou. Em seguida, selecione Continuar.
Em seguida, selecione os dispositivos a serem usados para teste e selecione Continuar.
Por fim, escolha um nome para o perfil em Nome do Perfil de Provisionamento e selecione Gerar.
Quando o novo perfil de provisionamento for criado, selecione Baixar. Lembre-se do local no qual ele foi salvo.
Navegue até o local do perfil de provisionamento e clique duas vezes nele para instalá-lo no computador de desenvolvimento.

Criar um Hub de Notificação

Nesta seção, você criará um hub de notificação e configurará a autenticação com APNS. Você pode usar um certificado push p12 ou uma autenticação baseada em token. Se você quiser usar um hub de notificação que já criou, poderá pular para a etapa 5.

Entre no Azure.
Clique em Criar um recurso, pesquise e escolha Hub de Notificação e clique em Criar.
Atualize os seguintes campos e clique em Criar:

DETALHES BÁSICOS

Assinatura: Escolha a Assinatura de destino na lista suspensa
Grupo de Recursos: Criar um novo Grupo de Recursos (ou escolher um existente)

DETALHES DO NAMESPACE

Namespace do Hub de Notificação: Insira um nome global exclusivo para o namespace do Hub de Notificação

Observação

Verifique se a opção Criar novo está selecionada para este campo.

DETALHES DO HUB DE NOTIFICAÇÃO

Hub de Notificação: Insira um nome para o Hub de Notificação
Localização: Escolha um local adequado na lista suspensa
Tipo de preço: Manter a opção gratuita padrão

Observação

A menos que você tenha atingido o número máximo de hubs na camada gratuita.
Depois que o Hub de Notificação tiver sido provisionado, navegue até esse recurso.
Navegue até o novo Hub de Notificação.
Selecione Políticas de Acesso na lista (em GERENCIAR).
Anote os valores de Nome da Política junto com seus valores de Cadeia de Conexão correspondentes.

Configurar o Hub de Notificação com informações de APNS

Em Serviços de Notificação, selecione Apple e siga as etapas apropriadas com base na abordagem escolhida anteriormente na seção Criando um certificado para hubs de notificação .

Observação

Use a 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

Selecione Certificado.
Selecione o ícone de arquivo.
Selecione o arquivo .p12 que você exportou anteriormente e selecione Abrir.
Se necessário, especifique a senha correta.
Selecione Modo de área restrita .
Clique em Salvar.

OPTION 2: Usando a autenticação baseada em token

Selecione Token.
Insira os seguintes valores adquiridos anteriormente:
- ID da chave
- ID do pacote
- ID da equipe
- Token
Escolha Área Restrita.
Clique em Salvar.

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

Selecione Google (GCM/FCM) na seção Configurações no menu à esquerda.
Insira a chave do servidor anotada no Console do Google Firebase.
Selecione Salvar na barra de ferramentas.

Criar um aplicativo de back-end da API Web ASP.NET Core

Nesta seção, você criará o ASP.NET Core back-end da API Web para lidar com o registro do dispositivo e o envio de notificações para o aplicativo móvel Xamarin.Forms.

Criar um projeto Web

No Visual Studio, selecione Arquivo>Nova Solução.
SelecioneAplicativo>.NET Core>ASP.NET Core>API>Avançar.
Na caixa de diálogo Configurar seu novo ASP.NET Core API Web, selecioneTarget Framework do .NET Core 3.1.
Insira PushDemoApi para o Nome do Projeto e selecione Criar.
Inicie a depuração (Command + Enter) para testar o aplicativo modelo.
Observação

O aplicativo modelo é configurado para usar o WeatherForecastController como launchUrl. Isso é definido em Propriedades>launchSettings.json.

Se você for solicitado com uma mensagem de certificado de desenvolvimento inválido encontrada :
1. Clique em Sim para concordar em executar a ferramenta 'dotnet dev-certs https' para corrigir isso. A ferramenta 'dotnet dev-certs https' solicita que você insira uma senha para o certificado e a senha do conjunto de chaves.
2. Clique em Sim quando solicitado a Instalar e confiar no novo certificado e, em seguida, insira a senha do conjunto de chaves.
Expanda a pasta Controladores e exclua WeatherForecastController.cs.
Excluir WeatherForecast.cs.
Configure valores de configuração local usando a ferramenta Gerenciador de Segredos. A desacoplamento dos segredos da solução garante que eles não acabem no controle do código-fonte. Abra o Terminal e vá para o diretório do arquivo de projeto e execute os seguintes comandos:
```
dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" <value>
```
Substitua os valores de espaço reservado por seu próprio nome de hub de notificação e valores de cadeia de conexão. Você anotou uma nota deles na seção criar um hub de notificação . Caso contrário, você pode pesquisá-los no Azure.

NotificationHub:Name:
Consulte Nome no resumo do Essentials na parte superior da Visão geral.

NotificationHub:ConnectionString:
Consulte DefaultFullSharedAccessSignature em Políticas de Acesso

Observação

Para cenários de produção, você pode examinar opções como o Azure KeyVault para armazenar com segurança o cadeia de conexão. Para simplificar, os segredos serão adicionados às configurações do aplicativo Serviço de Aplicativo do Azure.

Autenticar clientes usando uma chave de API (opcional)

As chaves de API não são tão seguras quanto os tokens, mas serão suficientes para os fins deste tutorial. Uma chave de API pode ser configurada facilmente por meio do middleware ASP.NET.

Adicione a chave de API aos valores de configuração local.
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Observação

Você deve substituir o valor do espaço reservado pelo seu próprio e anote-o.
Controle + Clique no projeto PushDemoApi , escolha Nova Pasta no menu Adicionar e clique em Adicionar usando Autenticação como o Nome da Pasta.
Controle + Clique na pasta Autenticação e escolha Novo Arquivo... no menu Adicionar .

SelecioneClasse VaziaGeral>, insira ApiKeyAuthOptions.cs para o Nome e clique em Novo adicionando a implementação a seguir.

using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthOptions : AuthenticationSchemeOptions
    {
        public const string DefaultScheme = "ApiKey";
        public string Scheme => DefaultScheme;
        public string ApiKey { get; set; }
    }
}

Adicione outra Classe Vazia à pasta Autenticação chamada ApiKeyAuthHandler.cs e adicione a implementação a seguir.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthHandler : AuthenticationHandler<ApiKeyAuthOptions>
    {
        const string ApiKeyIdentifier = "apikey";

        public ApiKeyAuthHandler(
            IOptionsMonitor<ApiKeyAuthOptions> options,
            ILoggerFactory logger,
            UrlEncoder encoder,
            ISystemClock clock)
            : base(options, logger, encoder, clock) {}

        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            string key = string.Empty;

            if (Request.Headers[ApiKeyIdentifier].Any())
            {
                key = Request.Headers[ApiKeyIdentifier].FirstOrDefault();
            }
            else if (Request.Query.ContainsKey(ApiKeyIdentifier))
            {
                if (Request.Query.TryGetValue(ApiKeyIdentifier, out var queryKey))
                    key = queryKey;
            }

            if (string.IsNullOrWhiteSpace(key))
                return Task.FromResult(AuthenticateResult.Fail("No api key provided"));

            if (!string.Equals(key, Options.ApiKey, StringComparison.Ordinal))
                return Task.FromResult(AuthenticateResult.Fail("Invalid api key."));

            var identities = new List<ClaimsIdentity> {
                new ClaimsIdentity("ApiKeyIdentity")
            };

            var ticket = new AuthenticationTicket(
                new ClaimsPrincipal(identities), Options.Scheme);

            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
    }
}

Observação

Um Manipulador de Autenticação é um tipo que implementa o comportamento de um esquema, nesse caso, um esquema de chave de API personalizado.

Adicione outra Classe Vazia à pasta Autenticação chamada ApiKeyAuthenticationBuilderExtensions.cs e adicione a implementação a seguir.

using System;
using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public static class AuthenticationBuilderExtensions
    {
        public static AuthenticationBuilder AddApiKeyAuth(
            this AuthenticationBuilder builder,
            Action<ApiKeyAuthOptions> configureOptions)
        {
            return builder
                .AddScheme<ApiKeyAuthOptions, ApiKeyAuthHandler>(
                    ApiKeyAuthOptions.DefaultScheme,
                    configureOptions);
        }
    }
}

Observação

Esse método de extensão simplifica o código de configuração de middleware em Startup.cs tornando-o mais legível e geralmente mais fácil de seguir.

Em Startup.cs, atualize o método ConfigureServices para configurar a autenticação de Chave de API abaixo da chamada para os serviços. Método AddControllers .

using PushDemoApi.Authentication;
using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = ApiKeyAuthOptions.DefaultScheme;
        options.DefaultChallengeScheme = ApiKeyAuthOptions.DefaultScheme;
    }).AddApiKeyAuth(Configuration.GetSection("Authentication").Bind);
}

Ainda em Startup.cs, atualize o método Configure para chamar os métodos de extensão UseAuthentication e UseAuthorization no IApplicationBuilder do aplicativo. Verifique se esses métodos são chamados após UseRouting e antes do aplicativo. UseEndpoints.
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthentication();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}
```
Observação

Chamar UseAuthentication registra o middleware que usa os esquemas de autenticação registrados anteriormente (de ConfigureServices). Isso deve ser chamado antes de qualquer middleware que dependa da autenticação dos usuários.

Adicionar dependências e configurar serviços

ASP.NET Core dá suporte ao padrão de design de software de DI (injeção de dependência), que é uma técnica para alcançar a IoC (Inversão de Controle) entre classes e suas dependências.

O uso do hub de notificação e do SDK dos Hubs de Notificação para operações de back-end é encapsulado em um serviço. O serviço é registrado e disponibilizado por meio de uma abstração adequada.

Controle + Clique na pasta Dependências e escolha Gerenciar Pacotes NuGet....
Pesquise Microsoft.Azure.NotificationHubs e verifique se ele está marcado.
Clique em Adicionar Pacotes e em Aceitar quando solicitado a aceitar os termos de licença.
Controle + Clique no projeto PushDemoApi , escolha Nova Pasta no menu Adicionar e, em seguida, clique em Adicionar usando Modelos como o Nome da Pasta.
Controle + Clique na pasta Modelos e escolha Novo Arquivo... no menu Adicionar .

SelecioneClasse VaziaGeral>, insira PushTemplates.cs para o Nome e clique em Novo adicionando a implementação a seguir.

namespace PushDemoApi.Models
{
    public class PushTemplates
    {
        public class Generic
        {
            public const string Android = "{ \"notification\": { \"title\" : \"PushDemo\", \"body\" : \"$(alertMessage)\"}, \"data\" : { \"action\" : \"$(alertAction)\" } }";
            public const string iOS = "{ \"aps\" : {\"alert\" : \"$(alertMessage)\"}, \"action\" : \"$(alertAction)\" }";
        }

        public class Silent
        {
            public const string Android = "{ \"data\" : {\"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\"} }";
            public const string iOS = "{ \"aps\" : {\"content-available\" : 1, \"apns-priority\": 5, \"sound\" : \"\", \"badge\" : 0}, \"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\" }";
        }
    }
}

Observação

Essa classe contém os conteúdos de notificação com token para as notificações genéricas e silenciosas exigidas por esse cenário. As cargas são definidas fora da Instalação para permitir a experimentação sem precisar atualizar as instalações existentes por meio do serviço. O tratamento de alterações nas instalações dessa maneira está fora do escopo deste tutorial. Para produção, considere modelos personalizados.

Adicione outra Classe Vazia à pasta Modelos chamada DeviceInstallation.cs e adicione a implementação a seguir.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class DeviceInstallation
    {
        [Required]
        public string InstallationId { get; set; }

        [Required]
        public string Platform { get; set; }

        [Required]
        public string PushChannel { get; set; }

        public IList<string> Tags { get; set; } = Array.Empty<string>();
    }
}

Adicione outra Classe Vazia à pasta Modelos chamada NotificationRequest.cs e adicione a implementação a seguir.

using System;

namespace PushDemoApi.Models
{
    public class NotificationRequest
    {
        public string Text { get; set; }
        public string Action { get; set; }
        public string[] Tags { get; set; } = Array.Empty<string>();
        public bool Silent { get; set; }
    }
}

Adicione outra Classe Vazia à pasta Modelos chamada NotificationHubOptions.cs e adicione a implementação a seguir.

using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class NotificationHubOptions
    {
        [Required]
        public string Name { get; set; }

        [Required]
        public string ConnectionString { get; set; }
    }
}

Adicione uma nova pasta ao projeto PushDemoApi chamado Serviços.

Adicione uma Interface Vazia à pasta Serviços chamada INotificationService.cs e adicione a implementação a seguir.

using System.Threading;
using System.Threading.Tasks;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public interface INotificationService
    {
        Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token);
        Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token);
        Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token);
    }
}

Adicione uma Classe Vazia à pasta Serviços chamada NotificationHubsService.cs e adicione o seguinte código para implementar a interface INotificationService :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public class NotificationHubService : INotificationService
    {
        readonly NotificationHubClient _hub;
        readonly Dictionary<string, NotificationPlatform> _installationPlatform;
        readonly ILogger<NotificationHubService> _logger;

        public NotificationHubService(IOptions<NotificationHubOptions> options, ILogger<NotificationHubService> logger)
        {
            _logger = logger;
            _hub = NotificationHubClient.CreateClientFromConnectionString(
                options.Value.ConnectionString,
                options.Value.Name);

            _installationPlatform = new Dictionary<string, NotificationPlatform>
            {
                { nameof(NotificationPlatform.Apns).ToLower(), NotificationPlatform.Apns },
                { nameof(NotificationPlatform.Fcm).ToLower(), NotificationPlatform.Fcm }
            };
        }

        public async Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(deviceInstallation?.InstallationId) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.Platform) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.PushChannel))
                return false;

            var installation = new Installation()
            {
                InstallationId = deviceInstallation.InstallationId,
                PushChannel = deviceInstallation.PushChannel,
                Tags = deviceInstallation.Tags
            };

            if (_installationPlatform.TryGetValue(deviceInstallation.Platform, out var platform))
                installation.Platform = platform;
            else
                return false;

            try
            {
                await _hub.CreateOrUpdateInstallationAsync(installation, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(installationId))
                return false;

            try
            {
                await _hub.DeleteInstallationAsync(installationId, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token)
        {
            if ((notificationRequest.Silent &&
                string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
                (!notificationRequest.Silent &&
                (string.IsNullOrWhiteSpace(notificationRequest?.Text)) ||
                string.IsNullOrWhiteSpace(notificationRequest?.Action)))
                return false;

            var androidPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.Android :
                PushTemplates.Generic.Android;

            var iOSPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.iOS :
                PushTemplates.Generic.iOS;

            var androidPayload = PrepareNotificationPayload(
                androidPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            var iOSPayload = PrepareNotificationPayload(
                iOSPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            try
            {
                if (notificationRequest.Tags.Length == 0)
                {
                    // This will broadcast to all users registered in the notification hub
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, token);
                }
                else if (notificationRequest.Tags.Length <= 20)
                {
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, notificationRequest.Tags, token);
                }
                else
                {
                    var notificationTasks = notificationRequest.Tags
                        .Select((value, index) => (value, index))
                        .GroupBy(g => g.index / 20, i => i.value)
                        .Select(tags => SendPlatformNotificationsAsync(androidPayload, iOSPayload, tags, token));

                    await Task.WhenAll(notificationTasks);
                }

                return true;
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Unexpected error sending notification");
                return false;
            }
        }

        string PrepareNotificationPayload(string template, string text, string action) => template
            .Replace("$(alertMessage)", text, StringComparison.InvariantCulture)
            .Replace("$(alertAction)", action, StringComparison.InvariantCulture);

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, token)
            };

            return Task.WhenAll(sendTasks);
        }

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, IEnumerable<string> tags, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, tags, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, tags, token)
            };

            return Task.WhenAll(sendTasks);
        }
    }
}

Observação

A expressão de marca fornecida a SendTemplateNotificationAsync é limitada a 20 marcas. Ele é limitado a 6 para a maioria dos operadores, mas a expressão contém apenas ORs (||) nesse caso. Se houver mais de 20 marcas na solicitação, elas deverão ser divididas em várias solicitações. Consulte a documentação Expressões de Roteamento e Marca para obter mais detalhes.

Em Startup.cs, atualize o método ConfigureServices para adicionar o NotificationHubsService como uma implementação singleton de INotificationService.


using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<INotificationService, NotificationHubService>();

    services.AddOptions<NotificationHubOptions>()
        .Configure(Configuration.GetSection("NotificationHub").Bind)
        .ValidateDataAnnotations();
}

Criar a API de notificações

Controle + Clique na pasta Controladores e escolha Novo Arquivo... no menu Adicionar .
Selecione ASP.NET Core>Classe de Controlador de API Web, insira NotificationsController para o Nome e clique em Novo.

Observação

Se você estiver seguindo com o Visual Studio 2019, escolha o modelo Controlador de API com ações de leitura/gravação .

Adicione os namespaces a seguir à parte superior do arquivo.

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PushDemoApi.Models;
using PushDemoApi.Services;

Atualize o controlador modelo para que ele seja derivado de ControllerBase e seja decorado com o atributo ApiController .
```
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase
{
    // Templated methods here
}
```
Observação

A classe base Controller fornece suporte para exibições, mas isso não é necessário nesse caso e, portanto , ControllerBase pode ser usado. Se você estiver seguindo com o Visual Studio 2019, ignore esta etapa.
Se você optar por concluir a seção Autenticar clientes usando uma Chave de API , decore o NotificationsController com o atributo Authorize também.
```
[Authorize]
```

Atualize o construtor para aceitar a instância registrada de INotificationService como um argumento e atribua-o a um membro somente leitura.

readonly INotificationService _notificationService;

public NotificationsController(INotificationService notificationService)
{
    _notificationService = notificationService;
}

Em launchSettings.json (dentro da pasta Propriedades ), altere launchUrl de weatherforecast para api/notifications para corresponder à URL especificada no atributo RegistrationsControllerRoute .
Inicie a depuração (Command + Enter) para validar se o aplicativo está funcionando com o novo NotificationsController e retorna um 401 Status não autorizado.

Observação

O Visual Studio pode não iniciar automaticamente o aplicativo no navegador. Você usará o Postman para testar a API desse ponto em diante.
Em uma nova guia do Postman , defina a solicitação como GET. Insira o endereço abaixo substituindo o espaço reservado< applicationUrl> pelo aplicativo httpsUrl encontrado em Propriedades>launchSettings.json.
```
<applicationUrl>/api/notifications
```
Observação

O applicationUrl deve ser 'https://localhost:5001' para o perfil padrão. Se você estiver usando o IIS (padrão no Visual Studio 2019 no Windows), deverá usar o applicationUrl especificado no item iisSettings . Você receberá uma resposta 404 se o endereço estiver incorreto.
Se você optar por concluir a seção Autenticar clientes usando uma Chave de API , configure os cabeçalhos de solicitação para incluir o valor de apikey .

Chave Valor

apikey <your_api_key>
Clique no botão Enviar .

Observação

Você deve receber uma status 200 OK com algum conteúdo JSON.

Se você receber um aviso de verificação de certificado SSL , poderá alternar a configuração do Postman de verificação de certificado SSL de solicitação nas Configurações.

Chave	Valor
apikey	<your_api_key>

Substitua os métodos de classe com modelo em NotificationsController.cs pelo código a seguir.

[HttpPut]
[Route("installations")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> UpdateInstallation(
    [Required]DeviceInstallation deviceInstallation)
{
    var success = await _notificationService
        .CreateOrUpdateInstallationAsync(deviceInstallation, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpDelete()]
[Route("installations/{installationId}")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<ActionResult> DeleteInstallation(
    [Required][FromRoute]string installationId)
{
    var success = await _notificationService
        .DeleteInstallationByIdAsync(installationId, CancellationToken.None);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpPost]
[Route("requests")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> RequestPush(
    [Required]NotificationRequest notificationRequest)
{
    if ((notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
        (!notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Text)))
        return new BadRequestResult();

    var success = await _notificationService
        .RequestNotificationAsync(notificationRequest, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

Criar o aplicativo de API

Agora você cria um Aplicativo de API no Serviço de Aplicativo do Azure para hospedar o serviço de back-end.

Entre no portal do Azure.
Clique em Criar um recurso, pesquise e escolha Aplicativo de API e clique em Criar.
Atualize os campos a seguir e clique em Criar.

Nome do aplicativo:
Insira um nome globalmente exclusivo para o aplicativo de API

Assinatura:
Escolha a mesma Assinatura de destino na qual você criou o hub de notificação.

Grupo de Recursos:
Escolha o mesmo Grupo de Recursos no qual você criou o hub de notificação.

Serviço de Aplicativo Plano/Local:
Criar um novo plano de Serviço de Aplicativo

Observação

Altere da opção padrão para um plano que inclua suporte a SSL . Caso contrário, você precisará executar as etapas apropriadas ao trabalhar com o aplicativo móvel para impedir que as solicitações http sejam bloqueadas.

Application Insights:
Mantenha a opção sugerida (um novo recurso será criado usando esse nome) ou escolha um recurso existente.
Depois que o Aplicativo de API tiver sido provisionado, navegue até esse recurso.
Anote a propriedade URL no resumo do Essentials na parte superior da Visão geral. Essa URL é o ponto de extremidade de back-end que será usado posteriormente neste tutorial.

Observação

A URL usa o nome do aplicativo de API especificado anteriormente, com o formato https://<app_name>.azurewebsites.net.
Selecione Configuração na lista (em Configurações).
Para cada uma das configurações abaixo, clique em Nova configuração de aplicativo para inserir o Nome e um Valor e clique em OK.

Nome Valor

Authentication:ApiKey <api_key_value>

NotificationHub:Name <hub_name_value>

NotificationHub:ConnectionString <hub_connection_string_value>

Observação

Essas são as mesmas configurações que você definiu anteriormente nas configurações do usuário. Você deve ser capaz de copiá-los. A configuração Authentication:ApiKey será necessária somente se você optar por concluir a seção Autenticar clientes usando uma chave de API . Para cenários de produção, você pode examinar opções como o Azure KeyVault. Elas foram adicionadas como configurações de aplicativo para simplificar nesse caso.
Depois que todas as configurações do aplicativo tiverem sido adicionadas, clique em Salvar e em Continuar.

Nome	Valor
`Authentication:ApiKey`	<api_key_value>
`NotificationHub:Name`	<hub_name_value>
`NotificationHub:ConnectionString`	<hub_connection_string_value>

Publicar o serviço de back-end

Em seguida, implante o aplicativo no Aplicativo de API para torná-lo acessível de todos os dispositivos.

Observação

As etapas a seguir são específicas para Visual Studio para Mac. Se você estiver seguindo com o Visual Studio 2019 no Windows, o fluxo de publicação será diferente. Consulte Publicar no Serviço de Aplicativo do Azure no Windows.

Altere sua configuração de Depurar para Versão se você ainda não tiver feito isso.
Controle + Clique no projeto PushDemoApi e escolha Publicar no Azure... no menu Publicar .
Siga o fluxo de autenticação se solicitado a fazê-lo. Use a conta que você usou na seção anterior criar o Aplicativo de API .
Selecione o aplicativo de API Serviço de Aplicativo do Azure criado anteriormente na lista como destino de publicação e clique em Publicar.

Depois de concluir o assistente, ele publicará o aplicativo no Azure e abrirá o aplicativo. Anote a URL se você ainda não tiver feito isso. Essa URL é o ponto de extremidade de back-end usado posteriormente neste tutorial.

Validando a API publicada

No Postman , abra uma nova guia, defina a solicitação como PUT e insira o endereço abaixo. Substitua o espaço reservado pelo endereço base que você anotou na seção publicar anteriormente o serviço de back-end .
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
Observação

O endereço base deve estar no formato https://<app_name>.azurewebsites.net/
Se você optar por concluir a seção Autenticar clientes usando uma Chave de API , configure os cabeçalhos de solicitação para incluir o valor de apikey .

Chave Valor

apikey <your_api_key>
Escolha a opção bruta para o Corpo, escolha JSON na lista de opções de formato e, em seguida, inclua algum conteúdo JSON de espaço reservado:
```
{}
```
Clique em Enviar.

Observação

Você deve receber uma status 422 UnprocessableEntity do serviço.
Execute as etapas de 1 a 4 novamente, mas desta vez especificando o ponto de extremidade de solicitações para validar se você recebe uma resposta de Solicitação Inválida 400 .
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

Chave	Valor
apikey	<your_api_key>

Observação

Ainda não é possível testar a API usando dados de solicitação válidos, pois isso exigirá informações específicas da plataforma do aplicativo móvel cliente.

Criar um aplicativo Xamarin.Forms multiplataforma

Nesta seção, você criará um aplicativo móvel Xamarin.Forms implementando notificações por push de maneira multiplataforma.

Ele permite registrar e cancelar o registro de um hub de notificação por meio do serviço de back-end que você criou.

Um alerta é exibido quando uma ação é especificada e o aplicativo está em primeiro plano. Caso contrário, as notificações aparecerão no centro de notificações.

Observação

Normalmente, você executaria as ações de registro (e desregistração) durante o ponto apropriado no ciclo de vida do aplicativo (ou como parte de sua experiência de primeira execução, talvez) sem entradas explícitas de registro/cancelamento de registro de usuário. No entanto, este exemplo exigirá entrada explícita do usuário para permitir que essa funcionalidade seja explorada e testada com mais facilidade.

Criar a solução Xamarin.Forms

No Visual Studio, crie uma nova solução do Xamarin.Forms usando o aplicativo Blank Forms como o modelo e inserindo PushDemo para o Nome do Projeto.

Observação

Na caixa de diálogo Configurar seu Aplicativo de Formulários em Branco , verifique se o Identificador da Organização corresponde ao valor usado anteriormente e se os destinos do Android e do iOS estão marcados.
Controle + Clique na solução PushDemo e escolha Atualizar Pacotes NuGet.
Controle + Clique na solução PushDemo e escolha Gerenciar Pacotes NuGet...
Pesquise Newtonsoft.Json e verifique se ele está marcado.
Clique em Adicionar Pacotes e em Aceitar quando solicitado a aceitar os termos de licença.
Compile e execute o aplicativo em cada plataforma de destino (Command + Enter) para testar as execuções do aplicativo modelo em seus dispositivos.

Implementar os componentes multiplataforma

Controle + Clique no projeto PushDemo , escolha Nova Pasta no menu Adicionar e, em seguida, clique em Adicionar usando Modelos como o Nome da Pasta.
Controle + Clique na pasta Modelos e escolha Novo Arquivo... no menu Adicionar .

SelecioneClasse VaziaGeral>, insira DeviceInstallation.cs e adicione a implementação a seguir.

using System.Collections.Generic;
using Newtonsoft.Json;

namespace PushDemo.Models
{
    public class DeviceInstallation
    {
        [JsonProperty("installationId")]
        public string InstallationId { get; set; }

        [JsonProperty("platform")]
        public string Platform { get; set; }

        [JsonProperty("pushChannel")]
        public string PushChannel { get; set; }

        [JsonProperty("tags")]
        public List<string> Tags { get; set; } = new List<string>();
    }
}

Adicione uma Enumeração Vazia à pasta Modelos chamada PushDemoAction.cs com a implementação a seguir.

namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}

Adicione uma nova pasta ao projeto PushDemo chamado Serviços e adicione uma Classe Vazia a essa pasta chamada ServiceContainer.cs com a implementação a seguir.

using System;
using System.Collections.Generic;

namespace PushDemo.Services
{
   public static class ServiceContainer
   {
       static readonly Dictionary<Type, Lazy<object>> services
           = new Dictionary<Type, Lazy<object>>();

       public static void Register<T>(Func<T> function)
           => services[typeof(T)] = new Lazy<object>(() => function());

       public static T Resolve<T>()
           => (T)Resolve(typeof(T));

       public static object Resolve(Type type)
       {
           {
               if (services.TryGetValue(type, out var service))
                   return service.Value;

               throw new KeyNotFoundException($"Service not found for type '{type}'");
           }
       }
   }
}

Observação

Esta é uma versão reduzida da classe ServiceContainer do repositório XamCAT . Ele será usado como um contêiner de IoC leve (Inversão de Controle).

Adicione uma Interface Vazia à pasta Serviços chamada IDeviceInstallationService.cs e adicione o código a seguir.
```
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IDeviceInstallationService
    {
        string Token { get; set; }
        bool NotificationsSupported { get; }
        string GetDeviceId();
        DeviceInstallation GetDeviceInstallation(params string[] tags);
    }
}
```
Observação

Essa interface será implementada e inicializada por cada destino posteriormente para fornecer a funcionalidade específica da plataforma e as informações de DeviceInstallation exigidas pelo serviço de back-end.

Adicione outra Interface Vazia à pasta Serviços chamada INotificationRegistrationService.cs e adicione o código a seguir.

using System.Threading.Tasks;

namespace PushDemo.Services
{
    public interface INotificationRegistrationService
    {
        Task DeregisterDeviceAsync();
        Task RegisterDeviceAsync(params string[] tags);
        Task RefreshRegistrationAsync();
    }
}

Observação

Isso manipulará a interação entre o cliente e o serviço de back-end.

Adicione outra Interface Vazia à pasta Serviços chamada INotificationActionService.cs e adicione o código a seguir.
```
namespace PushDemo.Services
{
    public interface INotificationActionService
    {
        void TriggerAction(string action);
    }
}
```
Observação

Isso é usado como um mecanismo simples para centralizar o tratamento de ações de notificação.
Adicione uma Interface Vazia à pasta Serviços chamada IPushDemoNotificationActionService.cs derivada de INotificationActionService, com a implementação a seguir.
```
using System;
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IPushDemoNotificationActionService : INotificationActionService
    {
        event EventHandler<PushDemoAction> ActionTriggered;
    }
}
```
Observação

Esse tipo é específico para o aplicativo PushDemo e usa a enumeração PushDemoAction para identificar a ação que está sendo disparada de maneira fortemente tipada.

Adicione uma Classe Vazia à pasta Serviços chamada NotificationRegistrationService.cs implementação do INotificationRegistrationService com o código a seguir.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using PushDemo.Models;
using Xamarin.Essentials;

namespace PushDemo.Services
{
    public class NotificationRegistrationService : INotificationRegistrationService
    {
        const string RequestUrl = "api/notifications/installations";
        const string CachedDeviceTokenKey = "cached_device_token";
        const string CachedTagsKey = "cached_tags";

        string _baseApiUrl;
        HttpClient _client;
        IDeviceInstallationService _deviceInstallationService;

        public NotificationRegistrationService(string baseApiUri, string apiKey)
        {
            _client = new HttpClient();
            _client.DefaultRequestHeaders.Add("Accept", "application/json");
            _client.DefaultRequestHeaders.Add("apikey", apiKey);

            _baseApiUrl = baseApiUri;
        }

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService = ServiceContainer.Resolve<IDeviceInstallationService>());

        public async Task DeregisterDeviceAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            if (cachedToken == null)
                return;

            var deviceId = DeviceInstallationService?.GetDeviceId();

            if (string.IsNullOrWhiteSpace(deviceId))
                throw new Exception("Unable to resolve an ID for the device.");

            await SendAsync(HttpMethod.Delete, $"{RequestUrl}/{deviceId}")
                .ConfigureAwait(false);

            SecureStorage.Remove(CachedDeviceTokenKey);
            SecureStorage.Remove(CachedTagsKey);
        }

        public async Task RegisterDeviceAsync(params string[] tags)
        {
            var deviceInstallation = DeviceInstallationService?.GetDeviceInstallation(tags);

            await SendAsync<DeviceInstallation>(HttpMethod.Put, RequestUrl, deviceInstallation)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedDeviceTokenKey, deviceInstallation.PushChannel)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedTagsKey, JsonConvert.SerializeObject(tags));
        }

        public async Task RefreshRegistrationAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            var serializedTags = await SecureStorage.GetAsync(CachedTagsKey)
                .ConfigureAwait(false);

            if (string.IsNullOrWhiteSpace(cachedToken) ||
                string.IsNullOrWhiteSpace(serializedTags) ||
                string.IsNullOrWhiteSpace(DeviceInstallationService.Token) ||
                cachedToken == DeviceInstallationService.Token)
                return;

            var tags = JsonConvert.DeserializeObject<string[]>(serializedTags);

            await RegisterDeviceAsync(tags);
        }

        async Task SendAsync<T>(HttpMethod requestType, string requestUri, T obj)
        {
            string serializedContent = null;

            await Task.Run(() => serializedContent = JsonConvert.SerializeObject(obj))
                .ConfigureAwait(false);

            await SendAsync(requestType, requestUri, serializedContent);
        }

        async Task SendAsync(
            HttpMethod requestType,
            string requestUri,
            string jsonRequest = null)
        {
            var request = new HttpRequestMessage(requestType, new Uri($"{_baseApiUrl}{requestUri}"));

            if (jsonRequest != null)
                request.Content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

            var response = await _client.SendAsync(request).ConfigureAwait(false);

            response.EnsureSuccessStatusCode();
        }
    }
}

Observação

O argumento apiKey só será necessário se você optar por concluir a seção Autenticar clientes usando uma chave de API .

Adicione uma Classe Vazia à pasta Serviços chamada PushDemoNotificationActionService.cs implementação do IPushDemoNotificationActionService com o código a seguir.

using System;
using System.Collections.Generic;
using System.Linq;
using PushDemo.Models;

namespace PushDemo.Services
{
    public class PushDemoNotificationActionService : IPushDemoNotificationActionService
    {
        readonly Dictionary<string, PushDemoAction> _actionMappings = new Dictionary<string, PushDemoAction>
        {
            { "action_a", PushDemoAction.ActionA },
            { "action_b", PushDemoAction.ActionB }
        };

        public event EventHandler<PushDemoAction> ActionTriggered = delegate { };

        public void TriggerAction(string action)
        {
            if (!_actionMappings.TryGetValue(action, out var pushDemoAction))
                return;

            List<Exception> exceptions = new List<Exception>();

            foreach (var handler in ActionTriggered?.GetInvocationList())
            {
                try
                {
                    handler.DynamicInvoke(this, pushDemoAction);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
                throw new AggregateException(exceptions);
        }
    }
}

Adicione uma Classe Vazia ao projeto PushDemo chamado Config.cs com a implementação a seguir.
```
namespace PushDemo
{
    public static partial class Config
    {
        public static string ApiKey = "API_KEY";
        public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
    }
}
```
Observação

Isso é usado como uma maneira simples de manter os segredos fora do controle do código-fonte. Você pode substituir esses valores como parte de um build automatizado ou substituí-los usando uma classe parcial local. Você fará isso na próxima etapa.

O campo ApiKey só será necessário se você optar por concluir a seção Autenticar clientes usando uma chave de API .
Adicione outra Classe Vazia ao projeto PushDemo desta vez chamada Config.local_secrets.cs com a implementação a seguir.
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
Observação

Substitua os valores de espaço reservado pelos seus próprios. Você deve ter anotado isso quando criou o serviço de back-end. A URL do Aplicativo de API deve ser https://<api_app_name>.azurewebsites.net/. Lembre-se de adicionar *.local_secrets.* ao arquivo gitignore para evitar confirmar esse arquivo.

O campo ApiKey só será necessário se você optar por concluir a seção Autenticar clientes usando uma chave de API .

Adicione uma Classe Vazia ao projeto PushDemo chamado Bootstrap.cs com a implementação a seguir.

using System;
using PushDemo.Services;

namespace PushDemo
{
    public static class Bootstrap
    {
        public static void Begin(Func<IDeviceInstallationService> deviceInstallationService)
        {
            ServiceContainer.Register(deviceInstallationService);

            ServiceContainer.Register<IPushDemoNotificationActionService>(()
                => new PushDemoNotificationActionService());

            ServiceContainer.Register<INotificationRegistrationService>(()
                => new NotificationRegistrationService(
                    Config.BackendServiceEndpoint,
                    Config.ApiKey));
        }
    }
}

Observação

O método Begin será chamado por cada plataforma quando o aplicativo iniciar a passagem de uma implementação específica da plataforma de IDeviceInstallationService.

O argumento do construtor apiKeyNotificationRegistrationService só será necessário se você optar por concluir a seção Autenticar clientes usando uma chave de API.

Implementar a interface do usuário multiplataforma

No projeto PushDemo , abra MainPage.xaml e substitua o controle StackLayout pelo seguinte.

<StackLayout VerticalOptions="EndAndExpand"  
             HorizontalOptions="FillAndExpand"
             Padding="20,40">
    <Button x:Name="RegisterButton"
            Text="Register"
            Clicked="RegisterButtonClicked" />
    <Button x:Name="DeregisterButton"
            Text="Deregister"
            Clicked="DeregisterButtonClicked" />
</StackLayout>

Agora, no MainPage.xaml.cs, adicione um campo de suporte somente leitura para armazenar uma referência à implementação INotificationRegistrationService .
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
No construtor MainPage, resolve a implementação INotificationRegistrationService usando o ServiceContainer e atribua-o ao campo de suporte notificationRegistrationService.
```
public MainPage()
{
    InitializeComponent();

    _notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>();
}
```

Implemente os manipuladores de eventos para os botões RegisterButton e DeregisterButtonEventos clicados chamando os métodos Register/Deregister correspondentes.

void RegisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.RegisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device registered"); });

void DeregisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.DeregisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device deregistered"); });

void ShowAlert(string message)
    => MainThread.BeginInvokeOnMainThread(()
        => DisplayAlert("PushDemo", message, "OK").ContinueWith((task)
            => { if (task.IsFaulted) throw task.Exception; }));

Agora, em App.xaml.cs, verifique se os namespaces a seguir são referenciados.

using PushDemo.Models;
using PushDemo.Services;
using Xamarin.Essentials;
using Xamarin.Forms;

Implemente o manipulador de eventos para o evento IPushDemoNotificationActionServiceActionTriggered .

void NotificationActionTriggered(object sender, PushDemoAction e)
    => ShowActionAlert(e);

void ShowActionAlert(PushDemoAction action)
    => MainThread.BeginInvokeOnMainThread(()
        => MainPage?.DisplayAlert("PushDemo", $"{action} action received", "OK")
            .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; }));

No construtor App, resolve a implementação IPushNotificationActionService usando o ServiceContainer e assine o evento IPushDemoNotificationActionServiceActionTriggered.
```
public App()
{
    InitializeComponent();

    ServiceContainer.Resolve<IPushDemoNotificationActionService>()
        .ActionTriggered += NotificationActionTriggered;

    MainPage = new MainPage();
}
```
Observação

Isso é simplesmente para demonstrar o recebimento e a propagação de ações de notificação por push. Normalmente, eles seriam tratados silenciosamente, por exemplo, navegando até uma exibição específica ou atualizando alguns dados em vez de exibir um alerta por meio da Página raiz, MainPage nesse caso.

Configurar o projeto nativo do Android para notificações por push

Validar o nome e as permissões do pacote

Em PushDemo.Android, abra as Opções de Projeto e, em seguida, Aplicativo Android na seção Compilar .
Verifique se o Nome do pacote corresponde ao valor usado no projeto PushDemo do Console do Firebase. O nome do pacote estava no formato com.<organization>.pushdemo.
Defina a Versão Mínima do Android como Android 8.0 (nível de API 26) e a Versão de Destino do Android para o nível de API mais recente.

Observação

Somente os dispositivos que executam o nível de API 26 e superiores têm suporte para os fins deste tutorial, no entanto, você pode estendê-lo para dar suporte a dispositivos que executam versões mais antigas.
Verifique se as permissões internet e READ_PHONE_STATE estão habilitadas em Permissões necessárias.
Clique em OK

Adicionar a base do Xamarin Google Play Services e os pacotes Xamarin.Firebase.Messaging

Em PushDemo.Android, Controle + Clique na pasta Pacotes e escolha Gerenciar Pacotes NuGet....
Pesquise Xamarin.GooglePlayServices.Base (não Porão) e verifique se ele está marcado.
Pesquise Xamarin.Firebase.Messaging e verifique se ele está marcado.
Clique em Adicionar Pacotes e em Aceitar quando solicitado a aceitar os termos de licença.

Adicionar o arquivo JSON do Google Services

Controle + Clique no PushDemo.Android projeto e escolha Arquivo Existente... no menu Adicionar .
Escolha o arquivo google-services.json que você baixou anteriormente ao configurar o projeto PushDemo no Console do Firebase e clique em Abrir.
Quando solicitado, escolha Copiar o arquivo para o diretório.
Controle + Clique no arquivo google-services.json de dentro do PushDemo.Android projeto e verifique se GoogleServicesJson está definido como a Ação de Build.

Manipular notificações por push para Android

Controle + Clique no PushDemo.Android projeto, escolha Nova Pasta no menu Adicionar e, em seguida, clique em Adicionar usando Serviços como o Nome da Pasta.
Controle + Clique na pasta Serviços e escolha Novo Arquivo... no menu Adicionar .

SelecioneClasse VaziaGeral>, insira DeviceInstallationService.cs para o Nome e clique em Novo adicionando a implementação a seguir.

using System;
using Android.App;
using Android.Gms.Common;
using PushDemo.Models;
using PushDemo.Services;
using static Android.Provider.Settings;

namespace PushDemo.Droid.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        public string Token { get; set; }

        public bool NotificationsSupported
            => GoogleApiAvailability.Instance
                .IsGooglePlayServicesAvailable(Application.Context) == ConnectionResult.Success;

        public string GetDeviceId()
            => Secure.GetString(Application.Context.ContentResolver, Secure.AndroidId);

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetPlayServicesError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for FCM");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "fcm",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetPlayServicesError()
        {
            int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Application.Context);

            if (resultCode != ConnectionResult.Success)
                return GoogleApiAvailability.Instance.IsUserResolvableError(resultCode) ?
                           GoogleApiAvailability.Instance.GetErrorString(resultCode) :
                           "This device is not supported";

            return "An error occurred preventing the use of push notifications";
        }
    }
}

Observação

Essa classe fornece uma ID exclusiva (usando Secure.AndroidId) como parte do conteúdo de registro do hub de notificação.

Adicione outra Classe Vazia à pasta Serviços chamada PushNotificationFirebaseMessagingService.cs e adicione a implementação a seguir.

using Android.App;
using Android.Content;
using Firebase.Messaging;
using PushDemo.Services;

namespace PushDemo.Droid.Services
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
    public class PushNotificationFirebaseMessagingService : FirebaseMessagingService
    {
        IPushDemoNotificationActionService _notificationActionService;
        INotificationRegistrationService _notificationRegistrationService;
        IDeviceInstallationService _deviceInstallationService;

        IPushDemoNotificationActionService NotificationActionService
            => _notificationActionService ??
                (_notificationActionService =
                ServiceContainer.Resolve<IPushDemoNotificationActionService>());

        INotificationRegistrationService NotificationRegistrationService
            => _notificationRegistrationService ??
                (_notificationRegistrationService =
                ServiceContainer.Resolve<INotificationRegistrationService>());

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService =
                ServiceContainer.Resolve<IDeviceInstallationService>());

        public override void OnNewToken(string token)
        {
            DeviceInstallationService.Token = token;

            NotificationRegistrationService.RefreshRegistrationAsync()
                .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; });
        }

        public override void OnMessageReceived(RemoteMessage message)
        {
            if(message.Data.TryGetValue("action", out var messageAction))
                NotificationActionService.TriggerAction(messageAction);
        }
    }
}

Em MainActivity.cs, verifique se os namespaces a seguir foram adicionados à parte superior do arquivo.

using System;
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using Android.Runtime;
using Firebase.Iid;
using PushDemo.Droid.Services;
using PushDemo.Services;

Em MainActivity.cs, defina LaunchMode como SingleTop para que MainActivity não seja criado novamente quando aberto.

[Activity(
    Label = "PushDemo",
    LaunchMode = LaunchMode.SingleTop,
    Icon = "@mipmap/icon",
    Theme = "@style/MainTheme",
    MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]

Adicione propriedades privadas e campos de backup correspondentes para armazenar uma referência às implementações IPushNotificationActionService e IDeviceInstallationService .

IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Implemente a interface IOnSuccessListener para recuperar e armazenar o token do Firebase .

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity, Android.Gms.Tasks.IOnSuccessListener
{
    ...

    public void OnSuccess(Java.Lang.Object result)
        => DeviceInstallationService.Token =
            result.Class.GetMethod("getToken").Invoke(result).ToString();
}

Adicione um novo método chamado ProcessNotificationActions que marcar se uma determinada Intenção tem um valor extra chamado action. Dispare condicionalmente essa ação usando a implementação IPushDemoNotificationActionService .

void ProcessNotificationActions(Intent intent)
{
    try
    {
        if (intent?.HasExtra("action") == true)
        {
            var action = intent.GetStringExtra("action");

            if (!string.IsNullOrEmpty(action))
                NotificationActionService.TriggerAction(action);
        }
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.Message);
    }
}

Substitua o método OnNewIntent para chamar o método ProcessNotificationActions .
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
Observação

Como o LaunchMode para a Atividade está definido como SingleTop, uma Intenção será enviada para a instância de Atividade existente por meio do método OnNewIntent em vez do método OnCreate e, portanto, você deve manipular uma intenção de entrada nos métodos OnCreate e OnNewIntent .
Atualize o método OnCreate para chamar Bootstrap.Begin logo após a chamada para base.OnCreate passar a implementação específica da plataforma de IDeviceInstallationService.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

No mesmo método, chame condicionalmente GetInstanceId na instância do FirebaseApp , logo após a chamada para Bootstrap.Begin, adicionando MainActivity como iOnSuccessListener.

if (DeviceInstallationService.NotificationsSupported)
{
    FirebaseInstanceId.GetInstance(Firebase.FirebaseApp.Instance)
        .GetInstanceId()
        .AddOnSuccessListener(this);
}

Ainda em OnCreate, chame ProcessNotificationActions imediatamente após a chamada para LoadApplication passar a Intenção atual.
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

Observação

Você deve registrar novamente o aplicativo sempre que executá-lo e interrompê-lo de uma sessão de depuração para continuar recebendo notificações por push.

Configurar o projeto nativo do iOS para notificações por push

Configurar Info.plist e Entitlements.plist

Verifique se você entrou em sua conta de desenvolvedor da Apple nasPreferências do Visual Studio>...>Publicação>As Contas de Desenvolvedor da Apple e o Perfil de Provisionamento e Certificado apropriado foram baixados. Você deve ter criado esses ativos como parte das etapas anteriores.
No PushDemo.iOS, abra Info.plist e verifique se o BundleIdentifier corresponde ao valor que foi usado para o respectivo perfil de provisionamento no Portal do Desenvolvedor da Apple. O BundleIdentifier estava no formato com.<organization>.PushDemo.
No mesmo arquivo, defina Versão mínima do sistema como 13.0.

Observação

Somente os dispositivos que executam o iOS 13.0 e superior têm suporte para os fins deste tutorial, no entanto, você pode estendê-lo para dar suporte a dispositivos que executam versões mais antigas.
Abra as Opções de Projeto para PushDemo.iOS (clique duas vezes no projeto).
Em Opções do Projeto, em Compilar > Assinatura de Pacote do iOS, verifique se sua conta de Desenvolvedor está selecionada em Equipe. Em seguida, verifique se "Gerenciar a assinatura automaticamente" está selecionado e se o Certificado de Autenticação e o Perfil de Provisionamento são selecionados automaticamente.

Observação

Se o Certificado de Autenticação e o Perfil de Provisionamento não tiverem sido selecionados automaticamente, escolha Provisionamento Manual e clique em Opções de Assinatura de Pacote. Verifique se sua Equipe está selecionada para Identidade de Assinatura e se o perfil de provisionamento específico do PushDemo está selecionado para Perfil de Provisionamento para configurações de Depuração e Versão , garantindo que o iPhone esteja selecionado para a Plataforma em ambos os casos.
No PushDemo.iOS, abra Entitlements.plist e verifique se Habilitar Notificações por Push é verificado quando exibido na guia Direitos . Em seguida, verifique se a configuração Ambiente do APS está definida como desenvolvimento quando exibida na guia Origem .

Manipular notificações por push para iOS

Controle + Clique no projeto PushDemo.iOS , escolha Nova Pasta no menu Adicionar e, em seguida, clique em Adicionar usando Serviços como o Nome da Pasta.
Controle + Clique na pasta Serviços e escolha Novo Arquivo... no menu Adicionar .

SelecioneClasse VaziaGeral>, insira DeviceInstallationService.cs para o Nome e clique em Novo adicionando a implementação a seguir.

using System;
using PushDemo.Models;
using PushDemo.Services;
using UIKit;

namespace PushDemo.iOS.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        const int SupportedVersionMajor = 13;
        const int SupportedVersionMinor = 0;

        public string Token { get; set; }

        public bool NotificationsSupported
            => UIDevice.CurrentDevice.CheckSystemVersion(SupportedVersionMajor, SupportedVersionMinor);

        public string GetDeviceId()
            => UIDevice.CurrentDevice.IdentifierForVendor.ToString();

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetNotificationsSupportError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for APNS");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "apns",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetNotificationsSupportError()
        {
            if (!NotificationsSupported)
                return $"This app only supports notifications on iOS {SupportedVersionMajor}.{SupportedVersionMinor} and above. You are running {UIDevice.CurrentDevice.SystemVersion}.";

            if (Token == null)
                return $"This app can support notifications but you must enable this in your settings.";


            return "An error occurred preventing the use of push notifications";
        }
    }
}

Observação

Essa classe fornece uma ID exclusiva (usando o valor UIDevice.IdentifierForVendor ) e o conteúdo de registro do hub de notificação.

Adicione uma nova pasta ao projeto PushDemo.iOS chamada Extensões e adicione uma Classe Vazia a essa pasta chamada NSDataExtensions.cs com a implementação a seguir.

using System.Text;
using Foundation;

namespace PushDemo.iOS.Extensions
{
    internal static class NSDataExtensions
    {
        internal static string ToHexString(this NSData data)
        {
            var bytes = data.ToArray();

            if (bytes == null)
                return null;

            StringBuilder sb = new StringBuilder(bytes.Length * 2);

            foreach (byte b in bytes)
                sb.AppendFormat("{0:x2}", b);

            return sb.ToString().ToUpperInvariant();
        }
    }
}

Em AppDelegate.cs, verifique se os namespaces a seguir foram adicionados à parte superior do arquivo.

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Foundation;
using PushDemo.iOS.Extensions;
using PushDemo.iOS.Services;
using PushDemo.Services;
using UIKit;
using UserNotifications;
using Xamarin.Essentials;

Adicione propriedades privadas e seus respectivos campos de suporte para armazenar uma referência às implementações IPushDemoNotificationActionService, INotificationRegistrationService e IDeviceInstallationService .

IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

INotificationRegistrationService NotificationRegistrationService
    => _notificationRegistrationService ??
        (_notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Adicione o método RegisterForRemoteNotifications para registrar as configurações de notificação do usuário e, em seguida, para notificações remotas com APNS.

void RegisterForRemoteNotifications()
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        var pushSettings = UIUserNotificationSettings.GetSettingsForTypes(
            UIUserNotificationType.Alert |
            UIUserNotificationType.Badge |
            UIUserNotificationType.Sound,
            new NSSet());

        UIApplication.SharedApplication.RegisterUserNotificationSettings(pushSettings);
        UIApplication.SharedApplication.RegisterForRemoteNotifications();
    });
}

Adicione o método CompleteRegistrationAsync para definir o valor da IDeviceInstallationService.Token propriedade. Atualize o registro e armazene em cache o token do dispositivo se ele tiver sido atualizado desde que foi armazenado pela última vez.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

Adicione o método ProcessNotificationActions para processar os dados de notificação do NSDictionary e chamar condicionalmente NotificationActionService.TriggerAction.

void ProcessNotificationActions(NSDictionary userInfo)
{
    if (userInfo == null)
        return;

    try
    {
        var actionValue = userInfo.ObjectForKey(new NSString("action")) as NSString;

        if (!string.IsNullOrWhiteSpace(actionValue?.Description))
            NotificationActionService.TriggerAction(actionValue.Description);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.Message);
    }
}

Substitua o método RegisteredForRemoteNotifications passando o argumento deviceToken para o método CompleteRegistrationAsync .

public override void RegisteredForRemoteNotifications(
    UIApplication application,
    NSData deviceToken)
    => CompleteRegistrationAsync(deviceToken).ContinueWith((task)
        => { if (task.IsFaulted) throw task.Exception; });

Substitua o método ReceivedRemoteNotification passando o argumento userInfo para o método ProcessNotificationActions .

public override void ReceivedRemoteNotification(
    UIApplication application,
    NSDictionary userInfo)
    => ProcessNotificationActions(userInfo);

Substitua o método FailedToRegisterForRemoteNotifications para registrar o erro em log.
```
public override void FailedToRegisterForRemoteNotifications(
    UIApplication application,
    NSError error)
    => Debug.WriteLine(error.Description);
```
Observação

Este é um espaço reservado. Você desejará implementar o registro em log e o tratamento de erros adequados para cenários de produção.
Atualize o método FinishedLaunching para chamar Bootstrap.Begin logo após a chamada para Forms.Init passar a implementação específica da plataforma de IDeviceInstallationService.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

No mesmo método, solicite condicionalmente a autorização e registre-se para notificações remotas imediatamente após Bootstrap.Begin.

if (DeviceInstallationService.NotificationsSupported)
{
    UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (approvalGranted, error) =>
            {
                if (approvalGranted && error == null)
                    RegisterForRemoteNotifications();
            });
}

Ainda em FinishedLaunching, chame ProcessNotificationActions imediatamente após a chamada para LoadApplication se o argumento options contiver o UIApplication.LaunchOptionsRemoteNotificationKey passando o objeto userInfo resultante.
```
using (var userInfo = options?.ObjectForKey(
    UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
        ProcessNotificationActions(userInfo);
```

Testar a solução

Agora você pode testar o envio de notificações por meio do serviço de back-end.

Enviar uma notificação de teste

Abra uma nova guia no Postman.

Defina a solicitação como POST e insira o seguinte endereço:

https://<app_name>.azurewebsites.net/api/notifications/requests

Se você optar por concluir a seção Autenticar clientes usando uma Chave de API , configure os cabeçalhos de solicitação para incluir o valor de apikey .

Chave Valor

apikey <your_api_key>
Escolha a opção bruta para o Corpo, escolha JSON na lista de opções de formato e, em seguida, inclua algum conteúdo JSON de espaço reservado:
```
{
    "text": "Message from Postman!",
    "action": "action_a"
}
```
Selecione o botão Código , que fica no botão Salvar no canto superior direito da janela. A solicitação deve ser semelhante ao exemplo a seguir quando exibida para HTML (dependendo se você incluiu um cabeçalho apikey ):
```
POST /api/notifications/requests HTTP/1.1
Host: https://<app_name>.azurewebsites.net
apikey: <your_api_key>
Content-Type: application/json

{
    "text": "Message from backend service",
    "action": "action_a"
}
```
Execute o aplicativo PushDemo em uma ou ambas as plataformas de destino (Android e iOS).

Observação

Se você estiver testando no Android , verifique se não está em execução na Depuração ou se o aplicativo foi implantado executando o aplicativo, force o fechamento do aplicativo e inicie-o novamente no inicializador.
No aplicativo PushDemo , toque no botão Registrar .
De volta ao Postman, feche a janela Gerar Snippets de Código (se você ainda não fez isso) e clique no botão Enviar .
Valide se você obtém uma resposta 200 OK no Postman e o alerta aparece no aplicativo mostrando a ação ActionA recebida.
Feche o aplicativo PushDemo e clique no botão Enviar novamente no Postman.
Valide se você obtém uma resposta 200 OK no Postman novamente. Valide se uma notificação aparece na área de notificação do aplicativo PushDemo com a mensagem correta.
Toque na notificação para confirmar que ele abre o aplicativo e exibiu o alerta recebido da ação ActionA .
No Postman, modifique o corpo da solicitação anterior para enviar uma notificação silenciosa especificando action_b em vez de action_a para o valor da ação .
```
{
    "action": "action_b",
    "silent": true
}
```
Com o aplicativo ainda aberto, clique no botão Enviar no Postman.
Valide se você obtém uma resposta 200 OK no Postman e se o alerta aparece no aplicativo mostrando a ação ActionB recebida em vez da ação ActionA recebida.
Feche o aplicativo PushDemo e clique no botão Enviar novamente no Postman.
Valide se você obtém uma resposta 200 OK no Postman e se a notificação silenciosa não aparece na área de notificação.

Chave	Valor
apikey	<your_api_key>

Solução de problemas

Nenhuma resposta do serviço de back-end

Ao testar localmente, verifique se o serviço de back-end está em execução e se está usando a porta correta.

Se estiver testando no Aplicativo de API do Azure, marcar o serviço está em execução e foi implantado e foi iniciado sem erro.

Certifique-se de marcar você especificou o endereço base corretamente no Postman ou na configuração do aplicativo móvel ao testar por meio do cliente. O endereço base deve ser https://<api_name>.azurewebsites.net/ indicativamente ou https://localhost:5001/ ao testar localmente.

Não receber notificações no Android depois de iniciar ou interromper uma sessão de depuração

Verifique se você se registrou novamente depois de iniciar ou interromper uma sessão de depuração. O depurador fará com que um novo token firebase seja gerado. A instalação do hub de notificação também deve ser atualizada.

Recebendo um código 401 status do serviço de back-end

Valide se você está definindo o cabeçalho de solicitação apikey e esse valor corresponde ao que você configurou para o serviço de back-end.

Se você receber esse erro ao testar localmente, verifique se o valor da chave definido na configuração do cliente corresponde ao valor de configuração de usuário Authentication:ApiKey usado pela API.

Se você estiver testando com um Aplicativo de API, verifique se o valor da chave no arquivo de configuração do cliente corresponde à configuração de aplicativo Authentication:ApiKey que você está usando no Aplicativo de API.

Observação

Se você tiver criado ou alterado essa configuração depois de implantar o serviço de back-end, deverá reiniciar o serviço para que ele entre em vigor.

Se você optar por não concluir a seção Autenticar clientes usando uma chave de API , verifique se você não aplicou o atributo Authorize à classe NotificationsController .

Recebendo um código 404 status do serviço de back-end

Valide se o ponto de extremidade e o método de solicitação HTTP estão corretos. Por exemplo, os pontos de extremidade devem ser:

[PUT]https://<api_name>.azurewebsites.net/api/notifications/installations
[DELETE]https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
[POST]https://<api_name>.azurewebsites.net/api/notifications/requests

Ou ao testar localmente:

[PUT]https://localhost:5001/api/notifications/installations
[DELETE]https://localhost:5001/api/notifications/installations/<installation_id>
[POST]https://localhost:5001/api/notifications/requests

Ao especificar o endereço base no aplicativo cliente, verifique se ele termina com um /. O endereço base deve ser https://<api_name>.azurewebsites.net/ indicativamente ou https://localhost:5001/ ao testar localmente.

Não é possível registrar e uma mensagem de erro do hub de notificação é exibida

Verifique se o dispositivo de teste tem conectividade de rede. Em seguida, determine a resposta Http status código definindo um ponto de interrupção para inspecionar o valor da propriedade StatusCode no HttpResponse.

Examine as sugestões de solução de problemas anteriores, quando aplicável com base no código status.

Defina um ponto de interrupção nas linhas que retornam esses códigos de status específicos para a respectiva API. Em seguida, tente chamar o serviço de back-end ao depurar localmente.

Valide se o serviço de back-end está funcionando conforme o esperado por meio do Postman usando o conteúdo apropriado. Use a carga real criada pelo código do cliente para a plataforma em questão.

Examine as seções de configuração específicas da plataforma para garantir que nenhuma etapa tenha sido perdida. Verifique se os valores adequados estão sendo resolvidos para installation id variáveis e token para a plataforma apropriada.

Não é possível resolve uma ID para a mensagem de erro do dispositivo é exibida

Examine as seções de configuração específicas da plataforma para garantir que nenhuma etapa tenha sido perdida.

Próximas etapas

Agora você deve ter um aplicativo Xamarin.Forms básico conectado a um hub de notificação por meio de um serviço de back-end e pode enviar e receber notificações.

Provavelmente, você precisará adaptar o exemplo usado neste tutorial para se ajustar ao seu próprio cenário. A implementação de tratamento de erros, lógica de repetição e registro em log mais robustos também é recomendada.

O Visual Studio App Center pode ser rapidamente incorporado em aplicativos móveis que fornecem análise e diagnóstico para ajudar na solução de problemas.

Tutorial: Enviar notificações por push para aplicativos Xamarin.Forms usando hubs de notificação do Azure por meio de um serviço de back-end

Pré-requisitos

Configurar os Serviços de Notificação por Push e o Hub de Notificação do Azure

Criar um projeto do Firebase e habilitar o Firebase Cloud Messaging para Android

Registrar seu aplicativo iOS para notificações por push

Criando um certificado para Hubs de Notificação

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

OPTION 2: Criando um certificado p8 que pode ser usado para autenticação baseada em token

Criar um perfil de provisionamento para o aplicativo

Criar um Hub de Notificação

Configurar o Hub de Notificação com informações de APNS

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

OPTION 2: Usando a autenticação baseada em token

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

Criar um aplicativo de back-end da API Web ASP.NET Core

Criar um projeto Web

Autenticar clientes usando uma chave de API (opcional)

Adicionar dependências e configurar serviços

Criar a API de notificações

Criar o aplicativo de API

Publicar o serviço de back-end

Validando a API publicada

Criar um aplicativo Xamarin.Forms multiplataforma

Criar a solução Xamarin.Forms

Implementar os componentes multiplataforma

Implementar a interface do usuário multiplataforma

Configurar o projeto nativo do Android para notificações por push

Validar o nome e as permissões do pacote

Adicionar a base do Xamarin Google Play Services e os pacotes Xamarin.Firebase.Messaging

Adicionar o arquivo JSON do Google Services

Manipular notificações por push para Android

Configurar o projeto nativo do iOS para notificações por push

Configurar Info.plist e Entitlements.plist

Manipular notificações por push para iOS

Testar a solução

Enviar uma notificação de teste

Solução de problemas

Nenhuma resposta do serviço de back-end

Não receber notificações no Android depois de iniciar ou interromper uma sessão de depuração

Recebendo um código 401 status do serviço de back-end

Recebendo um código 404 status do serviço de back-end

Não é possível registrar e uma mensagem de erro do hub de notificação é exibida

Não é possível resolve uma ID para a mensagem de erro do dispositivo é exibida

Links relacionados

Próximas etapas

Recursos adicionais