Användarmeddelanden

Ramverket för användarmeddelanden möjliggör leverans och hantering av lokala och fjärranslutna meddelanden. Med det här ramverket kan en app eller ett apptillägg schemalägga leveransen av lokala meddelanden genom att ange en uppsättning villkor, till exempel plats eller tid på dagen.

Dessutom kan appen eller tillägget ta emot (och eventuellt ändra) både lokala och fjärranslutna meddelanden när de levereras till användarens enhet.

Användarmeddelandegränssnittsramverket tillåter att ett app- eller apptillägg anpassar utseendet på både lokala och fjärranslutna meddelanden när de visas för användaren.

Det här ramverket tillhandahåller följande sätt att en app kan leverera meddelanden till en användare:

• Visuella aviseringar: där meddelandet rullas ned överst på skärmen som en banderoll.
• Ljud och vibrationer: kan associeras med ett meddelande.
• Appikonens märkning: där appens ikon visar en indikator som visar att nytt innehåll är tillgängligt, till exempel antalet olästa e-postmeddelanden.

Beroende på användarens aktuella kontext finns det dessutom olika sätt att presentera ett meddelande:

• Om enheten är upplåst rullas meddelandet ned överst på skärmen som en banderoll.
• Om enheten är låst visas meddelandet på användarens låsskärm.
• Om användaren har missat ett meddelande kan de öppna meddelandecentret och visa alla tillgängliga väntande meddelanden där.

En app kan skicka två typer av användarmeddelanden:

• Lokala meddelanden: dessa skickas av appar som installeras lokalt på användarnas enhet.
• Fjärrmeddelanden: skickas från en fjärrserver och visas antingen för användaren eller så utlöser de en bakgrundsuppdatering av appens innehåll.

Om lokala meddelanden

De lokala meddelanden som en app kan skicka har följande funktioner och attribut:

• De skickas av appar som är lokala på användarens enhet.
• De kan konfigureras för att använda tids- eller platsbaserade utlösare.
• Appen schemalägger meddelandet med användarens enhet och visas när utlösarvillkoret uppfylls.
• När användaren interagerar med ett meddelande får appen ett återanrop.

Några exempel på lokala meddelanden är:

• Kalenderaviseringar.
• Påminnelseaviseringar.
• Platsmedvetna utlösare.

Mer information finns i Apples dokumentation om användarmeddelanden .

Om fjärrmeddelanden

Fjärrmeddelanden som en app kan skicka har följande funktioner och attribut:

• Appen har en komponent på serversidan som den kommunicerar med.
• Apple Push Notification Service (APN) används för att överföra en bästa leverans av fjärrmeddelanden till användarens enhet från utvecklarens molnbaserade servrar.
• När appen får fjärrmeddelandet visas den för användaren.
• När användaren interagerar med meddelandet får appen ett återanrop.

Några exempel på fjärrmeddelanden är:

• Nyhetsaviseringar.
• Sportuppdateringar.
• Snabbmeddelanden.

Det finns två typer av fjärrmeddelanden som är tillgängliga för en app:

• Användarläge: dessa visas för användaren på enheten.
• Tysta uppdateringar: dessa ger en mekanism för att uppdatera innehållet i en app i bakgrunden. När en tyst uppdatering tas emot kan appen kontakta fjärrservrarna för att hämta det senaste innehållet.

Mer information finns i Apples dokumentation om användarmeddelanden .

UIApplication API

Det är möjligt att använda UIApplication för att registrera ett meddelande med systemet och schemalägga hur meddelandet ska utlösas – antingen efter tid eller plats (det här var det ursprungliga API:et som tillhandahölls för användarmeddelanden från Apple).

Det finns dock flera problem som en utvecklare kan stöta på när de arbetar med det befintliga meddelandet enligt UIApplication:

• Det finns olika återanrop som krävs för lokala eller fjärranslutna meddelanden som kan leda till duplicering av kod.
• Appen har begränsad kontroll över meddelandet efter att det schemalagts med systemet.
• Det finns olika stödnivåer för alla Apples befintliga plattformar.

Om ramverket för användarmeddelanden

För att förbättra upplevelsen av meddelanden introducerade Apple ramverket Användarmeddelanden, som ersätter den befintliga UIApplication-metoden som anges ovan.

