Notifications à l’utilisateur

L’infrastructure Notifications utilisateur permet la remise et la gestion des notifications locales et distantes. À l’aide de cette infrastructure, une application ou une extension d’application peut planifier la remise des notifications locales en spécifiant un ensemble de conditions telles que l’emplacement ou l’heure de la journée.

En outre, l’application ou l’extension peut recevoir (et éventuellement modifier) des notifications locales et distantes à mesure qu’elles sont remises à l’appareil de l’utilisateur.

L’infrastructure de l’interface utilisateur notification utilisateur permet à une application ou une extension d’application de personnaliser l’apparence des notifications locales et distantes lorsqu’elles sont présentées à l’utilisateur.

Cette infrastructure fournit les méthodes suivantes pour qu’une application puisse remettre des notifications à un utilisateur :

• Alertes visuelles : où la notification est déployée en haut de l’écran sous la forme d’une bannière.
• Son et vibrations : peut être associé à une notification.
• Le badging des icônes d'applications : lorsque l’icône de l'application affiche un badge indiquant la disponibilité de nouveau contenu, comme le nombre de messages électroniques non lus.

En outre, selon le contexte actuel de l’utilisateur, il existe différentes façons de présenter une notification :

• Si l’appareil est déverrouillé, la notification s’affiche en haut de l’écran sous la forme d’une bannière.
• Si l’appareil est verrouillé, la notification s’affiche sur l’écran de verrouillage de l’utilisateur.
• Si l'utilisateur a raté une notification, il peut ouvrir le Centre de notifications et voir toutes les notifications disponibles et en attente.

Une application peut envoyer deux types de notifications utilisateur :

• Notifications locales : celles-ci sont envoyées par les applications installées localement sur l’appareil des utilisateurs.
• Notifications à distance : sont envoyées à partir d’un serveur distant et présentées à l’utilisateur ou déclenchent une mise à jour en arrière-plan du contenu de l’application.

À propos des notifications locales

Les notifications locales qu’une application peut envoyer ont les fonctionnalités et attributs suivants :

• Ils sont envoyés par des applications locales sur l’appareil de l’utilisateur.
• Ils peuvent être configurés pour utiliser des déclencheurs basés sur l’heure ou l’emplacement.
• L’application planifie la notification avec l’appareil de l’utilisateur et s’affiche lorsque la condition de déclencheur est remplie.
• Lorsque l’utilisateur interagit avec une notification, l’application reçoit un rappel.

Voici quelques exemples de notifications locales :

• Alertes de calendrier.
• Alertes de rappel.
• Déclencheurs prenant en compte l’emplacement.

Pour plus d’informations, consultez la documentation sur les notifications utilisateur d’Apple.

À propos des notifications à distance

Les notifications à distance qu’une application peut envoyer ont les fonctionnalités et attributs suivants :

• L’application a un composant côté serveur avec lequel elle communique.
• Le service de notification Push Apple (APN) est utilisé pour transmettre une transmission en mode meilleur effort des notifications à distance à l’appareil de l’utilisateur à partir des serveurs basés sur le cloud du développeur.
• Lorsque l’application reçoit la notification à distance, elle s’affiche à l’utilisateur.
• Lorsque l’utilisateur interagit avec la notification, l’application reçoit un rappel.

Voici quelques exemples de notifications à distance :

• Alertes d’actualités.
• Mises à jour sportives.
• Messages de messagerie instantanée.

Il existe deux types de notifications à distance disponibles pour une application :

• À l'attention de l'utilisateur : ceux-ci sont affichés à l'utilisateur sur l'appareil.
• Mises à jour silencieuses : elles fournissent un mécanisme permettant de mettre à jour le contenu d’une application en arrière-plan. Lorsqu’une mise à jour silencieuse est reçue, l’application peut contacter les serveurs distants pour extraire le contenu le plus récent.

Pour plus d’informations, consultez la documentation sur les notifications utilisateur d’Apple.

UIApplication API

Il est possible d’utiliser UIApplication pour inscrire une notification auprès du système et de planifier la façon dont cette notification doit être déclenchée , soit par heure, soit par emplacement (il s’agit de l’API d’origine fournie pour les notifications utilisateur par Apple).

Toutefois, un développeur peut rencontrer plusieurs problèmes lors de l’utilisation de la notification existante, comme indiqué par UIApplication :

• Il existe différents rappels requis pour les notifications locales ou distantes, ce qui peut entraîner la duplication du code.
• L’application a un contrôle limité de la notification une fois qu’elle a été planifiée avec le système.
• Il existe différents niveaux de prise en charge sur toutes les plateformes existantes d’Apple.

