Partilhar via

Notificações de usuário aprimoradas no Xamarin.iOS

  • Artigo

Novidade no iOS 10, a estrutura de Notificação do Usuário permite a entrega e o manuseio de notificações locais e remotas. Usando essa estrutura, um aplicativo ou Extensão de Aplicativo pode agendar a entrega de notificações locais especificando um conjunto de condições, como local ou hora do dia.

Sobre notificações do usuário

Como dito acima, a nova estrutura de Notificação do Usuário permite a entrega e o tratamento de notificações locais e remotas. Usando essa estrutura, um aplicativo ou Extensão de 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 extensão pode receber (e potencialmente modificar) notificações locais e remotas à medida que são entregues ao dispositivo iOS do usuário.

A nova estrutura da interface do usuário de Notificação do Usuário permite que um aplicativo ou Extensão de Aplicativo personalize a aparência das notificações locais e remotas quando elas são apresentadas ao usuário.

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

  • Alertas visuais - Onde a notificação rola da parte superior da tela como um banner.
  • Som e Vibrações - Pode ser associado a uma notificação.
  • Badging do ícone do aplicativo - Onde o ícone do aplicativo exibe um selo mostrando que o novo conteúdo está 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 rolará para baixo da parte superior da tela como um banner.
  • Se o dispositivo estiver bloqueado, a notificação será exibida na tela de bloqueio do usuário.
  • Se o usuário perdeu uma notificação, ele pode abrir a Central de Notificações e exibir todas as notificações disponíveis em espera.

Um aplicativo Xamarin.iOS tem dois tipos de Notificações do Usuário que ele pode enviar:

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

Sobre notificações locais

As Notificações Locais que um aplicativo iOS pode enviar têm os seguintes recursos e atributos:

  • Eles são enviados por aplicativos que são locais no dispositivo do usuário.
  • Eles podem ser configurados para usar gatilhos baseados em tempo ou local.
  • O aplicativo agenda a notificação com o dispositivo do usuário e ela é exibida quando a condição de gatilho é atendida.
  • Quando o usuário interage 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 com reconhecimento de localização

Para obter mais informações, consulte a documentação do Guia de Programação de Notificação Local e Remota da Apple.

Sobre notificações remotas

As Notificações Remotas que um aplicativo iOS pode enviar têm os seguintes recursos e atributos:

  • O aplicativo tem um componente do lado do servidor com o qual se comunica.
  • O Apple Push Notification Service (APNs) é usado para transmitir uma entrega de melhor esforço de notificações remotas para o dispositivo do usuário a partir dos servidores baseados em nuvem do desenvolvedor.
  • Quando o aplicativo receber a Notificação Remota, ela será exibida para o usuário.
  • Quando o usuário interage com a notificação, o aplicativo receberá um retorno de chamada.

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 iOS:

  • Voltados para o usuário - Eles são exibidos para o usuário no dispositivo.
  • Atualizações silenciosas - Fornecem um mecanismo para atualizar o conteúdo de um aplicativo iOS em segundo plano. Quando uma Atualização Silenciosa é recebida, o aplicativo pode entrar em contato com os servidores remotos para obter o conteúdo mais recente.

Para obter mais informações, consulte a documentação do Guia de Programação de Notificação Local e Remota da Apple.

Sobre a API de notificações existente

Antes do iOS 10, um aplicativo iOS usava UIApplication para registrar uma notificação no sistema e agendar como essa notificação deveria ser acionada (por hora ou local).

Há vários problemas que um desenvolvedor pode encontrar ao trabalhar com a API de notificação existente:

  • Havia diferentes retornos de chamada necessários para notificações locais ou remotas que poderiam levar à duplicação de código.
  • O aplicativo tinha controle limitado da notificação depois que ela era agendada com o sistema.
  • Havia diferentes níveis de suporte em todas as plataformas existentes da Apple.

Sobre a nova estrutura de notificação do usuário

Com o iOS 10, a Apple introduziu a nova estrutura de Notificação do Usuário, que substitui o método existente UIApplication mencionado acima.

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

  • Uma API familiar que inclui 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 ricas sejam enviadas ao usuário.
  • As notificações locais e remotas podem ser tratadas pelo mesmo código e retornos de chamada.
  • Simplifica o processo de manipulação de retornos de chamada que são enviados para 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 fazer a apresentação de notificações no aplicativo.
  • Adiciona a capacidade de agendar e lidar com notificações de dentro das Extensões de Aplicativo.
  • Adiciona novo ponto de extensão para as próprias notificações.