Ramverket för användarmeddelanden innehåller följande:

• Ett välbekant API som innehåller funktionsparitet med de tidigare metoderna, vilket gör det enkelt att portkoda från det befintliga ramverket.
• Innehåller en utökad uppsättning innehållsalternativ som gör att fler meddelanden kan skickas till användaren.
• Både lokala och fjärranslutna meddelanden kan hanteras med samma kod och återanrop.
• Förenklar processen för hantering av återanrop som skickas till en app när användaren interagerar med ett meddelande.
• Förbättrad hantering av både väntande och levererade meddelanden, inklusive möjligheten att ta bort eller uppdatera meddelanden.
• Lägger till möjligheten att göra en presentation av meddelanden i appen.
• Lägger till möjligheten att schemalägga och hantera meddelanden inifrån apptillägg.
• Lägger till en ny tilläggspunkt för själva meddelandena.

Ramverket för användarmeddelanden tillhandahåller ett enhetligt meddelande-API på flera av de plattformar som Apple stöder, inklusive:

• iOS: Fullständigt stöd för att hantera och schemalägga meddelanden.
• tvOS: Lägger till möjligheten att märka appikoner för lokala meddelanden och fjärrmeddelanden.
• Mac Catalyst: Fullständigt stöd för att hantera och schemalägga meddelanden.
• macOS: Fullständigt stöd för att hantera och schemalägga meddelanden.

Mer information finns i Apples användaraviseringar och användaraviseringars användargränssnittsdokumentation .

Förbereda för meddelandeleverans

Innan en app kan skicka meddelanden till användaren måste appen vara registrerad i systemet och eftersom ett meddelande är ett avbrott för användaren måste en app uttryckligen begära behörighet innan den skickas.

Det finns tre olika nivåer av meddelandebegäranden som användaren kan godkänna för en app:

• Banderoll visas.
• Ljudaviseringar.
• Förse appikonen med ett märke.

Dessutom måste dessa godkännandenivåer begäras och anges för både lokala och fjärranslutna meddelanden.

Meddelandebehörighet bör begäras så snart appen startas genom att lägga till följande kod i FinishedLaunching metoden AppDelegate för och ange önskad meddelandetyp (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;
}

I macOS gör du det i implementeringen 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)
    });
}

Dessutom kan en användare alltid ändra meddelandebehörigheterna för en app när som helst med hjälp av appen Inställningar på enheten. Appen bör söka efter användarens begärda meddelandebehörigheter innan ett meddelande visas med hjälp av följande kod:

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

Aktivera bakgrundsmeddelanden

För att appen ska kunna ta emot bakgrundsmeddelanden måste den aktivera bakgrundsläget för fjärrmeddelanden till appen.

Detta görs genom att lägga till en remote-notifications post i matrisen UIBackgroundModes i projektets Info.plist-fil , så här:

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

Konfigurera miljön för fjärrmeddelanden

Utvecklaren måste informera operativsystemet om vilken miljö push-avisering som körs i som antingen development eller production. Om du inte anger den här informationen kan det leda till att appen avvisas när den skickas till App Store med ett meddelande som liknar följande:

Stöd för push-meddelanden saknas – Appen innehåller ett API för Apples push-meddelandetjänst, men rättigheten aps-environment saknas i appens signatur.

Gör följande för att tillhandahålla den behörighet som krävs:

1. Öppna projektfilen i valfri textredigerare.

2. Ange två CustomEntitlements objekt, så här:

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

   Obs! Om du använder en annan konfiguration än Release för att publicera till App Store uppdaterar du villkoren i enlighet med detta.

Tillhandahållande

Behörigheten aps-environment från föregående avsnitt kräver användning av en försörjningsprofil med funktionen Push Notifications.

1. Gå till avsnittet Identifierare på Webbplatsen Apple Developer :

   

2. Lägg till en ny identifierare (Registrera en ny identifierare):

   

3. Välj typ av app:

   

4. Ange paketidentifieraren och beskrivningen för den nya appidentifieraren:

   

5. Aktivera funktionen Push Notifications :

   

6. Klicka på Register för att spara den nya appens identifierare.

Nästa steg är att skapa en etableringsprofil för den nya appidentifieraren:

1. Gå till avsnittet Profiler på Webbplatsen Apple Developer :

   