À propos de l’infrastructure Notifications utilisateur

Pour améliorer l’expérience avec les notifications, Apple a introduit l’infrastructure Notifications utilisateur, qui remplace la méthode UIApplication existante indiquée ci-dessus.

L’infrastructure Notifications utilisateur fournit les éléments suivants :

• API familière qui inclut la parité des fonctionnalités avec les méthodes précédentes, ce qui facilite le port du code à partir de l’infrastructure existante.
• Inclut un ensemble étendu d’options de contenu qui permet d’envoyer des notifications plus riches à l’utilisateur.
• Les notifications locales et distantes peuvent être gérées par le même code et les mêmes rappels.
• Simplifie le processus de gestion des rappels envoyés à une application lorsque l’utilisateur interagit avec une notification.
• Gestion améliorée des notifications en attente et remises, notamment la possibilité de supprimer ou de mettre à jour des notifications.
• Ajoute la possibilité d’effectuer une présentation dans l’application des notifications.
• Ajoute la possibilité de planifier et de gérer les notifications à partir des extensions d’application.
• Ajoute un nouveau point d’extension pour les notifications elles-mêmes.

L’infrastructure Notifications utilisateur fournit une API de notification unifiée sur plusieurs plateformes prises en charge par Apple, notamment :

• iOS : prise en charge complète de la gestion et de la planification des notifications.
• tvOS : ajoute la possibilité de badger des icônes d’application pour les notifications locales et distantes.
• Mac Catalyst : Prise en charge complète de la gestion et de la planification des notifications.
• macOS : prise en charge complète de la gestion et de la planification des notifications.

Pour plus d’informations, consultez la documentation d’Apple sur les notifications utilisateurs et l’interface utilisateur des notifications.

Préparation de la remise des notifications

Avant qu’une application puisse envoyer des notifications à l’utilisateur, l’application doit être inscrite auprès du système et, étant donné qu’une notification est une interruption de l’utilisateur, une application doit demander explicitement l’autorisation avant de les envoyer.

Il existe trois niveaux de demandes de notification différents que l’utilisateur peut approuver pour une application :

• Bannières affichées.
• Alertes sonores.
• Badging the app icon.

En outre, ces niveaux d’approbation doivent être demandés et définis pour les notifications locales et distantes.

L’autorisation de notification doit être demandée dès que l’application démarre en ajoutant le code suivant à la FinishedLaunching méthode du type de notification souhaité () et en définissant le type de AppDelegate notification souhaité (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;
}

Sur macOS, effectuez-le dans l’implémentation 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)
    });
}

En outre, un utilisateur peut toujours modifier les privilèges de notification d’une application à tout moment à l’aide de l’application Paramètres sur l’appareil. L’application doit vérifier les privilèges de notification demandés par l’utilisateur avant de présenter une notification à l’aide du code suivant :

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

Activation des notifications en arrière-plan

Pour que l’application reçoive des notifications en arrière-plan, elle doit activer le mode en arrière-plan des notifications à distance pour l’application.

Pour ce faire, ajoutez une remote-notifications entrée au tableau dans le UIBackgroundModes fichier Info.plist du projet, comme suit :

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

Configuration de l’environnement de notifications à distance

Le développeur doit informer le système d’exploitation dans quel environnement les notifications push s’exécutent : soit development, soit production. L’échec de la fourniture de ces informations peut entraîner le rejet de l’application lorsqu’elle est envoyée à l’App Store avec une notification similaire à ce qui suit :

Droits de notification Push manquants : votre application inclut une API pour le service de notification Push d’Apple, mais l'autorisation aps-environment est manquante de la signature de l’application.

Pour fournir le droit requis, procédez comme suit :

1. Ouvrez le fichier projet dans l’éditeur de texte de votre choix.

2. Entrez deux CustomEntitlements éléments, comme suit :

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

   Remarque : si vous utilisez une configuration différente de Release celle pour publier sur l’App Store, mettez à jour les conditions en conséquence.

Approvisionnement

L'autorisation aps-environment de la section précédente nécessite l’utilisation d’un profil de provisionnement avec la capacité Push Notifications :

1. Accédez à la section Identificateurs du site développeur Apple :

   

2. Ajoutez un nouvel identificateur (Inscrire un nouvel identificateur) :

   

3. Sélectionnez le type « Application » :

   

4. Entrez l’identificateur de bundle et la description du nouvel identificateur d’application :

   

