Notificações do usuário

A estrutura de Notificações do Usuário permite a entrega e o tratamento de notificações locais e remotas. Usando essa estrutura, uma extensão de aplicativo ou aplicativo pode agendar a entrega de notificações locais especificando um conjunto de condições, como local ou hora do dia.

Além disso, o aplicativo ou a extensão pode receber (e potencialmente modificar) notificações locais e remotas à medida que são entregues ao dispositivo do usuário.

A estrutura de interface do usuário para notificações permite que um aplicativo ou extensão de aplicativo personalize a aparência de notificações locais e remotas quando elas são apresentadas ao usuário.

Essa estrutura fornece as seguintes maneiras pelas quais um aplicativo pode fornecer notificações a um usuário:

• Alertas visuais: em que a notificação rola para baixo da parte superior da tela como uma faixa.
• Som e vibrações: podem ser associados a uma notificação.
• Exibição de insígnia no ícone do aplicativo: onde o ícone do aplicativo exibe uma insígnia indicando que há novo conteúdo disponível, como o número de mensagens de email não lidas.

Além disso, dependendo do contexto atual do usuário, há diferentes maneiras de apresentar uma notificação:

• Se o dispositivo estiver desbloqueado, a notificação descerá da parte superior da tela como uma faixa.
• Se o dispositivo estiver bloqueado, a notificação será exibida na tela de bloqueio do usuário.
• Se o usuário tiver perdido uma notificação, ele poderá abrir a Central de Notificações e verificar as notificações disponíveis lá.

Um aplicativo pode enviar dois tipos de notificações do usuário:

• Notificações locais: elas são enviadas por aplicativos instalados localmente no dispositivo de usuários.
• Notificações remotas: são enviadas de um servidor remoto e apresentadas ao usuário ou disparam uma atualização em segundo plano do conteúdo do aplicativo.

Sobre notificações locais

As notificações locais que um aplicativo pode enviar têm os seguintes recursos e atributos:

• Eles são enviados por aplicativos locais no dispositivo do usuário.
• Eles podem ser configurados para usar gatilhos baseados em hora ou local.
• O aplicativo agenda a notificação com o dispositivo do usuário e é exibida quando a condição de gatilho é atendida.
• Quando o usuário interagir com uma notificação, o aplicativo receberá um retorno de chamada.

Alguns exemplos de notificações locais incluem:

• Alertas de calendário.
• Alertas de lembrete.
• Gatilhos baseados em localização.

Para obter mais informações, consulte a documentação de Notificações de Usuário da Apple.

Sobre notificações remotas

As notificações remotas que um aplicativo pode enviar têm os seguintes recursos e atributos:

• O aplicativo tem um componente do lado do servidor com o qual ele se comunica.
• O Serviço de Notificação por Push da Apple (APNs) é usado para transmitir notificações remotas com o melhor esforço possível do servidor em nuvem do desenvolvedor para o dispositivo do usuário.
• Quando o aplicativo receber a notificação remota, ele será exibido para o usuário.
• Quando o usuário interagir com a notificação, o aplicativo receberá um callback.

Alguns exemplos de notificações remotas incluem:

• Alertas de notícias.
• Atualizações esportivas.
• Mensagens instantâneas

Há dois tipos de notificações remotas disponíveis para um aplicativo:

• Voltados para o usuário: eles são exibidos para o usuário no dispositivo.
• Atualizações silenciosas: elas fornecem um mecanismo para atualizar o conteúdo de um aplicativo em segundo plano. Quando uma atualização silenciosa é recebida, o aplicativo pode acessar os servidores remotos para baixar o conteúdo mais recente.

Para obter mais informações, consulte a documentação de Notificações de Usuário da Apple.

UIApplication API

É possível usar uiApplication para registrar uma notificação com o sistema e agendar como essa notificação deve ser disparada - por hora ou local (esta era a API original fornecida para notificações do usuário pela Apple).

No entanto, há vários problemas que um desenvolvedor pode encontrar ao trabalhar com a notificação existente, conforme fornecido pela UIApplication:

• Existem diferentes callbacks necessários para notificações locais ou remotas, o que pode levar à duplicação de código.
• O aplicativo tem controle limitado sobre a notificação após ela ter sido agendada com o sistema.
• Há diferentes níveis de suporte em todas as plataformas existentes da Apple.

Sobre a estrutura de Notificações do Usuário

Para melhorar a experiência com notificações, a Apple introduziu a estrutura de Notificações do Usuário, que substitui o método UIApplication existente observado acima.

A estrutura de Notificações do Usuário fornece o seguinte:

• Uma API familiar que inclui a paridade de recursos com os métodos anteriores, facilitando a portabilidade de código da estrutura existente.
• Inclui um conjunto expandido de opções de conteúdo que permite que notificações mais avançadas sejam enviadas ao usuário.
• As notificações locais e remotas podem ser tratadas pelo mesmo código e callbacks.
• Simplifica o processo de manipulação de callbacks enviados a um aplicativo quando o usuário interage com uma notificação.
• Gerenciamento aprimorado de notificações pendentes e entregues, incluindo a capacidade de remover ou atualizar notificações.
• Adiciona a capacidade de exibir notificações dentro do aplicativo.
• Adiciona a capacidade de agendar e manipular notificações de dentro de extensões de aplicativo.
• Adiciona um novo ponto de extensão para notificações em si.

A estrutura de Notificações de Usuário fornece uma API de notificação unificada em várias das plataformas compatíveis com a Apple, incluindo:

• iOS: suporte total para gerenciar e agendar notificações.
• tvOS: adiciona a capacidade de mostrar selos nos ícones de aplicativos para notificações locais e remotas.
• Mac Catalyst: suporte total para gerenciar e agendar notificações.
• macOS: suporte total para gerenciar e agendar notificações.

Para obter mais informações, consulte a documentação da Apple sobre Notificações de Usuário e Interface de Notificações de Usuário.

Preparando-se para entrega de notificação

Antes que um aplicativo possa enviar notificações ao usuário, o aplicativo deve ser registrado no sistema e, como uma notificação é uma interrupção para o usuário, um aplicativo deve solicitar explicitamente a permissão antes de enviá-las.

Há três níveis diferentes de solicitações de notificação que o usuário pode aprovar para um aplicativo:

• O banner é exibido.
• Alertas de som.
• Adicionando distintivo ao ícone do aplicativo.

Além disso, esses níveis de aprovação devem ser solicitados e definidos para notificações locais e remotas.

A permissão de notificação deve ser solicitada assim que o aplicativo for iniciado adicionando o seguinte código ao FinishedLaunching método e definindo o tipo de AppDelegate notificação desejado (UNAuthorizationOptions):

using UserNotifications;

public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert, (approved, error) => {
        // Handle approval (or disapproval)
    });

    return true;
}

No macOS, faça isso na DidFinishLaunching implementação:

using UserNotifications;

public override void DidFinishLaunching (NSNotification notification)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound, (approved, error) => {
        // Handle approval (or disapproval)
    });
}

Além disso, um usuário sempre pode alterar os privilégios de notificação de um aplicativo a qualquer momento usando o aplicativo Configurações no dispositivo. O aplicativo deve verificar os privilégios de notificação solicitados pelo usuário antes de apresentar uma notificação usando o seguinte código:

// Get current notification settings
UNUserNotificationCenter.Current.GetNotificationSettings ((settings) => {
    var alertsAllowed = (settings.AlertSetting == UNNotificationSetting.Enabled);
});

Habilitando notificações em segundo plano

Para que o aplicativo receba notificações em segundo plano, ele deve habilitar o modo em segundo plano de notificações remotas para o aplicativo.

Isso é feito adicionando uma remote-notifications entrada à UIBackgroundModes matriz no arquivo Info.plist do projeto, desta forma:

<key>UIBackgroundModes</key>
<array>
    <string>remote-notification</string>
</array>

Configurando o ambiente de notificações remotas

O desenvolvedor deve informar ao sistema operacional em qual ambiente a notificação por push está sendo executada, seja como development ou production. A falha ao fornecer essas informações pode fazer com que o aplicativo seja rejeitado quando enviado à App Store com uma notificação semelhante à seguinte:

Ausência de Atributo de Notificação por Push - Seu aplicativo inclui uma API para o serviço de Notificação por Push da Apple, mas o atributo aps-environment está ausente da signatura do aplicativo.

Para fornecer o direito necessário, faça o seguinte:

1. Abra o arquivo de projeto no editor de texto de sua escolha.

2. Insira dois CustomEntitlements itens, como este:

   <ItemGroup>
       <CustomEntitlements Include="aps-environment" Type="String" Value="development" Condition="'$(Configuration)' != 'Release'" />
       <CustomEntitlements Include="aps-environment" Type="String" Value="production" Condition="'$(Configuration)' == 'Release'" />
   </ItemGroup>
   

   Observação: se você usar uma configuração diferente da Release para publicar na App Store, atualize as condições adequadamente.

Provisionamento

O aps-environment direito da seção anterior requer o uso de um perfil de provisionamento com a Push Notifications funcionalidade:

1. Vá para a seção Identificadores do site Desenvolvedor Apple.

   

2. Adicionar um novo identificador (registrar um novo identificador):

   

3. Selecione o tipo 'App':

   

4. Insira o identificador de pacote e a descrição do novo identificador de aplicativo:

   

5. Habilite a Push Notifications funcionalidade:

   

6. Clique no identificador Register para salvar o novo identificador do aplicativo.

A próxima etapa é criar um perfil de provisionamento para o novo identificador de aplicativo:

1. Vá para a seção Perfis do site desenvolvedor da Apple :

   

2. Adicione um novo perfil para o Desenvolvimento de Aplicativos do iOS:

   

3. Selecione a ID do aplicativo que acabamos de criar:

   

4. Selecione todos os certificados incluídos neste perfil de provisionamento (um novo certificado deve ser criado se ainda não tiver sido criado nenhum):

   

5. Selecione todos os dispositivos incluídos neste perfil de provisionamento (o aplicativo só pode ser instalado nesses dispositivos).

   

6. Escolha um nome para o perfil de provisionamento e examine-o:

   

7. Gere e baixe o novo perfil de provisionamento.

   

8. Abra o arquivo de perfil de provisionamento baixado no Xcode (clicando duas vezes nele no Finder) para instalá-lo no sistema.

9. Configure o projeto para usar o perfil de provisionamento recém-criado definindo a CodesignProvision propriedade como o nome do perfil de provisionamento da etapa 6:

   <PropertyGroup>
       <CodesignProvision>User Notifications Profile</CodesignProvision>
   </PropertyGroup>
   

Registrando-se para notificações remotas

Se o aplicativo enviar e receber notificações remotas, ele ainda precisará fazer o Registro de Token usando a API UIApplication existente. Esse registro exige que o dispositivo tenha uma conexão de rede dinâmica para acessar APNs, o que gerará o token necessário que será enviado ao aplicativo. Em seguida, o aplicativo precisa encaminhar esse token para o aplicativo do servidor do desenvolvedor para registro de notificações remotas.

Use o seguinte código para inicializar o registro necessário:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

O token que é enviado para o aplicativo do lado do servidor do desenvolvedor precisará ser incluído como parte do conteúdo de notificação que é enviado do servidor para APNs ao enviar uma notificação remota:

O token atua como a chave que vincula a notificação e o aplicativo usado para abrir ou responder à notificação.

Para obter mais informações, consulte a documentação de Notificações de Usuário da Apple.

Entrega de notificação

Com o aplicativo totalmente registrado e as permissões necessárias solicitadas e concedidas pelo usuário, o aplicativo agora está pronto para enviar e receber notificações.

Fornecendo conteúdo de notificação

Todas as notificações contêm um Título e Um Subtítulo que sempre serão exibidos com o Corpo do conteúdo da notificação. Há também a capacidade de adicionar Anexos de Mídia ao conteúdo da notificação.

Para criar o conteúdo de uma notificação local, use o seguinte código:

var content = new UNMutableNotificationContent();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;

Para notificações remotas, o processo é semelhante:

{
    "aps":{
        "alert":{
            "title":"Notification Title",
            "subtitle":"Notification Subtitle",
            "body":"This is the message body of the notification."
        },
        "badge":1
    }
}