2. Lägg till en ny profil för iOS App Development:

   

3. Välj det app-ID som vi nyss skapade:

   

4. Välj alla certifikat som ingår i den här etableringsprofilen (ett nytt certifikat måste skrivas in om inget har skapats ännu):

   

5. Välj alla enheter som ingår i den här etableringsprofilen (appen kan bara installeras på dessa enheter).

   

6. Välj ett namn för konfigurationsprofilen och granska den:

   Granska och namnge

7. Generera och ladda ned den nya etableringsprofilen.

   

8. Öppna den nedladdade etableringsprofilfilen i Xcode (genom att dubbelklicka på den i Finder) för att installera den i systemet.

9. Konfigurera projektet för att använda den nyligen skapade etableringsprofilen genom att ange CodesignProvision egenskapen till namnet på etableringsprofilen från steg 6:

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

Registrera dig för fjärrmeddelanden

Om appen skickar och tar emot fjärrmeddelanden måste den fortfarande göra tokenregistrering med hjälp av det befintliga API:et för UIApplication . Den här registreringen kräver att enheten har en live-nätverksanslutning för åtkomst till API:er, vilket genererar den nödvändiga token som ska skickas till appen. Appen måste sedan vidarebefordra denna token till utvecklarens app på serversidan för att registrera sig för fjärrmeddelanden:

Använd följande kod för att initiera den nödvändiga registreringen:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Den token som skickas till utvecklarens app på serversidan måste inkluderas som en del av aviseringsnyttolasten som skickas från servern till APN när du skickar ett fjärrmeddelande:

Token fungerar som den nyckel som kopplar samman meddelandet och den app som används för att öppna eller svara på meddelandet.

Mer information finns i Apples dokumentation om användarmeddelanden .

Meddelandeleverans

När appen är helt registrerad och de behörigheter som begärs från och beviljas av användaren är appen nu redo att skicka och ta emot meddelanden.

Tillhandahålla meddelandeinnehåll

Alla meddelanden innehåller både en rubrik och underrubrik som alltid visas med brödtexten i meddelandeinnehållet. Det finns också möjlighet att lägga till mediabilagor i meddelandeinnehållet.

Om du vill skapa innehållet i ett lokalt meddelande använder du följande kod:

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;

För fjärrmeddelanden liknar processen:

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

Schemaläggning när ett meddelande skickas

När innehållet i meddelandet har skapats måste appen schemalägga när meddelandet ska visas för användaren genom att ange en utlösare. Det finns fyra olika utlösartyper:

• Push-meddelande – används uteslutande med fjärrmeddelanden och utlöses när APN skickar ett meddelandepaket till appen som körs på enheten.
• Tidsintervall – Tillåter att ett lokalt meddelande schemaläggs från ett tidsintervall som börjar med nu och avslutar en viss framtida punkt. Till exempel:

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

• Kalenderdatum – Tillåter att lokala meddelanden schemaläggs för ett visst datum och en viss tid.
• Platsbaserad – Tillåter att lokala meddelanden schemaläggs när enheten anger eller lämnar en specifik geografisk plats eller är i en viss närhet till bluetooth-fyrar.

När ett lokalt meddelande är klart måste appen anropa UNUserNotificationCenter.AddNotificationRequest schemalägg visningen till användaren. För fjärrmeddelanden skickar appen på serversidan en nyttolast för meddelanden till APN:erna, som sedan skickar paketet vidare till användarens enhet.

Om du sammanför alla delar kan ett lokalt exempelmeddelande se ut så här:

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

Utlösa ett fjärrmeddelande

Det finns flera sätt att utlösa ett fjärrmeddelande under utvecklingen för testning:

• Apples push-meddelandekonsol
• Kommandoradsverktyg
• Andra lösningar från tredje part.

När appen har släppts utlöses vanligtvis fjärrmeddelanden från appar på serversidan.

Hantera aviseringar om förgrundsappar

En app kan hantera meddelanden på olika sätt när den är i förgrunden och ett meddelande utlöses. Genom att tillhandahålla en UNUserNotificationCenterDelegate och implementera metoden WillPresentNotification kan appen ta över ansvaret för att visa meddelandet. Till exempel:

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
}

