Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
A estrutura de Notificações 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 no dispositivo do usuário.
A estrutura da interface de notificação do utilizador 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 para baixo a partir da parte superior da tela como um banner.
- Som e vibrações: podem ser associados a uma notificação.
- Sinalização do ícone da aplicação: onde o ícone da aplicação exibe um indicador mostrando que novo conteúdo está disponível, como o número de mensagens de e-mail 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 será rolada para baixo a partir 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 visualizar todas as notificações disponíveis que aguardam lá.
Um aplicativo é capaz de enviar dois tipos de notificações de usuário:
- Notificações locais: são enviadas por aplicações instaladas localmente no dispositivo dos utilizadores.
- 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 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 utilizador interage com uma notificação, a aplicação receberá um callback.
Alguns exemplos de notificações locais incluem:
- Alertas de calendário.
- Alertas de lembrete.
- Gatilhos sensíveis à localização.
Para obter mais informações, consulte a documentação de Notificações do 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 se comunica.
- O Apple Push Notification Service (APNs) é utilizado para efetuar a transmissão com melhor esforço de notificações remotas para o dispositivo do utilizador a partir dos servidores na nuvem do desenvolvedor.
- Quando o aplicativo receber a notificação remota, ela será exibida para o usuário.
- Quando o utilizador interage com a notificação, a aplicação receberá um retorno de chamada.
Alguns exemplos de notificações remotas incluem:
- Alertas de notícias.
- Atualizações desportivas.
- Mensagens instantâneas.
Há dois tipos de notificações remotas disponíveis para um aplicativo:
- Voltado para o usuário: estes são exibidos para o usuário no dispositivo.
- Atualizações silenciosas: fornecem um mecanismo para atualizar o conteúdo de um aplicativo em segundo plano. Quando uma atualização silenciosa é recebida, o aplicativo pode entrar em contato com os servidores remotos para extrair o conteúdo mais recente.
Para obter mais informações, consulte a documentação de Notificações do usuário da Apple.
UIApplication API
É possível usar UIApplication para registrar uma notificação no sistema e agendar como essa notificação deve ser acionada - seja por hora ou local (esta era a API original fornecida para notificações de usuários pela Apple).
No entanto, há vários problemas que um desenvolvedor pode encontrar ao trabalhar com a notificação existente, conforme fornecido pelo UIApplication:
- Existem vários callbacks necessários para notificações locais ou remotas que podem levar à duplicação de código.
- O aplicativo tem controle limitado da notificação depois que ela foi agendada com o sistema.
- Existem 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 mencionado acima.
A estrutura de Notificações 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 o envio de notificações mais avançadas 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 apresentações de notificações no aplicativo.
- Adiciona a capacidade de agendar e manipular notificações de dentro das extensões do aplicativo.
- Adiciona um novo ponto de extensão para as próprias notificações.
A estrutura de Notificações do Usuário fornece uma API de notificação unificada em várias das plataformas suportadas pela Apple, incluindo:
- iOS: Suporte completo para gerenciar e agendar notificações.
- tvOS: Adiciona a capacidade de emblemar ícones de aplicativos para notificações locais e remotas.
- Mac Catalyst: Suporte completo para gerenciar e agendar notificações.
- macOS: Suporte completo para gerenciar e agendar notificações.
Para obter mais informações, consulte a documentação da interface do usuário de Notificações do usuário e Notificações do usuário da Apple.
Preparação para a entrega da 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 permissão antes de enviá-los.
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.
- Colocando distintivo no ícone da aplicação.
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)
{
// 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 implementação DidFinishLaunching
.
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)
});
}
Observação
Os aplicativos macOS e Mac Catalyst devem ser assinados para que a caixa de diálogo de permissão apareça, mesmo ao criar localmente no modo de depuração.
Defina a propriedade EnableCodeSigning no arquivo de projeto para true
forçar a assinatura do aplicativo.
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);
});
Ativando notificações em segundo plano
Para que o aplicativo receba notificações em segundo plano, ele deve habilitar o modo de segundo plano de notificações remotas para o aplicativo.
Isso é feito adicionando uma remote-notifications
entrada à UIBackgroundModes
matriz no arquivo Info.plist do projeto, da seguinte 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 como ou development
production
. O não fornecimento dessas informações pode resultar na rejeição do aplicativo quando enviado para a App Store com uma notificação semelhante à seguinte:
Direito de notificação por push ausente - A sua aplicação inclui uma API para o serviço de notificações por push da Apple, mas a permissão
aps-environment
está ausente na assinatura da aplicação.
Para fornecer o direito exigido, faça o seguinte:
Abra o arquivo de projeto no editor de texto de sua escolha.
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>
Nota: se utilizar uma configuração diferente da
Release
utilizada para publicar na App Store, atualize as condições em conformidade.
Observação
O aps-environment
também pode ser definido no arquivo Entitlements.plist , que é historicamente como tem sido feito. A vantagem de usar o arquivo de projeto é que é mais fácil usar automaticamente o valor correto para o direito, development
ou production
, dependendo da configuração de compilação.
Aprovisionamento
O aps-environment
direito da seção anterior requer o uso de um perfil de provisionamento com a Push Notifications
capacidade:
Vá para a seção Identificadores do site do desenvolvedor da Apple :
Adicionar um novo identificador (Registar um novo identificador):
Selecione o tipo de 'App':
Insira o identificador do pacote e a descrição do novo identificador do aplicativo:
Habilite a
Push Notifications
funcionalidade:Clique no
Register
botão para salvar o novo identificador do aplicativo.
A próxima etapa é criar um perfil de provisionamento para o novo identificador de aplicativo:
Vá para a seção Perfis do site do desenvolvedor da Apple :
Adicione um novo perfil para iOS App Development:
Selecione o ID do aplicativo que acabamos de criar:
Selecione todos os certificados incluídos neste perfil de provisionamento (um novo certificado deve ser criado caso ainda não tenha sido criado).
Selecione todos os dispositivos incluídos neste perfil de provisionamento (o aplicativo só pode ser instalado nesses dispositivos).
Escolha um nome para o perfil de provisionamento e revise-o:
Gere e baixe o novo perfil de provisionamento.
Abra o arquivo de perfil de provisionamento baixado no Xcode (clicando duas vezes nele no Finder) para instalá-lo no sistema.
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>
Observação
Se o aplicativo tiver extensões de aplicativo que lidem com notificações, esse processo deverá ser repetido para cada projeto de extensão de aplicativo correspondente - cada um deles deve ter seu próprio identificador de aplicativo e perfil de provisionamento.
Registrando-se para receber notificações remotas
Se o aplicativo estiver enviando e recebendo notificações remotas, ele ainda precisará fazer o Registro de Token usando a API UIApplication existente. Esse registro requer que o dispositivo tenha uma conexão de rede ao vivo para acessar APNs, o que gerará o token necessário que será enviado para o 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 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 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 de Notificações do usuário da Apple.
Entrega da 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.
Fornecer conteúdo de notificação
Todas as notificações contêm um Título e uma Sublegenda que serão sempre 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 criado, o aplicativo precisa agendar quando a notificação será apresentada ao usuário definindo um gatilho. Existem 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 notificações locais sejam agendadas para uma data e hora específicas.
- Baseado em localização - Permite que 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 de qualquer beacon Bluetooth.
Quando uma notificação local estiver pronta, o aplicativo precisará chamar UNUserNotificationCenter.AddNotificationRequest 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.
Juntando todas as partes, uma notificação local de exemplo pode se parecer com:
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
}
});
}
Acionando 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 comando
- Outras soluções de terceiros.
Depois que o aplicativo é lançado, as notificações remotas geralmente são acionadas a partir de aplicativos do lado do servidor.
Tratamento de notificações de aplicativos em primeiro plano
Um aplicativo pode lidar com notificações de forma diferente quando está em primeiro plano e uma notificação é acionada. Ao fornecer um UNUserNotificationCenterDelegate e implementar o método WillPresentNotification , o aplicativo pode assumir a responsabilidade pela exibição da 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
}
Este código está simplesmente a escrever o conteúdo da UNNotification para a saída da aplicação e a solicitar ao sistema que exiba 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 Nenhum 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;
}
Este código está a anexar o UNUserNotificationCenterDelegate personalizado de cima ao UNUserNotificationCenter atual para que a aplicação possa gerir notificações enquanto está ativa e em primeiro plano.
Gestão de notificações
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 através do 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.
Remoção de 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);
Atualizar 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 da 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 o topo da lista nas telas Início e Bloqueio e na Central de Notificações, se já tiver sido lida pelo usuário.
Trabalhando com ações de notificação
As notificações que são 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 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 - fornecem uma maneira rápida para o usuário executar uma tarefa personalizada diretamente da notificação, sem a necessidade de 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).
- Rejeitar ação - Esta ação é enviada para o aplicativo quando o usuário descarta uma determinada notificação.
Criar 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 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 estar associada a uma categoria. Ao criar um novo UNNotificationCategory, é atribuído um identificador exclusivo, uma lista de ações que 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.
Finalmente, todas as categorias são registradas no sistema usando o método SetNotificationCategories .
Apresentação de ações personalizadas
Uma vez que um conjunto de ações e categorias personalizadas tenham sido criadas e registradas no sistema, elas podem ser apresentadas a partir de notificações locais ou remotas.
Para notificações remotas, 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 propriedade CategoryIdentifier
do objeto UNMutableNotificationContent
. 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 criadas acima.
Tratamento de ações de rejeição
Como dito acima, uma ação de descarte pode ser enviada para o aplicativo quando o usuário descarta uma notificação. Como esta 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);
Gerindo respostas de ação
Quando o usuário interage com as ações e categorias personalizadas que foram criadas acima, o aplicativo precisa cumprir a 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 UNNotificationResponse
passada contém uma propriedade ActionIdentifier
que pode ser a ação padrão ou a ação de descartar. 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 propriedade Notification
contém a notificação original que inclui a solicitação com o conteúdo relacionado ao 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 do Serviço de Notificação
Ao trabalhar com notificações remotas, uma Extensão de Serviço de Notificação fornece uma maneira de habilitar a criptografia de ponta a ponta dentro da carga útil de notificação. Uma extensão do Serviço de Notificação é uma extensão que não é da Interface do Usuário 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 do Serviço de Notificaçã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 do Serviço de Notificação não consiga concluir sua tarefa no período de tempo atribuído, 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 das extensões do Serviço de Notificação incluem:
- Fornecendo criptografia de ponta a ponta do conteúdo da notificação remota.
- Adicionar 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:
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 tenha o nome
MyNotificationServiceExtension
.Abra um terminal e execute:
dotnet new ios-notification-service-extension
Abra o arquivo de projeto principal do projeto e adicione:
<ItemGroup> <ProjectReference Include="..\MyNotificationServiceExtension\MyNotificationServiceExtension.csproj"> <IsAppExtension>true</IsAppExtension> </ProjectReference> </ItemGroup>
Agora construa o projeto principal, e o projeto de extensão também será construído e incluído no pacote final do aplicativo.
Importante
Devido a alterações na forma como a interação entre um Mac e quaisquer dispositivos conectados é tratada pelo Mac, atualmente não é possível depurar uma extensão de aplicativo com um depurador. Consulte também https://github.com/xamarin/xamarin-macios/issues/19484 para obter mais informações sobre a data de up-to.
Isso significa que a maneira mais confiável de depurar uma extensão de aplicativo é, infelizmente, adicionar instruções Console.WriteLine ao código e, em seguida, procurar essas instruções no log do dispositivo.
Importante
O identificador de pacote (ApplicationId) para a extensão de serviço deve ser prefixado com o identificador de pacote do aplicativo principal. Por exemplo, se a aplicação principal tiver um Identificador de Pacote de com.xamarin.monkeynotify
, a extensão de serviço deverá ter um Identificador de Pacote de com.xamarin.monkeynotify.monkeynotifyserviceextension
.
Há uma classe principal na extensão do 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 através do request
objeto. O parâmetro passado contentHandler
precisará ser chamado para apresentar a notificação ao utilizador.
O segundo método, TimeWillExpire, será chamado pouco antes do tempo se esgotar para a extensão do Serviço de Notificação processar a solicitação. Se a extensão do Serviço de Notificação não conseguir chamar o contentHandler
no período de tempo atribuído, o conteúdo original será exibido para o usuário.
Acionando 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 acionada modificando a carga de notificação remota enviada para o 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 da notificação remota. 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 no seguinte exemplo de extensão do Serviço de Notificaçã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
}
}
}
Este código descriptografa o conteúdo criptografado da encrypted-content
chave, cria um novo UNMutableNotificationContent, atribui o conteúdo descriptografado à propriedade Body e utiliza o contentHandler
para apresentar a notificação ao utilizador.