5. Activez la Push Notifications fonctionnalité :

   

6. Cliquez sur le Register bouton pour enregistrer le nouvel identificateur d’application.

L’étape suivante consiste à créer un profil d’approvisionnement pour le nouvel identificateur d’application :

1. Accédez à la section Profils du site développeur Apple :

   

2. Ajoutez un nouveau profil pour le développement d’applications iOS :

   

3. Sélectionnez l’ID d’application que nous venons de créer :

   

4. Sélectionnez tous les certificats inclus dans ce profil d’approvisionnement (un nouveau certificat doit être créé si aucun certificat n’a encore été créé) :

   

5. Sélectionnez tous les appareils inclus dans ce profil d’approvisionnement (l’application ne peut être installée que sur ces appareils).

   

6. Choisissez un nom pour le profil d’approvisionnement et examinez-le :

   

7. Générez et téléchargez le nouveau profil d’approvisionnement.

   

8. Ouvrez le fichier de profil d’approvisionnement téléchargé dans Xcode (en double-cliquant dessus dans Finder) pour l’installer dans le système.

9. Configurez le projet pour utiliser le profil d’approvisionnement nouvellement créé en définissant la CodesignProvision propriété sur le nom du profil d’approvisionnement à partir de l’étape 6 :

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

Inscription aux notifications à distance

Si l’application envoie et reçoit des notifications à distance, elle doit toujours effectuer l’inscription de jeton à l’aide de l’API UIApplication existante. Cette inscription nécessite que l’appareil dispose d’une connexion réseau active pour accéder aux APIN, ce qui génère le jeton nécessaire qui sera envoyé à l’application. L’application doit ensuite transférer ce jeton à l’application côté serveur du développeur pour s’inscrire aux notifications à distance :

Utilisez le code suivant pour initialiser l’inscription requise :

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Le jeton envoyé à l’application côté serveur du développeur doit être inclus dans le cadre de la charge utile de notification envoyée du serveur aux API lors de l’envoi d’une notification à distance :

Le jeton agit comme la clé qui lie la notification et l’application utilisée pour ouvrir ou répondre à la notification.

Pour plus d’informations, consultez la documentation sur les notifications utilisateur d’Apple.

Remise des notifications

Avec l’application entièrement inscrite et les autorisations requises demandées par l’utilisateur et accordées par l’utilisateur, l’application est maintenant prête à envoyer et recevoir des notifications.

Fourniture de contenu de notification

Toutes les notifications contiennent un titre et un sous-titre qui seront toujours affichés avec le corps du contenu de la notification. Il est également possible d’ajouter des pièces jointes multimédias au contenu de notification.

Pour créer le contenu d’une notification locale, utilisez le code suivant :

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;

Pour les notifications à distance, le processus est similaire :

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

Planification lors de l’envoi d’une notification

Avec le contenu de la notification créée, l’application doit planifier le moment où la notification sera présentée à l’utilisateur en définissant un déclencheur. Il existe quatre types de déclencheurs différents :

• Notification Push : utilisée exclusivement avec les notifications à distance et déclenchée lorsque les API envoient un package de notification à l’application en cours d’exécution sur l’appareil.
• Intervalle de temps : permet à une notification locale d’être planifiée à partir d’un intervalle de temps de début avec maintenant et de terminer un point futur. Par exemple:

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

• Date du calendrier : permet aux notifications locales d’être planifiées pour une date et une heure spécifiques.
• Basé sur l’emplacement : permet aux notifications locales d’être planifiées lorsque l’appareil entre ou quitte un emplacement géographique spécifique ou se trouve dans une proximité donnée des balises Bluetooth.

Lorsqu’une notification locale est prête, l’application doit appeler UNUserNotificationCenter.AddNotificationRequest planifier son affichage à l’utilisateur. Pour les notifications à distance, l’application côté serveur envoie une charge utile de notification aux APN, qui envoie ensuite le paquet sur l’appareil de l’utilisateur.

Rassembler tous les éléments, un exemple de notification locale peut ressembler à ceci :

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
        }
    });
}

Déclenchement d’une notification à distance

Il existe plusieurs façons de déclencher une notification à distance pendant le développement pour les tests :

• Console de notification Push d’Apple
• Outils en ligne de commande
• Autres solutions tierces.

Une fois l’application publiée, les notifications à distance sont généralement déclenchées à partir d’applications côté serveur.

Gestion des notifications d’application de premier plan