A nova estrutura de Notificação do Usuário fornece uma API de notificação unificada em várias das plataformas que a Apple suporta, incluindo:

  • iOS - Suporte completo para gerenciar e agendar notificações.
  • tvOS - Adiciona a capacidade de marcar ícones de aplicativos para notificações locais e remotas.
  • watchOS - Adiciona a capacidade de encaminhar notificações do dispositivo iOS emparelhado do usuário para o Apple Watch e dá aos aplicativos do relógio a capacidade de fazer notificações locais diretamente no próprio relógio.
  • macOS - Suporte completo para gerenciar e agendar notificações.

Para obter mais informações, consulte a Referência do UserNotifications Framework da Apple e a documentação UserNotificationsUI.

Preparando-se para a entrega de notificações

Antes que um aplicativo iOS 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 permissão explicitamente 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:

  • Exibição de banners.
  • Alertas sonoros.
  • Badging o í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 do e definindo o tipo de AppDelegate notificação desejado (UNAuthorizationOptions):

Observação

UNUserNotificationCenter só está disponível a partir do iOS 10+. Portanto, é uma prática recomendada verificar a versão do macOS antes de enviar a solicitação.

using UserNotifications;
...

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

    return true;
}

Como essa API é unificada e também funciona no Mac 10.14+, se você estiver usando o macOS, também deve verificar a permissão de notificação o mais rápido possível:

using UserNotifications;
...

public override void DidFinishLaunching (NSNotification notification)
{
    // Check we're at least v10.14
    if (NSProcessInfo.ProcessInfo.IsOperatingSystemAtLeastVersion (new NSOperatingSystemVersion (10, 14, 0))) {
        // Request notification permissions from the user
        UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound, (approved, err) => {
            // Handle approval
        });
    }
}

> [!NOTE]
> With MacOS apps, for the permission dialog to appear, you must sign your macOS app, even if building locally in DEBUG mode. Therefore, **Project->Options->Mac Signing->Sign the application bundle** must be checked.

Additionally, a user can always change the notification privileges for an app at any time using the **Settings** app on the device. The app should check for the user's requested notification privileges before presenting a notification using the following code:

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

Configurando o ambiente de notificações remotas

Novo no iOS 10, o desenvolvedor deve informar ao sistema operacional em qual ambiente a Notificação por Push está sendo executada como Desenvolvimento ou Produção. O não fornecimento dessas informações pode resultar na rejeição do aplicativo quando enviado à iTune App Store com uma notificação semelhante à seguinte:

Direito de notificação por push ausente - Seu aplicativo inclui uma API para o serviço de notificação por push da Apple, mas o aps-environment direito está ausente da assinatura do aplicativo.

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

  1. Clique duas vezes no Entitlements.plist arquivo no Solution Pad para abri-lo para edição.

  2. Alterne para a guia Código-fonte:

    O modo de exibição Código-fonte

  3. Clique no + botão para adicionar uma nova chave.

  4. Insira aps-environment para a propriedade, deixe o Tipo como String e insira um development ou production para o Valor:

    A propriedade aps-environment

  5. Salve as alterações no arquivo.

Registrando-se para notificações remotas

Se o aplicativo estiver enviando e recebendo Notificações Remotas, ele ainda precisará fazer o Registro de Token usando a API existente UIApplication . Esse registro exige que o dispositivo tenha uma conexão de rede em tempo real com APNs de acesso, que gerará o token necessário que será enviado ao aplicativo. O aplicativo precisa encaminhar esse token para o aplicativo do lado do servidor do desenvolvedor para se registrar para notificações remotas:

Visão geral do Registro de Token

Use o código a seguir 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 da Carga de Notificação que é enviada do servidor para APNs ao enviar uma Notificação Remota:

O token incluído como parte da Carga de Notificação

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

Para obter mais informações, consulte a documentação do Guia de Programação de Notificação Local e Remota 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

Novidade no iOS 10, todas as notificações contêm um Título e uma Legenda que sempre serão exibidos com o Corpo do conteúdo da notificação. Outra novidade é 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 criado, o aplicativo precisa agendar quando a notificação será apresentada ao usuário definindo um Gatilho. O iOS 10 fornece quatro tipos diferentes de gatilho:

  • Notificação por push - É usada exclusivamente com notificações remotas e é acionada quando os APNs enviam 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 começa agora e termina em algum 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 iOS está entrando ou saindo de uma localização geográfica específica ou está em uma determinada proximidade de qualquer Bluetooth Beacons.