Agendamento quando uma notificação é enviada

Com o conteúdo da notificação criada, o aplicativo precisa agendar quando a notificação será apresentada ao usuário definindo um gatilho. Há quatro tipos de gatilho diferentes:

• Notificação por push – usada exclusivamente com notificações remotas e é acionada quando a APNs envia um pacote de notificação para o aplicativo em execução no dispositivo.
• Intervalo de tempo – permite que uma notificação local seja agendada a partir de um intervalo de tempo que comece agora e encerre um ponto futuro. Por exemplo:

  var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);
  

• Data do calendário – Permite que as notificações locais sejam agendadas para uma data e hora específicas.
• Baseado em localização – permite que as notificações locais sejam agendadas quando o dispositivo está entrando ou saindo de uma localização geográfica específica ou está em uma determinada proximidade com quaisquer sinalizadores Bluetooth.

Quando uma notificação local estiver pronta, o aplicativo precisará chamar UNUserNotificationCenter.AddNotificationRequest para agendar sua exibição para o usuário. Para notificações remotas, o aplicativo do lado do servidor envia um conteúdo de notificação para as APNs, que envia o pacote para o dispositivo do usuário.

Reunindo todas as partes, uma notificação local de exemplo pode ter a seguinte aparência:

using UserNotifications;

public void SendLocalNotification ()
{
    var content = new UNMutableNotificationContent ();
    content.Title = "Notification Title";
    content.Subtitle = "Notification Subtitle";
    content.Body = "This is the message body of the notification.";
    content.Badge = 1;

    var trigger =  UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);

    var requestId = "sampleRequest";
    var request = UNNotificationRequest.FromIdentifier (requestId, content, trigger);

    UNUserNotificationCenter.Current.AddNotificationRequest (request, (err) => {
        if (err is not null) {
            // Do something with error
        }
    });
}

Disparando uma notificação remota

Há várias maneiras de disparar uma notificação remota durante o desenvolvimento para teste:

• Console de Notificação por Push da Apple
• Ferramentas de linha de comandos
• Outras soluções de terceiros.

Depois que o aplicativo é liberado, as notificações remotas normalmente são disparadas de aplicativos do lado do servidor.

Manipulando notificações de aplicativo em primeiro plano

Um aplicativo pode lidar com notificações de forma diferente quando está em primeiro plano e uma notificação é disparada. Ao fornecer um UNUserNotificationCenterDelegate e implementar o método WillPresentNotification , o aplicativo pode assumir a responsabilidade de exibir a notificação. Por exemplo:

using System;
using UserNotifications;

public class UserNotificationCenterDelegate : UNUserNotificationCenterDelegate
{
    #region Constructors
    public UserNotificationCenterDelegate ()
    {
    }
    #endregion

    #region Override Methods
    public override void WillPresentNotification (UNUserNotificationCenter center, UNNotification notification, Action<UNNotificationPresentationOptions> completionHandler)
    {
        // Do something with the notification
        Console.WriteLine ("Active notification: {0}", notification);

        // Tell system to display the notification anyway or use
        // `None` to say we have handled the display locally.
        completionHandler (UNNotificationPresentationOptions.Alert);
    }
    #endregion
}

Esse código está simplesmente escrevendo o conteúdo da UNNotification para a Saída do Aplicativo e solicitando que o sistema exiba o alerta padrão para a notificação.

Se o aplicativo quisesse exibir a notificação em si quando estava em primeiro plano e não usar os padrões do sistema, passe None para o manipulador de conclusão. Exemplo:

completionHandler (UNNotificationPresentationOptions.None);

Com esse código em vigor, abra o AppDelegate.cs arquivo para edição e altere o FinishedLaunching método para ter a seguinte aparência:

public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert, (approved, err) => {
        // Handle approval
    });

    // Watch for notifications while the app is active
    UNUserNotificationCenter.Current.Delegate = new UserNotificationCenterDelegate ();

    return true;
}

Esse código está anexando o UNUserNotificationCenterDelegate personalizado acima ao UNUserNotificationCenter atual para que o aplicativo possa gerenciar notificações enquanto estiver ativo e em primeiro plano.

