Felhasználói értesítések

A Felhasználói értesítések keretrendszer lehetővé teszi a helyi és távoli értesítések kézbesítését és kezelését. Ennek a keretrendszernek a használatával egy alkalmazás vagy alkalmazásbővítmény ütemezheti a helyi értesítések kézbesítését olyan feltételek megadásával, mint például a hely vagy a nap időpontja.

Emellett az alkalmazás vagy a bővítmény helyi és távoli értesítéseket is fogadhat (és módosíthat) a felhasználó eszközére való kézbesítéskor.

A Felhasználói értesítés felhasználói felület keretrendszere lehetővé teszi, hogy egy alkalmazás vagy alkalmazásbővítmény testre szabja mind a helyi, mind a távoli értesítések megjelenését, amikor azok megjelennek a felhasználó számára.

Ez a keretrendszer a következő módszereket biztosítja, amelyekkel egy alkalmazás értesítéseket tud küldeni egy felhasználónak:

• Vizuális riasztások: ahol az értesítés szalagcímként a képernyő tetejéről legördül.
• Hang és rezgések: egy értesítéshez társíthatók.
• Alkalmazásikon-értesítés: ami azt jelzi, hogy új tartalom érhető, például az olvasatlan e-mailek száma.

Emellett a felhasználó aktuális környezetétől függően különböző módokon jelenik meg az értesítés:

• Ha az eszköz fel van oldva, az értesítés bannerként gördül le a képernyő tetejéről.
• Ha az eszköz zárolva van, az értesítés megjelenik a felhasználó zárolási képernyőjén.
• Ha a felhasználó elmulasztott egy értesítést, megnyithatja az Értesítési központot, és megtekintheti az elérhető, várakozó értesítéseket.

Az alkalmazások kétféle felhasználói értesítést küldhetnek:

• Helyi értesítések: ezeket a felhasználói eszközön helyileg telepített alkalmazások küldik el.
• Távoli értesítések: távoli kiszolgálóról érkeznek, és vagy megjelennek a felhasználónak, vagy elindítják az alkalmazás tartalmának háttérfrissítését.

Tudnivalók a helyi értesítésekről

Az alkalmazások által elküldhető helyi értesítések a következő funkciókkal és attribútumokkal rendelkeznek:

• Ezeket a felhasználó eszközén helyi alkalmazások küldik el.
• Ezek idő- vagy helyalapú eseményindítók használatára konfigurálhatók.
• Az alkalmazás ütemezi az értesítést a felhasználó eszközével, és akkor jelenik meg, amikor az eseményindító feltétel teljesül.
• Amikor a felhasználó egy értesítéssel kommunikál, az alkalmazás visszahívást kap.

Néhány példa a helyi értesítésekre:

• Naptárriasztások.
• Emlékeztető riasztások.
• Helyérzékeny eseményindítók.

További információkért tekintse meg az Apple Felhasználói értesítések dokumentációját.

Tudnivalók a távoli értesítésekről

Az alkalmazások által küldött távoli értesítések a következő funkciókkal és attribútumokkal rendelkeznek:

• Az alkalmazás egy kiszolgálóoldali összetevővel rendelkezik, amellyel kommunikál.
• Az Apple Leküldéses értesítési szolgáltatás (APN-ek) használatával a rendszer a távoli értesítések lehető leghatékonyabb kézbesítését továbbítja a felhasználó eszközére a fejlesztő felhőalapú kiszolgálóiról.
• Amikor az alkalmazás megkapja a távoli értesítést, az megjelenik a felhasználó számára.
• Amikor a felhasználó interakcióba lép az értesítéssel, az alkalmazás visszahívást kap.

Néhány példa a távoli értesítésekre:

• Hírriasztások.
• Sportfrissítések.
• Csevegőüzenetek.

Az alkalmazások kétféle távértesítést érhetnek el:

• Felhasználói felület: ezek jelennek meg a felhasználó számára az eszközön.
• Csendes frissítések: ezek lehetővé teszik az alkalmazás tartalmának frissítését a háttérben. Csendes frissítés érkezésekor az alkalmazás kapcsolatba lép a távoli kiszolgálókkal, hogy lekérje a legújabb tartalmat.

További információkért tekintse meg az Apple Felhasználói értesítések dokumentációját.

UIApplication API

A UIApplication használatával regisztrálhat egy értesítést a rendszeren, és ütemezheti az értesítés aktiválásának módját – idő vagy hely szerint (ez volt az Apple által a felhasználói értesítésekhez biztosított eredeti API).

A fejlesztő azonban több problémát is tapasztalhat, amikor az UIApplication által megadott meglévő értesítéssel dolgozik:

• A helyi vagy távoli értesítésekhez különböző visszahívások szükségesek, amelyek a kód duplikálásához vezethetnek.
• Az alkalmazás korlátozott ellenőrzéssel rendelkezik az értesítés felett, miután az rendszeren keresztül ütemezték.
• Az Apple összes meglévő platformján különböző szintű támogatás érhető el.

Tudnivalók a Felhasználói értesítések keretrendszerről

Az értesítések felhasználói élményének javítása érdekében az Apple bevezette a Felhasználói értesítések keretrendszert, amely felváltja a már meglévő UIApplication metódust.

A Felhasználói értesítések keretrendszer a következőket biztosítja:

• Egy jól ismert API, amely a korábbi metódusokkal együtt tartalmazza a funkciók paritását, így a meglévő keretrendszerből egyszerűen portkódokat portozhat.
• Bővített tartalombeállításokat tartalmaz, amelyek lehetővé teszik, hogy részletesebb értesítéseket küldhessenek a felhasználónak.
• A helyi és a távoli értesítéseket is ugyanazzal a kóddal és visszahívással lehet kezelni.
• Leegyszerűsíti az alkalmazásnak küldött visszahívások kezelését, amikor a felhasználó egy értesítéssel kommunikál.
• A függőben lévő és a kézbesített értesítések továbbfejlesztett kezelése, beleértve az értesítések eltávolításának vagy frissítésének lehetőségét.
• Lehetővé teszi az értesítések alkalmazáson belüli megjelenítését.
• Lehetővé teszi az alkalmazásbővítményeken belüli értesítések ütemezését és kezelését.
• Új bővítménypontot ad hozzá az értesítésekhez.

A Felhasználói értesítések keretrendszer az Apple által támogatott platformokon egységes értesítési API-t biztosít, beleértve a következőket:

• iOS: Teljes körű támogatás az értesítések kezeléséhez és ütemezéséhez.
• tvOS: Lehetővé teszi az alkalmazásikonok jelvényét helyi és távoli értesítésekhez.
• Mac Catalyst: Teljes körű támogatás az értesítések kezeléséhez és ütemezéséhez.
• macOS: Teljes körű támogatás az értesítések kezeléséhez és ütemezéséhez.

További információkért tekintse meg az Apple felhasználói értesítéseinek és felhasználói értesítéseinek felhasználói felületének dokumentációját.

Felkészülés az értesítés kézbesítésére

Ahhoz, hogy egy alkalmazás értesítéseket küldjön a felhasználónak, az alkalmazást regisztrálni kell a rendszerben, és mivel az értesítés a felhasználó számára megszakítást jelent, az alkalmazásnak kifejezetten engedélyt kell kérnie, mielőtt elküldené őket.

Az értesítési kérelmek három különböző szintje van, amelyeket a felhasználó jóváhagyhat egy alkalmazáshoz:

• A banner megjelenik.
• Hangjelzések.
• Az alkalmazás ikon megjelölése.

Ezenkívül ezeket a jóváhagyási szinteket helyi és távoli értesítésekhez is meg kell kérni és be kell állítani.