Quando uma Notificação Local está pronta, o aplicativo precisa chamar o Add UNUserNotificationCenter método do objeto para agendar sua exibição para o usuário. Para Notificações Remotas, o aplicativo do lado do servidor envia uma Carga de Notificação para os APNs, que enviam o pacote para o dispositivo do usuário.

Reunindo todas as partes, uma Notificação Local de exemplo pode se parecer com:

using UserNotifications;
...

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 != null) {
        // Do something with error...
    }
});

Manipulando notificações de aplicativos em primeiro plano

Novo no iOS 10, um aplicativo pode lidar com Notificações de forma diferente quando está em primeiro plano e uma Notificação é acionada. Ao fornecer e UNUserNotificationCenterDelegate implementar o WillPresentNotification método, o aplicativo pode assumir a responsabilidade pela exibição da Notificação. Por exemplo:

using System;
using UserNotifications;

namespace MonkeyNotification
{
    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 do para a saída do UNNotification aplicativo e pedindo ao sistema para exibir o alerta padrão para a notificação.

Se o aplicativo quiser exibir a própria notificação quando ela estiver 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 no lugar, 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 personalizado UNUserNotificationCenterDelegate de cima ao atual UNUserNotificationCenter para que o aplicativo possa lidar com a notificação enquanto ele está ativo e em primeiro plano.

Gerenciamento de Notificações

Novo no iOS 10, o Gerenciamento de Notificações 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ções é o Identificador de Solicitação que foi atribuído à Notificação quando ela foi criada e agendada com o sistema. Para Notificações Remotas, isso é atribuído por meio do novo apps-collapse-id campo no cabeçalho da solicitação HTTP.

O Identificador de Solicitação é usado para selecionar a Notificação na qual o aplicativo deseja executar o Gerenciamento de Notificações.

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 disparo) 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 ao topo da lista nas telas Início e de Bloqueio e na Central de Notificações, se já tiver sido lida pelo usuário.

Trabalhando com ações de notificação

No iOS 10, as notificações entregues ao usuário não são estáticas e fornecem várias maneiras de o usuário interagir com elas (de ações internas a personalizadas).

Há três tipos de Ações às quais um aplicativo iOS 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 foram adicionadas no iOS 8 e fornecem uma maneira rápida para 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 (onde o aplicativo recebe uma pequena quantidade de tempo para atender à solicitação) ou em primeiro plano (onde o aplicativo é iniciado em primeiro plano para atender à solicitação). As Ações personalizadas estão disponíveis no iOS e no watchOS.
  • Ação de Dispensa - Esta Ação é enviada ao aplicativo quando o usuário descarta 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 ID exclusivo e o título que aparecerá no botão. Por padrão, a Ação será criada como uma Ação em Segundo Plano, no entanto, opções podem ser fornecidas para ajustar o comportamento da Ação (por exemplo, definindo-a como uma Ação em Primeiro Plano).

Cada uma das Ações criadas precisa ser associada a uma Categoria. Ao criar um novo UNNotificationCategory, é atribuído um ID exclusivo, uma lista de Ações que ele pode executar, uma lista de IDs 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.

Finalmente, todas as Categorias são registradas no sistema usando o SetNotificationCategories método.

Apresentando ações personalizadas

Depois que um conjunto de Ações e Categorias Personalizadas tiver sido criado e registrado no sistema, elas poderão ser apresentadas a partir de Notificações Locais ou Remotas.

Para Notificação Remota, defina um category na Carga de Notificação Remota que corresponda a uma das Categorias criadas acima. Por exemplo:

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

Para Notificações Locais, defina a CategoryIdentifier UNMutableNotificationContent propriedade do 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 ID precisa corresponder a uma das Categorias criadas acima.

Lidando com ações de improcedência

Como dito acima, uma Ação de Dispensa 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);

Manipulando respostas de ação

Quando o usuário interage com as Ações e Categorias Personalizadas criadas acima, o aplicativo precisa cumprir a tarefa solicitada. Isso é feito fornecendo um UNUserNotificationCenterDelegate e implementando o UserNotificationCenter método. 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 tem UNNotificationResponse uma ActionIdentifier propriedade que pode ser a Ação Padrão ou a Ação de Descarte. Use response.Notification.Request.Identifier para testar quaisquer 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 Conteúdo de Gatilho e Notificação. O aplicativo pode decidir se foi uma Notificação Local ou Remota com base no tipo de gatilho.

Observação

