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

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

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:

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:

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 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 AddUNUserNotificationCenter 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 CategoryIdentifierUNMutableNotificationContent 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.

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.

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:

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.

Links relacionados

• Referência do UserNotifications Framework
• UserNotificationsUI
• Guia de Programação de Notificações Locais e Remotas