Notifiche utente avanzate in Xamarin.iOS

Novità di iOS 10, il framework di notifica utente consente il recapito e la gestione delle notifiche locali e remote. Usando questo framework, un'app o un'estensione dell'app può pianificare il recapito delle notifiche locali specificando un set di condizioni, ad esempio la posizione o l'ora del giorno.

Informazioni sulle notifiche utente

Come indicato in precedenza, il nuovo framework di notifica utente consente il recapito e la gestione delle notifiche locali e remote. Usando questo framework, un'app o un'estensione dell'app può pianificare il recapito delle notifiche locali specificando un set di condizioni, ad esempio la posizione o l'ora del giorno.

Inoltre, l'app o l'estensione possono ricevere (e potenzialmente modificare) le notifiche locali e remote man mano che vengono recapitate al dispositivo iOS dell'utente.

Il nuovo framework dell'interfaccia utente di notifica utente consente a un'app o all'estensione dell'app di personalizzare l'aspetto delle notifiche locali e remote quando vengono presentate all'utente.

Questo framework fornisce i modi seguenti in cui un'app può recapitare notifiche a un utente:

• Avvisi visivi: in cui la notifica viene eseguito il roll down dalla parte superiore dello schermo come banner.
• Audio e vibrazioni : può essere associato a una notifica.
• Icona dell'app Badging - Dove l'icona dell'app visualizza una notifica che mostra che è disponibile un nuovo contenuto, ad esempio il numero di messaggi di posta elettronica non letti.

Inoltre, a seconda del contesto corrente dell'utente, esistono diversi modi in cui verrà presentata una notifica:

• Se il dispositivo è sbloccato, la notifica verrà roll down dalla parte superiore dello schermo come banner.
• Se il dispositivo è bloccato, la notifica verrà visualizzata nella schermata di blocco dell'utente.
• Se l'utente ha perso una notifica, può aprire il Centro notifiche e visualizzare eventuali notifiche disponibili in attesa.

Un'app Xamarin.iOS ha due tipi di notifiche utente che è in grado di inviare:

• Notifiche locali: queste vengono inviate dalle app installate localmente nel dispositivo degli utenti.
• Notifiche remote: vengono inviate da un server remoto e presentate all'utente o attivano un aggiornamento in background del contenuto dell'app.

Informazioni sulle notifiche locali

Le notifiche locali che un'app iOS può inviare hanno le funzionalità e gli attributi seguenti:

• Vengono inviati dalle app locali nel dispositivo dell'utente.
• Possono essere configurati per l'uso di trigger basati sul tempo o sulla posizione.
• L'app pianifica la notifica con il dispositivo dell'utente e viene visualizzata quando viene soddisfatta la condizione del trigger.
• Quando l'utente interagisce con una notifica, l'app riceverà un callback.

Ecco alcuni esempi di notifiche locali:

• Avvisi del calendario
• Avvisi di promemoria
• Trigger con riconoscimento della posizione

Per altre informazioni, vedere la documentazione della Guida alla programmazione locale e remota di Apple.

Informazioni sulle notifiche remote

Le notifiche remote che un'app iOS può inviare hanno le funzionalità e gli attributi seguenti:

• L'app ha un componente lato server con cui comunica.
• Apple Push Notification Service (APN) viene usato per trasmettere una distribuzione ottimale delle notifiche remote al dispositivo dell'utente dai server basati sul cloud dello sviluppatore.
• Quando l'app riceve la notifica remota, verrà visualizzata all'utente.
• Quando l'utente interagisce con la notifica, l'app riceverà un callback.

Alcuni esempi di notifiche remote includono:

• Avvisi notizie
• Sport Aggiornamenti
• Messaggi di messaggistica istantanea

Esistono due tipi di notifiche remote disponibili per un'app iOS:

• Utente: vengono visualizzati all'utente nel dispositivo.
• Aggiornamenti invisibile all'utente: questi forniscono un meccanismo per aggiornare il contenuto di un'app iOS in background. Quando viene ricevuto un aggiornamento invisibile all'utente, l'app può contattare i server remoti per eseguire il pull del contenuto più recente.

Per altre informazioni, vedere la documentazione della Guida alla programmazione locale e remota di Apple.

Informazioni sull'API notifiche esistente

Prima di iOS 10, un'app iOS userebbe UIApplication per registrare una notifica con il sistema e pianificare la modalità di attivazione della notifica (in base all'ora o alla posizione).

Esistono diversi problemi che possono verificarsi per gli sviluppatori quando si lavora con l'API di notifica esistente:

• Sono stati necessari callback diversi per le notifiche locali o remote che potrebbero causare la duplicazione del codice.
• L'app aveva un controllo limitato della notifica dopo che era stata pianificata con il sistema.
• Ci sono stati diversi livelli di supporto in tutte le piattaforme esistenti di Apple.

Informazioni sul nuovo framework di notifica utente

Con iOS 10, Apple ha introdotto il nuovo framework di notifica utente, che sostituisce il metodo esistente UIApplication annotato in precedenza.

Il framework di notifica utente fornisce quanto segue:

• Un'API familiare che include parità di funzionalità con i metodi precedenti semplificando la conversione del codice dal framework esistente.
• Include un set esteso di opzioni di contenuto che consente l'invio di notifiche più avanzate all'utente.
• Sia le notifiche locali che remote possono essere gestite dallo stesso codice e dal callback.
• Semplifica il processo di gestione dei callback inviati a un'app quando l'utente interagisce con una notifica.
• Gestione avanzata delle notifiche in sospeso e recapitate, inclusa la possibilità di rimuovere o aggiornare le notifiche.
• Aggiunge la possibilità di eseguire la presentazione in-app delle notifiche.
• Aggiunge la possibilità di pianificare e gestire le notifiche dall'interno delle estensioni dell'app.
• Aggiunge un nuovo punto di estensione per le notifiche stesse.

Il nuovo framework di notifica utente fornisce un'API di notifica unificata tra più piattaforme supportate da Apple, tra cui:

• iOS : supporto completo per gestire e pianificare le notifiche.
• tvOS : aggiunge la possibilità di notificare le icone delle app per le notifiche locali e remote.
• watchOS : aggiunge la possibilità di inoltrare notifiche dal dispositivo iOS associato dell'utente all'Apple Watch e offre alle app watch la possibilità di eseguire notifiche locali direttamente sull'orologio stesso.
• macOS : supporto completo per gestire e pianificare le notifiche.

Per altre informazioni, vedere la documentazione userNotifications Framework di Apple e UserNotificationsUI .

Preparazione per il recapito delle notifiche

Prima che un'app iOS possa inviare notifiche all'utente, l'app deve essere registrata nel sistema e, poiché una notifica è un'interruzione per l'utente, un'app deve richiedere esplicitamente l'autorizzazione prima di inviarle.

Esistono tre diversi livelli di richieste di notifica che l'utente può approvare per un'app:

• Vengono visualizzati banner.
• Avvisi sonori.
• Badging dell'icona dell'app.

Inoltre, questi livelli di approvazione devono essere richiesti e impostati per le notifiche locali e remote.

L'autorizzazione di notifica deve essere richiesta non appena l'app viene avviata aggiungendo il codice seguente al FinishedLaunching metodo di e impostando il tipo di AppDelegate notifica desiderato (UNAuthorizationOptions):

Nota

UNUserNotificationCenter è disponibile solo da iOS 10+. Pertanto, è consigliabile controllare la versione di macOS prima di inviare la richiesta.

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

Poiché questa API è unificata e funziona anche in Mac 10.14+, se si intende impostare macOS come destinazione, è necessario anche verificare la presenza dell'autorizzazione di notifica il prima possibile:

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

Configurazione dell'ambiente di notifiche remote

Novità di iOS 10, lo sviluppatore deve informare il sistema operativo in cui è in esecuzione la notifica push dell'ambiente come sviluppo o produzione. Se non si specificano queste informazioni, l'app viene rifiutata quando viene inviata all'App Store iTune con una notifica simile alla seguente:

Entitlement di notifica push mancante: l'app include un'API per il servizio di notifica push di Apple, ma il aps-environment diritto non è presente nella firma dell'app.

Per fornire il diritto necessario, eseguire le operazioni seguenti:

Visual Studio per Mac

1. Fare doppio clic sul Entitlements.plist file nel riquadro della soluzione per aprirlo per la modifica.

2. Passare alla visualizzazione Origine:

   

3. Fare clic sul + pulsante per aggiungere una nuova chiave.

4. Immettere aps-environment per Property (Proprietà), lasciare type (StringTipo) e immettere development o production per Value (Valore):

   

5. Salvare le modifiche apportate al file.

Visual Studio

1. Fare doppio clic sul Entitlements.plist file nel Esplora soluzioni per aprirlo per la modifica.

2. Fare clic sul + pulsante per aggiungere una nuova chiave.

3. Immettere aps-environment per Property (Proprietà), lasciare type (StringTipo) e immettere development o production per Value (Valore):

   