Une application peut gérer les notifications différemment lorsqu’elle se trouve au premier plan et qu’une notification est déclenchée. En fournissant un UNUserNotificationCenterDelegate et en implémentant la méthode WillPresentNotification , l’application peut assumer la responsabilité d’afficher la notification. Par exemple:

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
}

Ce code écrit simplement le contenu de l’UNNotification dans la sortie de l’application et demande au système d’afficher l’alerte standard pour la notification.

Si l’application souhaitait afficher la notification elle-même lorsqu’elle était au premier plan, et ne pas utiliser les valeurs par défaut du système, passez None au gestionnaire d’achèvement. Exemple:

completionHandler (UNNotificationPresentationOptions.None);

Avec ce code en place, ouvrez le AppDelegate.cs fichier pour modifier et modifiez la FinishedLaunching méthode pour ressembler à ce qui suit :

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;
}

Ce code attache le UNUserNotificationCenterDelegate personnalisé mentionné ci-dessus au UNUserNotificationCenter actuel, afin que l’application puisse gérer les notifications pendant qu’elle est active et au premier plan.

Gestion des notifications

La gestion des notifications permet d’accéder aux notifications en attente et remises et ajoute la possibilité de supprimer, mettre à jour ou promouvoir ces notifications.

Une partie importante de la gestion des notifications est l’identificateur de demande qui a été affecté à la notification lors de sa création et sa planification avec le système. Pour les notifications à distance, cela est affecté via le apps-collapse-id champ dans l’en-tête de requête HTTP.

L’identificateur de demande est utilisé pour sélectionner la notification sur laquelle l’application souhaite effectuer la gestion des notifications.

Suppression des notifications

Pour supprimer une notification en attente du système, utilisez le code suivant :

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

Pour supprimer une notification déjà remise, utilisez le code suivant :

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

Mise à jour d’une notification existante

Pour mettre à jour une notification existante, créez simplement une notification avec les paramètres souhaités modifiés (par exemple, une nouvelle heure de déclenchement) et ajoutez-la au système avec le même identificateur de demande que la notification qui doit être modifiée. Exemple:

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...
    }
});

Pour les notifications déjà remises, la notification existante est mise à jour et promue en haut de la liste sur les écrans Accueil et Verrouillage et dans le Centre de notification s’il a déjà été lu par l’utilisateur.

Utilisation des actions de notification

Les notifications remises à l’utilisateur ne sont pas statiques et fournissent plusieurs façons dont l’utilisateur peut interagir avec eux (de l’intégration aux actions personnalisées).

Il existe trois types d’actions auxquelles une application peut répondre :

• Action par défaut : lorsque l’utilisateur appuie sur une notification pour ouvrir l’application et afficher les détails de la notification donnée.
• Actions personnalisées : elles permettent à l’utilisateur d’effectuer une tâche personnalisée directement à partir de la notification sans avoir à lancer l’application. Ils peuvent être présentés sous la forme d’une liste de boutons avec des titres personnalisables ou d’un champ d’entrée de texte qui peut s’exécuter en arrière-plan (où l’application dispose d’une petite quantité de temps pour répondre à la demande) ou au premier plan (où l’application est lancée au premier plan pour répondre à la demande).
• Action ignorer : cette action est envoyée à l’application lorsque l’utilisateur ignore une notification donnée.

Créer des actions personnalisées

Pour créer et inscrire une action personnalisée auprès du système, utilisez le code suivant :

// 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)); 

Lors de la création d’un nouvel objet UNNotificationAction, il reçoit un identificateur unique et le titre qui s’affiche sur le bouton. Par défaut, l’action est créée en tant qu’action en arrière-plan, mais les options peuvent être fournies pour ajuster le comportement de l’action (par exemple, la définition d’une action de premier plan).

Chacune des actions créées doit être associée à une catégorie. Lors de la création d’un nouvel identificateur UNNotificationCategory, il reçoit un identificateur unique, une liste d’actions qu’il peut effectuer, une liste d’identificateurs d’intention pour fournir plus d’informations sur l’intention des actions de la catégorie et certaines options pour contrôler le comportement de la catégorie.

Enfin, toutes les catégories sont inscrites auprès du système à l’aide de la méthode SetNotificationCategories .

Présentation d’actions personnalisées

Une fois qu’un ensemble d’actions et de catégories personnalisées ont été créées et inscrites auprès du système, elles peuvent être présentées à partir de notifications locales ou distantes.

Pour les notifications à distance, définissez une category valeur dans la charge utile de notification à distance qui correspond à l’une des catégories créées ci-dessus. Par exemple:

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