Den här koden skriver helt enkelt ut innehållet i UNNotification till programutdata och ber systemet att visa standardaviseringen för meddelandet.

Om appen vill visa själva meddelandet när det var i förgrunden och inte använda systemets standardvärden skickar du Ingen till slutförandehanteraren. Exempel:

completionHandler (UNNotificationPresentationOptions.None);

Med den här koden på plats öppnar du AppDelegate.cs filen för redigering och ändrar metoden så att den FinishedLaunching ser ut så här:

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

Den här koden kopplar den anpassade UNUserNotificationCenterDelegate ovanifrån till det aktuella UNUserNotificationCenter så att appen kan hantera meddelanden medan den är aktiv och i förgrunden.

Meddelandehantering

Meddelandehantering ger åtkomst till både väntande och levererade meddelanden och lägger till möjligheten att ta bort, uppdatera eller höja upp dessa meddelanden.

En viktig del av meddelandehanteringen är den begärandeidentifierare som tilldelades meddelandet när det skapades och schemalades med systemet. För fjärrmeddelanden tilldelas detta via fältet apps-collapse-id i HTTP-begärandehuvudet.

Begärandeidentifieraren används för att välja det meddelande som appen vill utföra meddelandehantering på.

Ta bort meddelanden

Om du vill ta bort ett väntande meddelande från systemet använder du följande kod:

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

Om du vill ta bort ett redan levererat meddelande använder du följande kod:

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

Uppdatera ett befintligt meddelande

Om du vill uppdatera ett befintligt meddelande skapar du bara ett nytt meddelande med önskade parametrar ändrade (till exempel en ny utlösartid) och lägger till det i systemet med samma begärandeidentifierare som meddelandet som måste ändras. Exempel:

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

För redan levererade meddelanden uppdateras det befintliga meddelandet och höjs upp överst i listan på start- och låsskärmarna och i Meddelandecenter om det redan har lästs av användaren.

Arbeta med meddelandeåtgärder

Meddelanden som levereras till användaren är inte statiska och ger flera sätt som användaren kan interagera med dem (från inbyggda till anpassade åtgärder).

Det finns tre typer av åtgärder som en app kan svara på:

• Standardåtgärd – Det här är när användaren trycker på ett meddelande för att öppna appen och visa information om det angivna meddelandet.
• Anpassade åtgärder – Dessa ger ett snabbt sätt för användaren att utföra en anpassad uppgift direkt från meddelandet utan att behöva starta appen. De kan visas som antingen en lista med knappar med anpassningsbara rubriker eller ett textinmatningsfält som kan köras antingen i bakgrunden (där appen ges en liten tid för att uppfylla begäran) eller förgrunden (där appen startas i förgrunden för att uppfylla begäran).
• Avvisa åtgärd – Den här åtgärden skickas till appen när användaren avvisar ett visst meddelande.

Skapa anpassade åtgärder

Om du vill skapa och registrera en anpassad åtgärd med systemet använder du följande kod:

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

När du skapar en ny UNNotificationAction tilldelas den en unik identifierare och rubriken som visas på knappen. Som standard skapas åtgärden som en bakgrundsåtgärd, men du kan ange alternativ för att justera åtgärdens beteende (till exempel att ange att åtgärden ska vara en förgrundsåtgärd).

Var och en av de åtgärder som skapas måste associeras med en kategori. När du skapar en ny UNNotificationCategory tilldelas den en unik identifierare, en lista över åtgärder som den kan utföra, en lista över avsiktsidentifierare för att ge mer information om avsikten med åtgärderna i kategorin och några alternativ för att kontrollera beteendet för kategorin.

Slutligen registreras alla kategorier i systemet med metoden SetNotificationCategories .

Presentera anpassade åtgärder

När en uppsättning anpassade åtgärder och kategorier har skapats och registrerats med systemet kan de visas från lokala meddelanden eller fjärrmeddelanden.

För fjärrmeddelanden anger du en category i nyttolasten för fjärrmeddelanden som matchar en av kategorierna som skapats ovan. Till exempel:

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

För lokala meddelanden anger du CategoryIdentifier objektets UNMutableNotificationContent egenskap. Till exempel:

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

Återigen måste den här identifieraren matcha en av de kategorier som skapades ovan.

Hantera avvisande åtgärder