4. Salvare le modifiche apportate al file.

Registrazione per le notifiche remote

Se l'app invia e riceve notifiche remote, sarà comunque necessario eseguire la registrazione dei token usando l'API esistente UIApplication . Questa registrazione richiede che il dispositivo disponga di un APN di accesso alla connessione di rete in tempo reale, che genererà il token necessario che verrà inviato all'app. L'app deve quindi inoltrare questo token all'app lato server dello sviluppatore per registrarsi per le notifiche remote:

Usare il codice seguente per inizializzare la registrazione richiesta:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Il token che viene inviato all'app lato server dello sviluppatore dovrà essere incluso come parte del payload di notifica che viene inviato dal server agli APN durante l'invio di una notifica remota:

Il token funge da chiave che collega la notifica e l'app usata per aprire o rispondere alla notifica.

Per altre informazioni, vedere la documentazione della Guida alla programmazione locale e remota di Apple.

Recapito delle notifiche

Con l'app completamente registrata e le autorizzazioni necessarie richieste e concesse dall'utente, l'app è ora pronta per inviare e ricevere notifiche.

Fornire contenuto di notifica

Novità di iOS 10, tutte le notifiche contengono sia un titolo che un sottotitolo che verranno sempre visualizzati con il corpo del contenuto della notifica. Inoltre, è la possibilità di aggiungere allegati multimediali al contenuto della notifica.

Per creare il contenuto di una notifica locale, usare il codice seguente:

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;

Per Le notifiche remote, il processo è simile al seguente:

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

Pianificazione quando viene inviata una notifica

Con il contenuto della notifica creata, l'app deve pianificare quando la notifica verrà presentata all'utente impostando un trigger. iOS 10 offre quattro tipi di trigger diversi:

• Notifica push: viene usata esclusivamente con le notifiche remote e viene attivata quando gli APN inviano un pacchetto di notifica all'app in esecuzione nel dispositivo.
• Intervallo di tempo: consente di pianificare una notifica locale da un intervallo di tempo a partire da ora e terminare un punto futuro. Ad esempio, var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);
• Data calendario: consente di pianificare le notifiche locali per una data e un'ora specifiche.
• Location Based : consente di pianificare le notifiche locali quando il dispositivo iOS entra o lascia una posizione geografica specifica o si trova in una determinata prossimità a qualsiasi Beacon Bluetooth.

Quando una notifica locale è pronta, l'app deve chiamare il Add metodo dell'oggetto UNUserNotificationCenter per pianificarne la visualizzazione all'utente. Per Le notifiche remote, l'app sul lato server invia un payload di notifica agli APN, che quindi invia il pacchetto al dispositivo dell'utente.

Riunire tutte le parti, una notifica locale di esempio potrebbe essere simile alla seguente:

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

Gestione delle notifiche delle app in primo piano

Novità di iOS 10, un'app può gestire le notifiche in modo diverso quando è in primo piano e viene attivata una notifica. Fornendo un UNUserNotificationCenterDelegate oggetto e implementando il WillPresentNotification metodo , l'app può assumere la responsabilità di visualizzare la notifica. Ad esempio:

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

Questo codice sta semplicemente scrivendo il contenuto di nell'output dell'applicazione UNNotification e chiedendo al sistema di visualizzare l'avviso standard per la notifica.

Se l'app vuole visualizzare la notifica stessa quando era in primo piano e non usa le impostazioni predefinite del sistema, passare None al gestore di completamento. Esempio:

completionHandler (UNNotificationPresentationOptions.None);

Con questo codice sul posto, aprire il AppDelegate.cs file per la modifica e modificare il FinishedLaunching metodo in modo che sia simile al seguente:

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

Questo codice collega l'oggetto personalizzato UNUserNotificationCenterDelegate dall'alto all'oggetto corrente UNUserNotificationCenter in modo che l'app possa gestire la notifica mentre è attiva e in primo piano.

Gestione delle notifiche

Novità di iOS 10, Gestione notifiche fornisce l'accesso alle notifiche in sospeso e recapitate e aggiunge la possibilità di rimuovere, aggiornare o alzare di livello queste notifiche.

Una parte importante di Gestione notifiche è l'identificatore della richiesta assegnato alla notifica al momento della creazione e della pianificazione con il sistema. Per Le notifiche remote, questa opzione viene assegnata tramite il nuovo apps-collapse-id campo nell'intestazione della richiesta HTTP.

L'identificatore della richiesta viene usato per selezionare la notifica in cui l'app vuole eseguire Gestione notifiche.