Gerenciamento de notificação

O gerenciamento de notificação fornece acesso a notificações pendentes e entregues e adiciona a capacidade de remover, atualizar ou promover essas notificações.

Uma parte importante do gerenciamento de notificação é o identificador de solicitação atribuído à notificação quando ela foi criada e agendada com o sistema. Para notificações remotas, isso é atribuído por meio do apps-collapse-id campo no cabeçalho de solicitação HTTP.

O identificador de solicitação é usado para selecionar a notificação na qual o aplicativo deseja executar o gerenciamento de notificação.

Removendo notificações

Para remover uma notificação pendente do sistema, use o seguinte código:

var requests = new string [] { "sampleRequest" };
UNUserNotificationCenter.Current.RemovePendingNotificationRequests (requests);

Para remover uma notificação já entregue, use o seguinte código:

var requests = new string [] { "sampleRequest" };
UNUserNotificationCenter.Current.RemoveDeliveredNotifications (requests);

Atualizando uma notificação existente

Para atualizar uma notificação existente, basta criar uma nova notificação com os parâmetros desejados modificados (como um novo tempo de gatilho) e adicioná-la ao sistema com o mesmo identificador de solicitação que a notificação que precisa ser modificada. Exemplo:

using UserNotifications;

// Rebuild notification
var content = new UNMutableNotificationContent ();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;

// New trigger time
var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (10, false);

// Id of notification to be updated
var requestId = "sampleRequest";
var request = UNNotificationRequest.FromIdentifier (requestId, content, trigger);

// Add to system to modify existing Notification
UNUserNotificationCenter.Current.AddNotificationRequest (request, (err) => {
    if (err != null) {
        // Do something with error...
    }
});

Para notificações já entregues, a notificação existente será atualizada e promovida para a parte superior da lista nas telas Página Inicial e Bloqueio e na Central de Notificação se já tiver sido lida pelo usuário.

Trabalhando com ações de notificação

As notificações entregues ao usuário não são estáticas e fornecem várias maneiras pelas quais o usuário pode interagir com ele (de ações internas a personalizadas).

Há três tipos de ações às quais um aplicativo pode responder:

• Ação padrão – é quando o usuário toca em uma notificação para abrir o aplicativo e exibir os detalhes da notificação fornecida.
• Ações personalizadas – elas fornecem uma maneira rápida de o usuário executar uma tarefa personalizada diretamente da notificação sem precisar iniciar o aplicativo. Eles podem ser apresentados como uma lista de botões com títulos personalizáveis ou um campo de entrada de texto que pode ser executado em segundo plano (em que o aplicativo recebe uma pequena quantidade de tempo para atender à solicitação) ou o primeiro plano (em que o aplicativo é iniciado em primeiro plano para atender à solicitação).
• Ação de ignorar – essa ação é enviada ao aplicativo quando o usuário ignora uma determinada notificação.

Criando ações personalizadas

Para criar e registrar uma ação personalizada com o sistema, use o seguinte código:

// Create action
var actionId = "reply";
var title = "Reply";
var action = UNNotificationAction.FromIdentifier (actionId, title, UNNotificationActionOptions.None);

// Create category
var categoryId = "message";
var actions = new UNNotificationAction [] { action };
var intentIds = new string [] { };
var categoryOptions = new UNNotificationCategoryOptions [] { };
var category = UNNotificationCategory.FromIdentifier (categoryId, actions, intentIds, UNNotificationCategoryOptions.None);
    
// Register category
var categories = new UNNotificationCategory [] { category };
UNUserNotificationCenter.Current.SetNotificationCategories (new NSSet<UNNotificationCategory>(categories)); 

Ao criar um novo UNNotificationAction, é atribuído um identificador exclusivo e o título que será exibido no botão. Por padrão, a ação será criada como uma ação em segundo plano, no entanto, as opções podem ser fornecidas para ajustar o comportamento da ação (por exemplo, defini-la como uma ação em primeiro plano).