Az értesítési engedélyt az alkalmazás elindításakor azonnal meg kell kérni, ha hozzáadja a következő kódot a FinishedLaunchingAppDelegate metódushoz, és beállítja a kívánt értesítési típust (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;
}

MacOS rendszeren a megvalósítás során DidFinishLaunching tegye:

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

Megjegyzés:

a macOS- és Mac Catalyst-alkalmazásokat alá kell írni ahhoz, hogy az engedély párbeszédpanel megjelenjen, még akkor is, ha helyileg, hibakeresési módban építkeznek. Állítsa be az EnableCodeSigning tulajdonságot a projektfájlban true az alkalmazás aláírásának kényszerítéséhez.

Emellett a felhasználó bármikor módosíthatja az alkalmazás értesítési jogosultságait az eszközön található Beállítások alkalmazással. Az alkalmazásnak ellenőriznie kell a felhasználó kért értesítési jogosultságait, mielőtt az alábbi kóddal jelenítené meg az értesítést:

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

Háttérértesítések engedélyezése

Ahhoz, hogy az alkalmazás háttérértesítéseket kapjon, engedélyeznie kell a távoli értesítések háttérmódját az alkalmazás számára.

Ezt úgy végezheti el, hogy hozzáad egy bejegyzést remote-notifications a UIBackgroundModes tömbhöz a projekt Info.plist fájljában, az alábbi módon:

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

A távoli értesítési környezet konfigurálása

A fejlesztőnek tájékoztatnia kell az operációs rendszert arról, hogy a leküldéses értesítések milyen környezetben futnak, mint development vagy production. Ha nem adja meg ezeket az információkat, az alkalmazás elutasításához vezethet, ha az App Store-ba az alábbihoz hasonló értesítéssel küldi el az alkalmazást:

Hiányzó leküldéses értesítési jogosultság – Az alkalmazás tartalmaz egy API-t az Apple leküldéses értesítési szolgáltatásához, de a aps-environment jogosultság hiányzik az alkalmazás aláírásából.

A szükséges jogosultság megadásához tegye a következőket:

1. Nyissa meg a projektfájlt a választott szövegszerkesztőben.

2. Írjon be két CustomEntitlements elemet, például:

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

   Megjegyzés: ha más konfigurációt használ, mint Release az App Store-ban való közzétételhez, frissítse a feltételeket ennek megfelelően.

Megjegyzés:

A aps-environmentJogosultságok.plist fájlban is beállítható, ami a korábbiakban így történt. A projektfájl használatának előnye, hogy egyszerűbb automatikusan használni a jogosultság megfelelő értékét, development vagy productiona buildkonfigurációtól függően.

Ellátás

Az aps-environment előző szakasz jogosultságához egy kiépítési profilt kell használnia a Push Notifications következő képességgel:

1. Nyissa meg az Apple Fejlesztői webhely Azonosítók szakaszát:

   

2. Új azonosító hozzáadása (új azonosító regisztrálása):

   

3. Válassza ki az "Alkalmazás" típust:

   

4. Adja meg az új alkalmazásazonosító csomagazonosítóját és leírását:

   

5. Engedélyezze a Push Notifications képességet:

   

6. Kattintson a Register gombra az új alkalmazásazonosító mentéséhez.

A következő lépés egy kiépítési profil létrehozása az új alkalmazásazonosítóhoz:

1. Nyissa meg az Apple Fejlesztői webhely Profilok szakaszát:

   

2. Új profil hozzáadása az iOS-alkalmazásfejlesztéshez:

   

3. Válassza ki az imént létrehozott alkalmazásazonosítót:

   

4. Válassza ki az ebben a kiépítési profilban szereplő összes tanúsítványt (új tanúsítványt kell létrehozni, ha még nincs létrehozva):

   

5. Válassza ki a kiépítési profilban szereplő összes eszközt (az alkalmazás csak ezeken az eszközökön telepíthető).

   

6. Válasszon nevet a kiépítési profilnak, és tekintse át:

   