Pour les notifications locales, définissez la CategoryIdentifier propriété de l’objet UNMutableNotificationContent . Par exemple:

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";

Là encore, cet identificateur doit correspondre à l’une des catégories créées ci-dessus.

Gestion des actions de rejet

Comme indiqué ci-dessus, une action d’abandon peut être envoyée à l’application lorsque l’utilisateur ignore une notification. Étant donné qu’il ne s’agit pas d’une action standard, une option doit être définie lors de la création de la catégorie. Par exemple:

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

Gestion des réponses d’action

Lorsque l’utilisateur interagit avec les actions et catégories personnalisées créées ci-dessus, l’application doit remplir la tâche demandée. Pour ce faire, fournissez un [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] et implémentez la méthode DidReceiveNotificationResponse . Par exemple:

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
    }
}

La classe passée UNNotificationResponse a une ActionIdentifier propriété qui peut être l’action par défaut ou l’action d’abandon. Utilisez response.Notification.Request.Identifier pour tester les actions personnalisées.

La UserText propriété contient la valeur d’une entrée de texte utilisateur. La Notification propriété contient la notification d’origine qui inclut la demande avec le contenu du déclencheur et de la notification. L’application peut décider s’il s’agissait d’une notification locale ou distante en fonction du type de déclencheur.

Utilisation des extensions de Service de notification

Lorsque vous utilisez des notifications à distance, une extension de service de notification permet d’activer le chiffrement de bout en bout à l’intérieur de la charge utile de notification. Une extension de service de notification est une extension d’interface non utilisateur qui s’exécute en arrière-plan avec l’objectif principal d’augmenter ou de remplacer le contenu visible d’une notification avant qu’elle ne soit présentée à l’utilisateur.

Les extensions de service de notification sont destinées à s’exécuter rapidement et n’ont qu’une courte durée d’exécution par le système. Si l’extension Notification Service ne parvient pas à terminer sa tâche dans le délai imparti, une méthode de secours est appelée. Si la solution de repli échoue, le contenu de notification d’origine sera affiché à l'utilisateur.

Voici quelques utilisations potentielles des extensions de Service de notification :

• Fourniture d’un chiffrement de bout en bout du contenu de notification à distance.
• Ajout de pièces jointes à des notifications à distance pour les enrichir.

Implémentation d’une extension de service de notification

Pour implémenter une extension Notification Service dans une application, procédez comme suit :

1. Créez un dossier pour le projet d’extension, en regard du dossier du projet principal. Les instructions suivantes supposent que le nouveau dossier est nommé MyNotificationServiceExtension.

2. Ouvrez un terminal et exécutez :

   dotnet new ios-notification-service-extension
   

3. Ouvrez le fichier projet du projet principal, puis ajoutez :

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

4. Maintenant, générez le projet principal, et le projet d’extension sera également généré et inclus dans le bundle d’application final.

Il existe une classe principale dans l’extension Notification Service qui doit être modifiée pour fournir les fonctionnalités requises. Par exemple:

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.
        }
    }
}

La méthode DidReceiveNotificationRequest recevra l'identificateur de notification ainsi que le contenu de la notification via l'objet request. contentHandler transmis doit être invoqué pour présenter la notification à l’utilisateur.

La deuxième méthode, TimeWillExpire, sera appelée juste avant que le délai soit sur le point d'expirer pour l'extension Notification Service afin de traiter la requête. Si l’extension de service de notification ne parvient pas à appeler le contentHandler, dans le délai imparti, le contenu d’origine s’affiche à l’utilisateur.

Déclenchement d’une extension de service de notification

Avec une extension Notification Service créée et remise avec l’application, elle peut être déclenchée en modifiant la charge utile de notification à distance envoyée à l’appareil. Par exemple:

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

La nouvelle mutable-content clé spécifie que l’extension Notification Service doit être lancée pour mettre à jour le contenu de notification à distance. La encrypted-content clé contient les données chiffrées que l’extension Notification Service peut déchiffrer avant de présenter à l’utilisateur.

Examinez l’exemple d’extension Notification Service suivant :

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
        }
        
    }
}

Ce code déchiffre le contenu chiffré à partir de la encrypted-content clé, crée un nouveau UNMutableNotificationContent, définit la propriété Body sur le contenu déchiffré et utilise le contentHandler pour présenter la notification à l’utilisateur.

Voir aussi

• exemple iOS
• Informations de référence sur l’infrastructure UserNotifications
• UserNotificationsUI
• Guide de programmation des notifications locales et distantes
• Personnalisation de l’apparence des notifications