Cada uma das ações criadas precisa ser associada a uma categoria. Ao criar um novo UNNotificationCategory, ele recebe um identificador exclusivo, uma lista de ações que ele pode executar, uma lista de identificadores de intenção para fornecer mais informações sobre a intenção das ações na categoria e algumas opções para controlar o comportamento da categoria.

Por fim, todas as categorias são registradas no sistema usando o método SetNotificationCategories .

Apresentando ações personalizadas

Depois que um conjunto de ações e categorias personalizadas tiver sido criado e registrado com o sistema, eles poderão ser apresentados a partir de notificações locais ou remotas.

Para notificações remotas, configure um category na carga útil de notificações remotas que corresponda a uma das categorias criadas acima. Por exemplo:

{
    aps: {
        alert:"Hello world!",
        category:"message"
    }
}

Para notificações locais, defina a CategoryIdentifier propriedade do UNMutableNotificationContent objeto. Por exemplo:

var content = new UNMutableNotificationContent ();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;
content.CategoryIdentifier = "message";

Novamente, esse identificador precisa corresponder a uma das categorias que foi criada acima.

Gerenciando ações de dispensa

Conforme indicado acima, uma ação de descarte pode ser enviada ao aplicativo quando o usuário descarta uma notificação. Como essa não é uma ação padrão, uma opção precisará ser definida quando a categoria for criada. Por exemplo:

var categoryId = "message";
var actions = new UNNotificationAction [] { action };
var intentIds = new string [] { };
var categoryOptions = new UNNotificationCategoryOptions [] { };
var category = UNNotificationCategory.FromIdentifier (categoryId, actions, intentIds, UNNotificationCategoryOptions.CustomDismissAction);

Gerenciando respostas de ação

Quando o usuário interage com as ações e categorias personalizadas que foram criadas acima, o aplicativo precisa atender à tarefa solicitada. Isso é feito fornecendo um [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] e implementando o método DidReceiveNotificationResponse . Por exemplo:

using System;
using UserNotifications;

namespace MonkeyNotification
{
    public class UserNotificationCenterDelegate : UNUserNotificationCenterDelegate
    {
        ...

        #region Override methods
        public override void DidReceiveNotificationResponse (UNUserNotificationCenter center, UNNotificationResponse response, Action completionHandler)
        {
            // Take action based on Action ID
            switch (response.ActionIdentifier) {
            case "reply":
                // Do something
                break;
            default:
                // Take action based on identifier
                if (response.IsDefaultAction) {
                    // Handle default action...
                } else if (response.IsDismissAction) {
                    // Handle dismiss action
                }
                break;
            }

            // Inform caller it has been handled
            completionHandler();
        }
        #endregion
    }
}

A classe passada UNNotificationResponse tem uma ActionIdentifier propriedade que pode ser a ação padrão ou a ação de descarte. Use response.Notification.Request.Identifier para testar as ações personalizadas.

A UserText propriedade contém o valor de qualquer entrada de texto do usuário. A Notification propriedade contém a notificação de origem que inclui a solicitação com o gatilho e o conteúdo da notificação. O aplicativo pode decidir se foi uma notificação local ou remota com base no tipo de gatilho.

Trabalhando com extensões do Serviço de Notificação

Ao trabalhar com notificações remotas, uma Extensão do Serviço de Notificação fornece uma maneira de habilitar a criptografia de ponta a ponta dentro do conteúdo da notificação. Uma extensão do Serviço de Notificação é uma extensão que não é de Interface do Usuário, que funciona em segundo plano com a principal finalidade de aumentar ou substituir o conteúdo visível de uma notificação antes de ser apresentada ao usuário.

As extensões do Serviço de Notificação devem ser executadas rapidamente e recebem apenas um curto período de tempo para serem executadas pelo sistema. Caso a extensão do serviço de notificação não conclua sua tarefa no tempo alocado, um método de fallback será chamado. Se o fallback falhar, o conteúdo da notificação original será exibido para o usuário.

Alguns usos potenciais de extensões do Serviço de Notificação incluem:

• Fornecendo criptografia de ponta a ponta do conteúdo de notificação remota.
• Adicionando anexos a notificações remotas para enriquecê-los.

Implementando uma extensão do Serviço de Notificação