7. Hozza létre és töltse le az új kiépítési profilt.

   

8. Nyissa meg a letöltött kiépítési profilfájlt az Xcode-ban (kattintson rá duplán a Finderben) a rendszerbe való telepítéshez.

9. Konfigurálja a projektet az újonnan létrehozott kiépítési profil használatára úgy, hogy a CodesignProvision tulajdonságot a 6. lépésben a kiépítési profil nevére állítja:

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

Megjegyzés:

Ha az alkalmazás rendelkezik értesítésekkel foglalkozó alkalmazásbővítményekkel, ezt a folyamatot meg kell ismételni minden alkalmazáskiterjesztési projekt esetében – mindegyiknek saját alkalmazásazonosítóval és kiépítési profillal kell rendelkeznie.

Távoli értesítések regisztrálása

Ha az alkalmazás távoli értesítéseket küld és fogad, akkor is jogkivonat-regisztrációt kell végeznie a meglévő UIApplication API használatával. Ehhez a regisztrációhoz az eszköznek élő hálózati kapcsolattal kell rendelkeznie az APN-ekhez való hozzáféréshez, amely létrehozza a szükséges jogkivonatot, amelyet elküld az alkalmazásnak. Az alkalmazásnak ezután továbbítania kell ezt a jogkivonatot a fejlesztő kiszolgálóoldali alkalmazásának, hogy regisztráljon a távoli értesítésekre:

A szükséges regisztráció inicializálásához használja a következő kódot:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

A fejlesztő kiszolgálóoldali alkalmazásának küldött jogkivonatot a kiszolgálóról az APN-eknek küldött értesítési hasznos adatok részeként kell tartalmaznia, amikor távoli értesítést küld:

A jogkivonat az értesítés és az értesítés megnyitásához vagy megválaszolásához használt alkalmazás összekapcsolásához használt kulcs.

További információkért tekintse meg az Apple Felhasználói értesítések dokumentációját.

Értesítés kézbesítése

Az alkalmazás teljes regisztrációja és a felhasználó által kért és megadott szükséges engedélyek birtokában az alkalmazás készen áll az értesítések küldésére és fogadására.

Értesítési tartalom megadása

Minden értesítés tartalmaz egy címet és egy alcímet is, amely mindig megjelenik az értesítési tartalom törzsével együtt. Emellett médiamellékleteket is hozzáadhat az értesítési tartalomhoz.

Helyi értesítés tartalmának létrehozásához használja a következő kódot:

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;

Távoli értesítések esetén a folyamat hasonló:

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

Ütemezés értesítés küldésekor

Az értesítés tartalmának létrehozásakor az alkalmazásnak ütemeznie kell, hogy mikor jelenik meg az értesítés a felhasználó számára egy eseményindító beállításával. Négy különböző triggertípus létezik:

• Leküldéses értesítés – Kizárólag távoli értesítésekhez használható, és akkor aktiválódik, amikor az APN-ek egy értesítési csomagot küldenek az eszközön futó alkalmazásnak.
• Időintervallum – Lehetővé teszi egy helyi értesítés ütemezését az időintervallumból kezdve a következő időpontig. Például:

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

• Naptárdátum – Lehetővé teszi a helyi értesítések ütemezését egy adott dátumra és időpontra.
• Helyalapú – Lehetővé teszi a helyi értesítések ütemezését, amikor az eszköz egy adott földrajzi helyre lép be, vagy elhagy egy adott helyet, vagy a Bluetooth-jelzők adott közelében van.

Ha egy helyi értesítés készen áll, az alkalmazásnak meg kell hívnia az UNUserNotificationCenter.AddNotificationRequest parancsot , hogy megjelenítse a felhasználót. Távoli értesítések esetén a kiszolgálóoldali alkalmazás egy hasznos adatcsomagot küld az APN-eknek, majd elküldi a csomagot a felhasználó eszközére.

Az összes darab összehozása esetén a helyi mintaértesítések a következőképpen nézhetnek ki:

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