O iOS 12 possibilita que uma interface do usuário de notificação personalizada modifique seus botões de ação em tempo de execução. Para obter mais informações, consulte a documentação dos botões de ação de notificação dinâmica.

Trabalhando com extensões de serviço

Ao trabalhar com Notificações Remotas, as Extensões de Serviço fornecem uma maneira de habilitar a criptografia de ponta a ponta dentro da Carga de Notificação. As Extensões de Serviço são uma extensão que não é da Interface do Usuário (disponível no iOS 10) que é executada em segundo plano com o objetivo principal de aumentar ou substituir o conteúdo visível de uma Notificação antes que ela seja apresentada ao usuário.

Visão geral da extensão de serviço

As extensões de serviço destinam-se a ser executadas rapidamente e recebem apenas um curto período de tempo para serem executadas pelo sistema. Caso a Extensão de Serviço não consiga concluir sua tarefa no tempo alocado, um método de fallback será chamado. Se o fallback falhar, o Conteúdo de Notificação original será exibido ao usuário.

Alguns usos potenciais das extensões de serviço incluem:

  • Fornecendo criptografia de ponta a ponta do conteúdo da Notificação Remota.
  • Adicionar anexos às Notificações Remotas para enriquecê-los.

Implementando uma extensão de serviço

Para implementar uma extensão de serviço em um aplicativo Xamarin.iOS, faça o seguinte:

  1. Abra a solução do aplicativo no Visual Studio para Mac.

  2. Clique com o botão direito do mouse no Nome da Solução no Painel de Soluções e selecione Adicionar>Novo Projeto.

  3. Selecione Extensões> do iOS>Extensões de Serviço de Notificação e clique no botão Avançar:

    Selecionar extensões de serviço de notificação

  4. Digite um Nome para a extensão e clique no botão Avançar :

    Insira um Nome para a extensão

  5. Ajuste o Nome do Projeto e/ou Nome da Solução, se necessário, e clique no botão Criar:

    Ajustar o nome do projeto e/ou o nome da solução

Importante

O Identificador de Pacote para a extensão de serviço deve corresponder ao Identificador de Pacote do aplicativo principal com .appnameserviceextension anexado ao final. Por exemplo, se o aplicativo principal tiver um Identificador de Pacote de , a extensão de com.xamarin.monkeynotifyserviço deverá ter um Identificador de Pacote de com.xamarin.monkeynotify.monkeynotifyserviceextension. Isso deve ser definido automaticamente quando a extensão é adicionada à solução.

Há uma classe principal na extensão de 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
    {
        #region Computed Properties
        public Action<UNNotificationContent> ContentHandler { get; set; }
        public UNMutableNotificationContent BestAttemptContent { get; set; }
        #endregion

        #region Constructors
        protected NotificationService (IntPtr handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic.
        }
        #endregion

        #region Override Methods
        public override void DidReceiveNotificationRequest (UNNotificationRequest request, Action<UNNotificationContent> contentHandler)
        {
            ContentHandler = contentHandler;
            BestAttemptContent = (UNMutableNotificationContent)request.Content.MutableCopy ();

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

            ContentHandler (BestAttemptContent);
        }

        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.

            ContentHandler (BestAttemptContent);
        }
        #endregion
    }
}

O primeiro método, , será passado o Identificador de Notificação, DidReceiveNotificationRequestbem como o Conteúdo de Notificação através do request objeto. O passado contentHandler precisará ser chamado para apresentar a Notificação ao usuário.

O segundo método, TimeWillExpire, será chamado pouco antes do tempo se esgotar para que a Extensão de Serviço processe a solicitação. Se a Extensão de Serviço não conseguir chamar o contentHandler no tempo alocado, o conteúdo original será exibido ao usuário.

Acionando uma extensão de serviço

Com uma Extensão de Serviço criada e fornecida com o aplicativo, ela pode ser acionada 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 de Serviço precisará ser iniciada para atualizar o conteúdo da Notificação Remota. A encrypted-content chave contém os dados criptografados que a Extensão de Serviço pode descriptografar antes de apresentar ao usuário.

Dê uma olhada no seguinte exemplo de extensão de serviço:

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 Body propriedade para o conteúdo descriptografado e usa o contentHandler para apresentar a notificação ao usuário.

Resumo

Este artigo abordou todas as maneiras pelas quais a Notificação de Usuários foi aprimorada pelo iOS 10. Ele apresentou a nova estrutura de Notificação do Usuário e como usá-la em um aplicativo Xamarin.iOS ou Extensão de Aplicativo.