Som nämnts ovan kan en avvisande åtgärd skickas till appen när användaren avvisar ett meddelande. Eftersom detta inte är en standardåtgärd måste ett alternativ anges när kategorin skapas. Till exempel:

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

Hantera åtgärdssvar

När användaren interagerar med de anpassade åtgärder och kategorier som skapades ovan måste appen uppfylla den begärda uppgiften. Detta görs genom att tillhandahålla en [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] och implementera metoden DidReceiveNotificationResponse . Till exempel:

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

Den skickade UNNotificationResponse klassen har en ActionIdentifier egenskap som antingen kan vara standardåtgärden eller avvisandeåtgärden. Använd response.Notification.Request.Identifier för att testa eventuella anpassade åtgärder.

Egenskapen UserText innehåller värdet för alla indata för användartext. Egenskapen Notification innehåller det ursprungliga meddelandet som innehåller begäran med utlösaren och meddelandeinnehållet. Appen kan avgöra om det var ett lokalt eller fjärranslutet meddelande baserat på typen av utlösare.

Arbeta med Notification Service-tillägg

När du arbetar med fjärrmeddelanden tillhandahåller ett meddelandetjänsttillägg ett sätt att aktivera kryptering från slutpunkt till slutpunkt i meddelandenyttolasten. Ett Notification Service-tillägg är ett tillägg för icke-användargränssnitt som körs i bakgrunden med huvudsyftet att utöka eller ersätta det synliga innehållet i ett meddelande innan det visas för användaren.

Notification Service extensions är avsedda att köras snabbt och ges bara en kort tid för att utföras av systemet. Om notification service-tillägget inte kan slutföra sin uppgift under den tilldelade tidsperioden anropas en återställningsmetod. Om återställningen misslyckas visas det ursprungliga meddelandeinnehållet för användaren.

Några möjliga användningsområden för Notification Service-tillägg är:

• Tillhandahålla kryptering från slutpunkt till slutpunkt för fjärrmeddelandeinnehållet.
• Lägga till bifogade filer i fjärrmeddelanden för att utöka dem.

Implementera ett notification service-tillägg

Gör följande för att implementera ett Notification Service-tillägg i en app:

1. Skapa en ny mapp för tilläggsprojektet bredvid huvudprojektets mapp. Följande instruktioner förutsätter att den nya mappen heter MyNotificationServiceExtension.

2. Öppna en terminal och kör:

   dotnet new ios-notification-service-extension
   

3. Öppna huvudprojektets projektfil och lägg till:

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

4. Bygg nu huvudprojektet och tilläggsprojektet kommer också att skapas och ingå i det slutliga apppaketet.

Det finns en huvudklass i notification service-tillägget som måste ändras för att tillhandahålla de funktioner som krävs. Till exempel:

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

Den första metoden DidReceiveNotificationRequest kommer att ta emot meddelandeidentifieraren samt meddelandeinnehållet via request-objektet. Den överförda contentHandler måste anropas för att kunna presentera meddelandet för användaren.

Den andra metoden , TimeWillExpire, anropas precis innan tiden håller på att ta slut för notification service-tillägget för att bearbeta begäran. Om tillägget för notifieringstjänsten inte anropar contentHandler inom den angivna tiden visas det ursprungliga innehållet för användaren.

Utlösa ett notification service-tillägg

När ett Notification Service-tillägg har skapats och levererats med appen kan det utlösas genom att ändra den fjärraviseringsnyttolast som skickas till enheten. Till exempel:

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

Den nya mutable-content nyckeln anger att notification service-tillägget måste startas för att uppdatera fjärrmeddelandeinnehållet. Nyckeln encrypted-content innehåller krypterade data som Notification Service-tillägget kan dekryptera innan de presenteras för användaren.

Ta en titt på följande exempel på notification service-tillägget:

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

Den här koden dekrypterar det krypterade innehållet från encrypted-content nyckeln, skapar en ny UNMutableNotificationContent, anger egenskapen Body till det dekrypterade innehållet och använder contentHandler för att presentera meddelandet för användaren.

Se även

• iOS-exempel
• Referens för UserNotifications Framework
• UserNotificationsUI
• Programmeringsguide för lokala meddelanden och fjärrmeddelanden
• Anpassa utseendet på meddelanden