Távoli értesítés aktiválása

A teszteléshez többféleképpen is aktiválhat távoli értesítést a fejlesztés során:

• Az Apple push értesítési konzolja
• Parancssori eszközök
• Egyéb külső megoldások.

Az alkalmazás kiadása után a távoli értesítések általában kiszolgálóoldali alkalmazásokból aktiválódnak.

Előtérben lévő alkalmazásértesítések kezelése

Az alkalmazások másképp kezelhetik az értesítéseket, ha az előtérben van, és egy értesítés aktiválódik. Az UNUserNotificationCenterDelegate biztosításával és a WillPresentNotification metódus implementálásával az alkalmazás átveheti az értesítés megjelenítésének felelősségét. Például:

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
}

Ez a kód egyszerűen kiírja a unNotification tartalmát az alkalmazás kimenetének, és megkéri a rendszert, hogy jelenítse meg az értesítés szabványos riasztását.

Ha az alkalmazás meg szeretné jeleníteni magát az értesítést, amikor az előtérben volt, és nem használja a rendszer alapértelmezéseit, adja át a Nincs elemet a befejezési kezelőnek. Példa:

completionHandler (UNNotificationPresentationOptions.None);

Ezzel a kóddal nyissa meg a AppDelegate.cs fájlt szerkesztésre, és változtassa meg a FinishedLaunching metódust, hogy a következők szerint nézzen ki:

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

Ez a kód az egyéni UNUserNotificationCenterDelegate-et csatolja felülről az aktuális UNUserNotificationCenterhez , hogy az alkalmazás kezelni tudja az értesítéseket, miközben aktív és előtérben van.

Értesítéskezelés

Az értesítéskezelés hozzáférést biztosít mind a függőben lévő, mind a kézbesített értesítésekhez, és lehetővé teszi az értesítések eltávolítását, frissítését vagy előléptetését.

Az értesítéskezelés fontos része az értesítéshez hozzárendelt kérésazonosító, amelyet a rendszer létrehozott és ütemezett. Távoli értesítések esetén ez a apps-collapse-id HTTP-kérelem fejlécében található mezőn keresztül van hozzárendelve.

A kérésazonosítóval kiválaszthatja azt az értesítést, amelyen az alkalmazás értesítéskezelést kíván végezni.

Értesítések eltávolítása

Ha el szeretne távolítani egy függőben lévő értesítést a rendszerből, használja a következő kódot:

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

Egy már kézbesített értesítés eltávolításához használja a következő kódot:

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

Meglévő értesítés frissítése

Meglévő értesítés frissítéséhez egyszerűen hozzon létre egy új értesítést a kívánt paraméterek módosításával (például egy új eseményindító időponttal), és adja hozzá a rendszerhez ugyanazzal a kérésazonosítóval, mint a módosítani kívánt értesítés. Példa:

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

A már kézbesített értesítések esetében a meglévő értesítés frissül és előléptetve jelenik meg a Kezdőlap és a Zárolás képernyők listájának tetején, illetve az Értesítési központban, ha a felhasználó már elolvasta.

Értesítési műveletek használata

A felhasználónak küldött értesítések nem statikusak, és számos módot kínálnak arra, hogy a felhasználó kommunikáljon velük (a beépítetttől az egyéni műveletekig).

Az alkalmazások háromféle műveletre válaszolhatnak:

• Alapértelmezett művelet – Ekkor a felhasználó egy értesítésre koppintva megnyitja az alkalmazást, és megjeleníti az adott értesítés részleteit.
• Egyéni műveletek – Ezek gyors módot biztosítanak arra, hogy a felhasználó közvetlenül az értesítésből hajtson végre egyéni feladatot anélkül, hogy el kellene indítania az alkalmazást. Megjeleníthetők testre szabható címmel rendelkező gombok listájaként vagy szövegbeviteli mezőként, amely a háttérben futtatható (ahol az alkalmazás kis időt kap a kérés teljesítésére) vagy az előtérben (ahol az alkalmazás az előtérben indul el a kérés teljesítéséhez).
• Művelet elvetése – Ezt a műveletet a rendszer elküldi az alkalmazásnak, amikor a felhasználó elutasít egy adott értesítést.