Para implementar uma extensão do Serviço de Notificação em um aplicativo, faça o seguinte:

1. Crie uma nova pasta para o projeto de extensão, ao lado da pasta do projeto principal. As instruções a seguir pressupõem que a nova pasta seja nomeada MyNotificationServiceExtension.

2. Abra um terminal e execute:

   dotnet new ios-notification-service-extension
   

3. Abra o arquivo de projeto do projeto principal e adicione:

   <ItemGroup>
       <ProjectReference Include="..\MyNotificationServiceExtension\MyNotificationServiceExtension.csproj">
           <IsAppExtension>true</IsAppExtension>
       </ProjectReference>
   </ItemGroup>
   

4. Agora, crie o projeto principal e o projeto de extensão também será criado e incluído no pacote final do aplicativo.

Há uma classe principal na extensão serviço de notificação que precisará ser modificada para fornecer a funcionalidade necessária. Por exemplo:

using System;

using Foundation;
using UIKit;
using UserNotifications;

namespace MonkeyChatServiceExtension
{
    [Register ("NotificationService")]
    public class NotificationService : UNNotificationServiceExtension
    {
        protected NotificationServiceClass (NativeHandle handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic,
            // it only exists so that the OS can instantiate an instance of this class.
        }

        public override void DidReceiveNotificationRequest (UNNotificationRequest request, Action<UNNotificationContent> contentHandler)
        {
            // Called when the OS receives a notification that can be muteated

            // Create a mutable copy of the notification
            var mutableRequest = (UNMutableNotificationContent) request.Content.MutableCopy ();

            // Modify the notification content here...
            mutableRequest.Title = $"[modified] {mutableRequest.Title}";

            // Call the contentHandler callback to let the OS know about the modified notification.
            contentHandler (mutableRequest);
        }

        public override void TimeWillExpire ()
        {
            // Called just before the extension will be terminated by the system.
            // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        }
    }
}

O primeiro método, DidReceiveNotificationRequest, receberá o identificador de notificação, bem como o conteúdo da notificação, por meio do objeto request. O parâmetro contentHandler passado precisará ser chamado para apresentar a notificação ao usuário.

O segundo método, TimeWillExpire, será chamado antes que o tempo esteja prestes a se esgotar para que a extensão do Serviço de Notificação processe a solicitação. Se a extensão do Serviço de Notificação falhar em chamar o contentHandler no tempo alocado, o conteúdo original será exibido ao usuário.

Ativação de uma extensão do Serviço de Notificação

Com uma extensão do Serviço de Notificação criada e entregue com o aplicativo, ela pode ser disparada modificando a carga de notificação remota enviada ao dispositivo. Por exemplo:

{
    aps : {
        alert : "New Message Available",
        mutable-content: 1
    },
    encrypted-content : "#theencryptedcontent"
}

A nova mutable-content chave especifica que a extensão do serviço de notificação precisará ser iniciada para atualizar o conteúdo de notificação remoto. A encrypted-content chave contém os dados criptografados que a extensão do Serviço de Notificação pode descriptografar antes de apresentar ao usuário.

Dê uma olhada na seguinte extensão do Serviço de Notificação de exemplo:

using UserNotification;

namespace myApp {
    public class NotificationService : UNNotificationServiceExtension {
    
        public override void DidReceiveNotificationRequest(UNNotificationRequest request, contentHandler) {
            // Decrypt payload
            var decryptedBody = Decrypt(Request.Content.UserInfo["encrypted-content"]);
            
            // Modify notification body
            var newContent = new UNMutableNotificationContent();
            newContent.Body = decryptedBody;
            
            // Present to user
            contentHandler(newContent);
        }
        
        public override void TimeWillExpire() {
            // Handle out-of-time fallback event
        }
        
    }
}

Esse código descriptografa o conteúdo criptografado da encrypted-content chave, cria um novo UNMutableNotificationContent, define a propriedade Body como o conteúdo descriptografado e usa a contentHandler para apresentar a notificação ao usuário.

Consulte também

• exemplo do iOS
• Referência do Framework UserNotifications
• UserNotificationsUI
• Guia de programação de notificação local e remota
• Personalizando a aparência das notificações