Rimozione delle notifiche

Per rimuovere una notifica in sospeso dal sistema, usare il codice seguente:

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

Per rimuovere una notifica già recapitata, usare il codice seguente:

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

Aggiornamento di una notifica esistente

Per aggiornare una notifica esistente, è sufficiente creare una nuova notifica con i parametri desiderati modificati (ad esempio un nuovo tempo di trigger) e aggiungerla al sistema con lo stesso identificatore di richiesta della notifica che deve essere modificata. Esempio:

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

Per le notifiche già recapitate, la notifica esistente verrà aggiornata e promossa all'inizio dell'elenco nelle schermate Home e Blocco e nel Centro notifiche, se è già stata letta dall'utente.

Utilizzo delle azioni di notifica

In iOS 10 le notifiche recapitate all'utente non sono statiche e forniscono diversi modi in cui l'utente può interagire con loro (da azioni predefinite a personalizzate).

Esistono tre tipi di azioni a cui un'app iOS può rispondere:

• Azione predefinita: quando l'utente tocca una notifica per aprire l'app e visualizzare i dettagli della notifica specificata.
• Azioni personalizzate: aggiunte in iOS 8 e consentono all'utente di eseguire un'attività personalizzata direttamente dalla notifica senza dover avviare l'app. Possono essere presentati come un elenco di pulsanti con titoli personalizzabili o un campo di input di testo che può essere eseguito in background (dove l'app viene data una piccola quantità di tempo per soddisfare la richiesta) o in primo piano (dove l'app viene avviata in primo piano per soddisfare la richiesta). Le azioni personalizzate sono disponibili sia in iOS che in watchOS.
• Ignora azione : questa azione viene inviata all'app quando l'utente ignora una determinata notifica.

Creazione di azioni personalizzate

Per creare e registrare un'azione personalizzata con il sistema, usare il codice seguente:

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

Quando si crea un nuovo UNNotificationActionoggetto , viene assegnato un ID univoco e il titolo che verrà visualizzato sul pulsante. Per impostazione predefinita, l'azione verrà creata come azione in background, ma è possibile specificare le opzioni per regolare il comportamento dell'azione, ad esempio impostandolo su un'azione in primo piano.

Ognuna delle azioni create deve essere associata a una categoria. Quando si crea un nuovo UNNotificationCategory, viene assegnato un ID univoco, un elenco di azioni che può eseguire, un elenco di ID finalità per fornire ulteriori informazioni sulla finalità delle azioni nella categoria e alcune opzioni per controllare il comportamento della categoria.

Infine, tutte le categorie vengono registrate con il sistema usando il SetNotificationCategories metodo .

Presentazione di azioni personalizzate

Dopo aver creato e registrato un set di azioni e categorie personalizzate con il sistema, possono essere presentate da Notifiche locali o remote.

Per Notifica remota, impostare un category oggetto nel payload di notifica remota che corrisponde a una delle categorie create in precedenza. Ad esempio:

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

Per Notifiche locali impostare la CategoryIdentifier proprietà dell'oggetto UNMutableNotificationContent . Ad esempio:

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

Anche in questo caso, questo ID deve corrispondere a una delle categorie create in precedenza.

Gestione delle azioni di chiusura

Come indicato in precedenza, un'azione Ignora può essere inviata all'app quando l'utente ignora una notifica. Poiché non si tratta di un'azione standard, è necessario impostare un'opzione quando viene creata la categoria. Ad esempio:

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

Gestione delle risposte alle azioni

Quando l'utente interagisce con le azioni personalizzate e le categorie create in precedenza, l'app deve soddisfare l'attività richiesta. Questa operazione viene eseguita fornendo un oggetto UNUserNotificationCenterDelegate e implementando il UserNotificationCenter metodo . Ad esempio:

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 passata UNNotificationResponse ha una ActionIdentifier proprietà che può essere l'azione predefinita o l'azione Ignora. Usare response.Notification.Request.Identifier per testare eventuali azioni personalizzate.

La UserText proprietà contiene il valore di qualsiasi input di testo dell'utente. La Notification proprietà contiene la notifica di origine che include la richiesta con il contenuto del trigger e della notifica. L'app può decidere se si tratta di una notifica locale o remota in base al tipo di trigger.

Nota

iOS 12 consente a un'interfaccia utente di notifica personalizzata di modificare i pulsanti di azione in fase di esecuzione. Per altre informazioni, vedere la documentazione relativa ai pulsanti di azione di notifica dinamica.

Uso delle estensioni del servizio

Quando si lavora con le notifiche remote, le estensioni del servizio consentono di abilitare la crittografia end-to-end all'interno del payload di notifica. Le estensioni di servizio sono un'estensione non dell'interfaccia utente (disponibile in iOS 10) eseguita in background con lo scopo principale di aumentare o sostituire il contenuto visibile di una notifica prima che venga presentato all'utente.

Le estensioni del servizio sono progettate per essere eseguite rapidamente e vengono date solo una breve quantità di tempo per l'esecuzione da parte del sistema. Nel caso in cui l'estensione del servizio non venga completata nell'intervallo di tempo assegnato, verrà chiamato un metodo di fallback. Se il fallback ha esito negativo, il contenuto di notifica originale verrà visualizzato all'utente.

Alcuni potenziali usi delle estensioni di servizio includono:

• Fornire la crittografia end-to-end del contenuto di notifica remota.
• Aggiunta di allegati a Notifiche remote per arricchire tali allegati.

Implementazione di un'estensione del servizio

Per implementare un'estensione del servizio in un'app Xamarin.iOS, eseguire le operazioni seguenti:

Visual Studio per Mac

1. Aprire la soluzione dell'app in Visual Studio per Mac.

2. Fare clic con il pulsante destro del mouse sul nome della soluzione nel riquadro della soluzione e scegliere Aggiungi>nuovo progetto.

3. Selezionare Le estensioni del servizio di notifica per le estensioni> iOS>e fare clic sul pulsante Avanti:

   

4. Immettere un nome per l'estensione e fare clic sul pulsante Avanti :

   

5. Modificare il nome del progetto e/o il nome della soluzione, se necessario, e fare clic sul pulsante Crea:

   

Visual Studio

1. Aprire la soluzione dell'app in Visual Studio.

2. Fare clic con il pulsante destro del mouse sul nome della soluzione nella Esplora soluzioni e scegliere Aggiungi > nuovo progetto.

3. Selezionare Visual C# iOS Extensions Notification Service Extensions :Select Visual C# > iOS Extensions Notification Service Extensions>:

   

4. Immettere un nome per l'estensione e fare clic sul pulsante OK .

Importante

L'identificatore bundle per l'estensione del servizio deve corrispondere all'identificatore bundle dell'app principale con .appnameserviceextension aggiunto alla fine. Ad esempio, se l'app principale ha un identificatore bundle di com.xamarin.monkeynotify, l'estensione del servizio deve avere un identificatore bundle di com.xamarin.monkeynotify.monkeynotifyserviceextension. Questa impostazione deve essere impostata automaticamente quando l'estensione viene aggiunta alla soluzione.

Esiste una classe principale nell'estensione del servizio di notifica che dovrà essere modificata per fornire la funzionalità necessaria. Ad esempio:

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

Il primo metodo, DidReceiveNotificationRequest, verrà passato l'identificatore di notifica e il contenuto della notifica tramite l'oggetto request . L'oggetto passato contentHandler dovrà essere chiamato per presentare la notifica all'utente.

Il secondo metodo, TimeWillExpire, verrà chiamato poco prima che si esaurisca per consentire all'estensione del servizio di elaborare la richiesta. Se l'estensione del servizio non riesce a chiamare nell'intervallo contentHandler di tempo assegnato, il contenuto originale verrà visualizzato all'utente.

Attivazione di un'estensione del servizio

Con un'estensione del servizio creata e recapitata con l'app, può essere attivata modificando il payload di notifica remota inviato al dispositivo. Ad esempio:

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

La nuova mutable-content chiave specifica che l'estensione del servizio dovrà essere avviata per aggiornare il contenuto della notifica remota. La encrypted-content chiave contiene i dati crittografati che l'estensione del servizio può decrittografare prima di presentare all'utente.

Esaminare l'esempio di estensione del servizio seguente:

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

    }
}

Questo codice decrittografa il contenuto crittografato dalla encrypted-content chiave, crea un nuovo UNMutableNotificationContentoggetto , imposta la Body proprietà sul contenuto decrittografato e usa per contentHandler presentare la notifica all'utente.

Riepilogo

Questo articolo ha illustrato tutti i modi in cui le notifiche degli utenti sono state migliorate da iOS 10. Ha presentato il nuovo framework di notifica utente e come usarlo in un'app Xamarin.iOS o in un'estensione dell'app.

Collegamenti correlati

• Informazioni di riferimento sul framework UserNotifications
• UserNotificationsUI
• Guida alla programmazione di notifiche locali e remote