Egyéni műveletek létrehozása

Ha egyéni műveletet szeretne létrehozni és regisztrálni a rendszerben, használja a következő kódot:

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

Új UNNotificationAction létrehozásakor a rendszer egy egyedi azonosítót és a gombon megjelenő címet rendeli hozzá. Alapértelmezés szerint a művelet háttérműveletként lesz létrehozva, de a művelet viselkedésének módosításához (például előtérműveletként) megadható beállítások.

Minden létrehozott műveletet egy kategóriához kell társítani. Új UNNotificationCategory létrehozásakor egyedi azonosítót, az általa végrehajtható műveletek listáját, a szándékazonosítókat tartalmazó listát kap, amely további információt nyújt a kategória műveleteinek szándékáról, valamint a kategória viselkedésének szabályozására vonatkozó néhány lehetőséget.

Végül az összes kategória a SetNotificationCategories metódussal van regisztrálva a rendszerben.

Egyéni műveletek bemutatása

Miután egy egyéni művelet- és kategóriakészletet hozott létre és regisztrált a rendszerben, azok helyi vagy távoli értesítésekből is megjeleníthetők.

Távoli értesítések esetén adjon meg a távoli értesítés hasznos adatában egy category-t, amely megfelel a fent létrehozott kategóriák egyikének. Például:

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

Helyi értesítések esetén állítsa be az CategoryIdentifier objektum tulajdonságát UNMutableNotificationContent . Például:

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

Ennek az azonosítónak ismét meg kell egyeznie a fent létrehozott kategóriák egyikével.

Elbocsátási műveletek kezelése

Ahogy fentebb említettük, a felhasználó értesítésének elutasítása után el lehet küldeni az alkalmazásnak az elbocsátási műveletet. Mivel ez nem egy szokásos művelet, a kategória létrehozásakor be kell állítani egy beállítást. Például:

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

Műveletválaszok kezelése

Amikor a felhasználó interakcióba lép a fent létrehozott egyéni műveletekkel és kategóriákkal, az alkalmazásnak teljesítenie kell a kért feladatot. Ez egy [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] megadásával és a DidReceiveNotificationResponse metódus implementálásával történik. Például:

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

Az átadott UNNotificationResponse osztálynak van egy ActionIdentifier tulajdonsága, amely lehet az alapértelmezett művelet vagy az elbocsátási művelet. Az egyéni műveletek tesztelésére használható response.Notification.Request.Identifier .

A UserText tulajdonság a felhasználói szövegbevitel értékét tartalmazza. A Notification tulajdonság tartalmazza a kezdeményező értesítést, amely tartalmazza a kérelmet az eseményindítóval és az értesítés tartalmával. Az alkalmazás eldöntheti, hogy helyi vagy távoli értesítés volt-e az eseményindító típusa alapján.

Értesítési szolgáltatás bővítményeinek használata

Ha távoli értesítéseket használ, az Értesítési szolgáltatás bővítménye lehetővé teszi a végpontok közötti titkosítást az értesítés hasznos adatai között. A Notification Service-bővítmények olyan nem felhasználói felületi bővítmények, amelyek a háttérben futnak azzal a fő céllal, hogy kibővítse vagy lecserélje az értesítés látható tartalmát, mielőtt az megjelenik a felhasználó számára.

A Notification Service-bővítmények célja, hogy gyorsan fussanak, és csak rövid időt kapnak a rendszer általi végrehajtásra. Abban az esetben, ha a Notification Service-bővítmény nem tudja elvégezni a feladatot a megadott idő alatt, a rendszer tartalék metódust hív meg. Ha a tartalék nem sikerül, az eredeti értesítési tartalom megjelenik a felhasználó számára.

A Notification Service-bővítmények néhány lehetséges felhasználási módja:

• A távoli értesítési tartalom végpontok közötti titkosításának biztosítása.
• Mellékletek hozzáadása távoli értesítésekhez, hogy bővítse őket.

Notification Service-bővítmény implementálása

A Notification Service-bővítmény alkalmazásbeli implementálásához tegye a következőket:

1. Hozzon létre egy új mappát a bővítményprojekthez a fő projekt mappája mellett. Az alábbi utasítások feltételezik, hogy az új mappa neve MyNotificationServiceExtension.

2. Nyisson meg egy terminált, és hajtsa végre a következőt:

   dotnet new ios-notification-service-extension
   

3. Nyissa meg a fő projekt projektfájlját, és adja hozzá a következőt:

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

4. Most hozza létre a fő projektet, és a bővítményprojekt is létrejön, és szerepel a végső alkalmazáscsomagban.

Fontos

Mivel a Mac és a csatlakoztatott eszközök közötti interakciót a Mac kezeli, jelenleg nem lehet hibakeresést végezni egy alkalmazásbővítményen egy hibakeresővel. További up-to-date információkért lásd még https://github.com/xamarin/xamarin-macios/issues/19484 .

Ez azt jelenti, hogy az alkalmazásbővítmények hibakeresésének legmegbízhatóbb módja sajnos a Console.WriteLine utasítások hozzáadása a kódhoz, majd ezeket az utasításokat keresni az eszköznaplóban.

Fontos

A szolgáltatásbővítmény csomagazonosítóját (ApplicationId) előtagként kell megadni a főalkalmazás csomagazonosítójával. Ha például a fő alkalmazás csomagazonosítóval com.xamarin.monkeynotifyrendelkezik, a szolgáltatásbővítménynek rendelkeznie kell a csomagazonosítóval com.xamarin.monkeynotify.monkeynotifyserviceextension.

A Notification Service bővítményben van egy fő osztály, amelyet módosítani kell a szükséges funkciók biztosításához. Például:

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

Az első metódus, a DidReceiveNotificationRequest az objektumon keresztül request átadja az értesítés azonosítóját és az értesítés tartalmát. Az átadott beküldést contentHandler meg kell hívni, hogy be lehessen mutatni az értesítést a felhasználónak.

A második metódus, a TimeWillExpire lesz meghívva, mielőtt az idő hamarosan elfogyna, hogy az Értesítési szolgáltatás bővítmény feldolgozhassa a kérést. Ha az Értesítési szolgáltatás bővítménye nem tudja meghívni a contentHandler megadott időtartamot, az eredeti tartalom megjelenik a felhasználó számára.

Értesítési szolgáltatás bővítményének aktiválása

Az alkalmazással létrehozott és kézbesített értesítésszolgáltatás-bővítmény úgy aktiválható, hogy módosítjuk a készülékre küldött távoli értesítés adathalmazát. Például:

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

Az új mutable-content kulcs azt határozza meg, hogy a értesítési szolgáltatás bővítményét el kell indítani a távoli értesítési tartalom frissítéséhez. A encrypted-content kulcs tartalmazza azokat a titkosított adatokat, amelyeket a Notification Service-bővítmény visszafejthet, mielőtt bemutatnák a felhasználónak.

Tekintse meg az alábbi Notification Service-bővítményt:

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

Ez a kód visszafejti a titkosított tartalmat a encrypted-content kulcsból, létrehoz egy új UNMutableNotificationContentet, beállítja a Body tulajdonságot a visszafejtett tartalomra, és az contentHandler értesítés a felhasználónak való bemutatására szolgál.

Lásd még

• iOS-minta
• UserNotifications-keretrendszer – referencia
• UserNotificationsUI
• Helyi és távoli értesítési programozási útmutató
• Az értesítések megjelenésének testreszabása