Oktatóanyag: Értesítések küldése adott felhasználóknak az Azure Notification Hubs használatával

  • Cikk

Áttekintés

Ez az oktatóanyag bemutatja, hogyan küldhet leküldéses értesítéseket egy adott alkalmazásfelhasználónak egy adott eszközön az Azure Notification Hubs használatával. Az ASP.NET WebAPI háttérrendszer az ügyfelek hitelesítésére szolgál. Amikor a háttérrendszer hitelesíti az ügyfélalkalmazás felhasználóját, automatikusan hozzáad egy címkét az értesítés regisztrációjához. A háttérrendszer ezt a címkét használja, hogy értesítéseket küldjön az adott felhasználónak.

Megjegyzés

Az oktatóanyag befejezett kódja megtalálható a GitHubon.

Ebben az oktatóanyagban a következő lépéseket hajtja végre:

  • A WebAPI-projekt létrehozása
  • Ügyfelek hitelesítése a WebAPI háttérrendszeren
  • Regisztráció értesítésekre a WebAPI háttérrendszer használatával
  • Értesítések küldése a WebAPI háttérrendszerről
  • Az új WebAPI háttérrendszer közzététele
  • Az ügyfélprojekt kódjának frissítése
  • Az alkalmazás tesztelése

Előfeltételek

Ez az oktatóanyag az Oktatóanyag: Értesítések küldése az Univerzális Windows-platformon alapuló alkalmazásoknak az Azure Notification Hubs használatával című oktatóanyagban létrehozott értesítési központra és Visual Studio-projektre épül. Ezért fejezze be azt az oktatóanyagot a jelen oktatóanyag elkezdése előtt.

Megjegyzés

Ha az Azure App Service Mobile Apps szolgáltatását használja háttérszolgáltatásként, az oktatóanyag Mobile Apps-verzióját tekintse meg.

A WebAPI-projekt létrehozása

Az alábbi szakaszok az új ASP.NET WebAPI hátterrendszer létrehozását ismertetik. E folyamat három fő célja:

  • Ügyfelek hitelesítése: Az ügyfélkérések hitelesítéséhez és a kérés adott felhasználóhoz való hozzárendeléséhez egy üzenetkezelőt fog hozzáadni a rendszerhez.
  • Regisztrálás értesítésekre a WebAPI háttérrendszer használatával: Annak érdekében, hogy az ügyféleszközön értesítéseket lehessen fogadni, egy vezérlőt fog hozzáadni az új regisztrációk kezeléséhez. A rendszer címke formájában automatikusan hozzáadja a hitelesített felhasználó nevét a regisztrációhoz.
  • Értesítések küldése az ügyfeleknek: Egy vezérlőt is hozzá fog adni annak érdekében, hogy a felhasználók biztonságos leküldést indíthassanak az eszközökre és a címkéhez társított ügyfelek számára.

Hozza létre az új ASP.NET Core 6.0 webes API-háttérrendszert a következő műveletek végrehajtásával:

Az ellenőrzéshez indítsa el a Visual Studiót. Az Eszközök menüben válassza a Bővítmények és frissítések pontot. Keresse meg az Ön által használt Visual Studio-verzióhoz tartozó NuGet-csomagkezelőt, és ellenőrizze, hogy a legfrissebb verzió van-e telepítve a gépén. Ha nem a legfrissebb verzió van telepítve a gépén, távolítsa el, és telepítse újra a NuGet-csomagkezelőt.

Képernyőkép a Bővítmények és Frissítések párbeszédpanelről, kiemelt NuGet Package manage for Visual Studios csomaggal.

Megjegyzés

Győződjön meg arról, hogy telepítette a Visual Studio Azure SDK-t a webhely üzembe helyezéséhez.

  1. Indítsa el a Visual Studiót vagy a Visual Studio Expresst.

  2. Kattintson a Server Explorer (Kiszolgálókezelő) elemre, és jelentkezzen be az Azure-fiókjába. Be kell jelentkeznie ahhoz, hogy a fiókban létrehozhassa a webhelyerőforrásokat.

  3. A Visual Studio Fájl menüjében válassza az Új>projekt lehetőséget.

  4. A keresőmezőbe írja be a Webes API kifejezést.

  5. Válassza ki a ASP.NET Core Webes API-projektsablont, és válassza a Tovább gombot.

  6. Az Új projekt konfigurálása párbeszédpanelen adja a projektnek az AppBackend nevet, majd válassza a Tovább gombot.

  7. A További információk párbeszédpanelen:

    • Győződjön meg arról, hogy a keretrendszer.NET 6.0 (hosszú távú támogatás).
    • Győződjön meg arról, hogy a Vezérlők használata jelölőnégyzet be van jelölve (törölje a jelölést a minimális API-k használatához).
    • Törölje az OpenAPI-támogatás engedélyezése jelölőnégyzet jelölését.
    • Válassza a Létrehozás lehetőséget.

A WeatherForecast sablonfájljainak eltávolítása

  1. Távolítsa el a WeatherForecast.cs és a Controllers/WeatherForecastController.cs példafájlokat az új AppBackend projektből.
  2. Nyissa meg a Properties\launchSettings.json fájlt.
  3. A launchUrl tulajdonságainak módosítása weatherforcastrólappbackendre.

A Configure Microsoft Azure Web App (Microsoft Azure-webalkalmazás konfigurálása) ablakban válasszon ki egy előfizetést, majd az App Service plan (App Service-csomag) listában végezze el az alábbi műveletek valamelyikét:

  • Válasszon ki egy már létrehozott Azure App Service csomagot.
  • Válassza a Create a new app service plan (Új App Service-csomag létrehozása) lehetőséget is, és hozzon létre egy új csomagot.

Az oktatóanyag elvégzéséhez nincs szükség adatbázisra. Az App Service-csomag kiválasztása után kattintson az OK gombra a projekt létrehozásához.

A Configure Microsoft Azure Web App (Microsoft Azure-webalkalmazás konfigurálása) ablak

Ha nem látja ezt a lapot az App Service-csomag konfigurálásához, folytassa az oktatóanyaggal. Az alkalmazást később is konfigurálhatja az alkalmazás közzétételekor.

Ügyfelek hitelesítése a WebAPI háttérrendszeren

Ebben a szakaszban egy új, AuthenticationTestHandler nevű üzenetkezelő-osztályt fog létrehozni az új háttérrendszer számára. A rendszer ezt az osztályt a DelegatingHandler kezelőből származtatja, és üzenetkezelőként adja hozzá, így az képes a háttérrendszerhez beérkező összes kérés feldolgozására.

  1. A Solution Explorer (Megoldáskezelő) ablakában kattintson a jobb gombbal az AppBackend projektre, válassza az Add (Hozzáadás) parancsot, majd a Class (Osztály) elemet.

  2. Nevezze el az új osztályt AuthenticationTestHandler.cs néven, majd kattintson az Add (Hozzáadás) gombra az osztály létrehozásához. Az egyszerűség kedvéért a rendszer ezt az osztályt fogja használni a felhasználók alapszintű hitelesítéséhez. Az alkalmazás bármilyen hitelesítési séma használatára képes.

  3. Az AuthenticationTestHandler.cs osztályban adja hozzá a következő using-utasításokat:

    using System.Net.Http;
using System.Threading;
using System.Security.Principal;
using System.Net;
using System.Text;
using System.Threading.Tasks;

  4. Az AuthenticationTestHandler.cs osztályban cserélje le az AuthenticationTestHandler osztálydefiníciót az alábbi kódra:

    A kezelő akkor engedélyezi a kérést, ha teljesül a következő három feltétel:

    • A kérés tartalmaz engedélyezési fejlécet.
    • A kérés alapszintű hitelesítést használ.
    • A felhasználónév és a jelszó sztring azonos.

    Ellenkező esetben a kérést a rendszer elutasítja. Ez nem egy valós hitelesítési és engedélyezési megközelítés, csak egy egyszerű példa ehhez az oktatóanyaghoz.

    Ha az AuthenticationTestHandler hitelesíti és engedélyezi a kérésüzenetet, az alapszintű hitelesítést használó felhasználót a rendszer hozzákapcsolja az aktuális kéréshez a HttpContext felületén. A HttpContext felhasználói adatait a későbbiekben egy másik vezérlő (RegisterController) fogja használni egy címke az értesítésregisztrációs kéréshez való hozzáadásához.

    public class AuthenticationTestHandler : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(
    HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var authorizationHeader = request.Headers.GetValues("Authorization").First();

        if (authorizationHeader != null && authorizationHeader
            .StartsWith("Basic ", StringComparison.InvariantCultureIgnoreCase))
        {
            string authorizationUserAndPwdBase64 =
                authorizationHeader.Substring("Basic ".Length);
            string authorizationUserAndPwd = Encoding.Default
                .GetString(Convert.FromBase64String(authorizationUserAndPwdBase64));
            string user = authorizationUserAndPwd.Split(':')[0];
            string password = authorizationUserAndPwd.Split(':')[1];

            if (VerifyUserAndPwd(user, password))
            {
                // Attach the new principal object to the current HttpContext object
                HttpContext.Current.User =
                    new GenericPrincipal(new GenericIdentity(user), new string[0]);
                System.Threading.Thread.CurrentPrincipal =
                    System.Web.HttpContext.Current.User;
            }
            else return Unauthorized();
        }
        else return Unauthorized();

        return base.SendAsync(request, cancellationToken);
    }

    private bool VerifyUserAndPwd(string user, string password)
    {
        // This is not a real authentication scheme.
        return user == password;
    }

    private Task<HttpResponseMessage> Unauthorized()
    {
        var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
        var tsc = new TaskCompletionSource<HttpResponseMessage>();
        tsc.SetResult(response);
        return tsc.Task;
    }
}

    Megjegyzés

    Biztonsági megjegyzés: Az AuthenticationTestHandler osztály nem biztosít valós hitelesítést. A rendszer azt csak az alapszintű hitelesítés utánzására használja, és nem tekinthető biztonságosnak. Az éles alkalmazásokban és szolgáltatásokban implementálnia kell egy biztonságos hitelesítési mechanizmust.

  5. Az üzenetkezelő regisztrálásához adja hozzá a következő kódot a Register metódus végéhez a Program.cs fájlban:

    config.MessageHandlers.Add(new AuthenticationTestHandler());

  6. Mentse a módosításokat.

Regisztráció értesítésekre a WebAPI háttérrendszer használatával

Ebben a szakaszban egy új vezérlőt fog hozzáadni a WebAPI háttérrendszerhez a felhasználók és az eszközök értesítés-regisztrációs kéréseinek kezeléséhez az értesítési központ ügyfélkönyvtárával. A vezérlő hozzáad egy felhasználói címkét a hitelesített és az AuthenticationTestHandler által a HttpContext elemhez kapcsolt felhasználóhoz. A címke "username:<actual username>" sztringformátumú lesz.

  1. A Solution Explorer (Megoldáskezelő) ablakában kattintson a jobb gombbal az AppBackend projektre, majd kattintson a Manage NuGet Packages (NuGet-csomagok kezelése) parancsra.

  2. A bal oldali ablaktáblán válassza az Online elemet, majd a keresőmezőbe írja be a Microsoft.Azure.NotificationHubs kifejezést.

  3. Az eredmények listájából válassza ki a Microsoft Azure Notification Hubs elemet, majd az Install (Telepítés) lehetőséget. Fejezze be a telepítést, majd zárja be a NuGet-csomagkezelő ablakát.

    Ez a művelet hozzáad egy, az Azure Notification Hubs SDK-ra mutató hivatkozást a Microsoft.Azure.Notification Hubs NuGet-csomag használatával.

  4. Hozzon létre egy új osztályfájlt, amely az értesítések küldésére használt értesítési központtal való kapcsolatot jelöli. A Solution Explorer (Megoldáskezelő) ablakában kattintson a jobb gombbal a Models (Modellek) mappára, kattintson az Add (Hozzáadás) parancsra, majd kattintson a Class (Osztály) gombra. Nevezze el az új osztályt Notifications.cs néven, majd kattintson az Add (Hozzáadás) gombra az osztály létrehozásához.

    Az Add New Item (Új elem hozzáadása) ablak

  5. Adja hozzá a következő using-utasítást a Notifications.cs fájl elejéhez:

    using Microsoft.Azure.NotificationHubs;

  6. Cserélje le a Notifications osztálydefiníciót a következő kódra, a két helyőrzőt pedig az értesítési központ kapcsolati sztringjére (teljes hozzáféréssel) és a központ nevére (az Azure Portalon érhető el):

    public class Notifications
{
    public static Notifications Instance = new Notifications();

    public NotificationHubClient Hub { get; set; }

    private Notifications() {
        Hub = NotificationHubClient.CreateClientFromConnectionString("<your hub's DefaultFullSharedAccessSignature>",
                                                                        "<hub name>");
    }
}

    Fontos

    A továbblépés előtt adja meg a központ nevét és DefaultFullSharedAccessSignature értékét.

  7. A következő lépésben hozzon létre egy új vezérlőt RegisterController néven. A Solution Explorer (Megoldáskezelő) ablakában kattintson a jobb gombbal a Controllers (Vezérlők) mappára, kattintson az Add (Hozzáadás) parancsra, majd kattintson a Controller (Vezérlő) gombra.

  8. Válassza az API Controller – Üres lehetőséget, majd válassza a Hozzáadás lehetőséget.

  9. A Controller name (Vezérlő neve) mezőben nevezze el az új osztályt RegisterController néven, majd kattintson az Add (Hozzáadás) gombra.

    A Vezérlő hozzáadása ablak.

  10. Adja hozzá a következő using-utasításokat a RegisterController.cs fájlhoz:

    using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.NotificationHubs.Messaging;
using AppBackend.Models;
using System.Threading.Tasks;
using System.Web;

  11. Adja hozzá a következő kódot a(z) RegisterController osztálydefiníciójához: Ebben a kódban felhasználói címkét fog hozzáadni a HttpContexthez csatolt felhasználóhoz. A felhasználó hitelesítését és a HttpContexthez való csatolását az Ön által hozzáadott üzenetszűrő (AuthenticationTestHandler) végezte. További választható ellenőrzéseket is hozzáadhat, amelyekkel ellenőrizheti, hogy a felhasználó jogosult-e a kért címkékre történő regisztráláshoz.

    private NotificationHubClient hub;

public RegisterController()
{
    hub = Notifications.Instance.Hub;
}

public class DeviceRegistration
{
    public string Platform { get; set; }
    public string Handle { get; set; }
    public string[] Tags { get; set; }
}

// POST api/register
// This creates a registration id
public async Task<string> Post(string handle = null)
{
    string newRegistrationId = null;

    // make sure there are no existing registrations for this push handle (used for iOS and Android)
    if (handle != null)
    {
        var registrations = await hub.GetRegistrationsByChannelAsync(handle, 100);

        foreach (RegistrationDescription registration in registrations)
        {
            if (newRegistrationId == null)
            {
                newRegistrationId = registration.RegistrationId;
            }
            else
            {
                await hub.DeleteRegistrationAsync(registration);
            }
        }
    }

    if (newRegistrationId == null) 
        newRegistrationId = await hub.CreateRegistrationIdAsync();

    return newRegistrationId;
}

// PUT api/register/5
// This creates or updates a registration (with provided channelURI) at the specified id
public async Task<HttpResponseMessage> Put(string id, DeviceRegistration deviceUpdate)
{
    RegistrationDescription registration = null;
    switch (deviceUpdate.Platform)
    {
        case "mpns":
            registration = new MpnsRegistrationDescription(deviceUpdate.Handle);
            break;
        case "wns":
            registration = new WindowsRegistrationDescription(deviceUpdate.Handle);
            break;
        case "apns":
            registration = new AppleRegistrationDescription(deviceUpdate.Handle);
            break;
        case "fcm":
            registration = new FcmRegistrationDescription(deviceUpdate.Handle);
            break;
        default:
            throw new HttpResponseException(HttpStatusCode.BadRequest);
    }

    registration.RegistrationId = id;
    var username = HttpContext.Current.User.Identity.Name;

    // add check if user is allowed to add these tags
    registration.Tags = new HashSet<string>(deviceUpdate.Tags);
    registration.Tags.Add("username:" + username);

    try
    {
        await hub.CreateOrUpdateRegistrationAsync(registration);
    }
    catch (MessagingException e)
    {
        ReturnGoneIfHubResponseIsGone(e);
    }

    return Request.CreateResponse(HttpStatusCode.OK);
}

// DELETE api/register/5
public async Task<HttpResponseMessage> Delete(string id)
{
    await hub.DeleteRegistrationAsync(id);
    return Request.CreateResponse(HttpStatusCode.OK);
}

private static void ReturnGoneIfHubResponseIsGone(MessagingException e)
{
    var webex = e.InnerException as WebException;
    if (webex.Status == WebExceptionStatus.ProtocolError)
    {
        var response = (HttpWebResponse)webex.Response;
        if (response.StatusCode == HttpStatusCode.Gone)
            throw new HttpRequestException(HttpStatusCode.Gone.ToString());
    }
}

  12. Mentse a módosításokat.

Értesítések küldése a WebAPI háttérrendszerről

Ebben a szakaszban egy új vezérlőt ad hozzá, amely értesítés küldését teszi lehetővé az ügyféleszközök számára. A rendszer az értesítést az ASP.NET WebAPI-háttérrendszeren lévő Azure Notification Hubs .NET Libraryt használó felhasználónév-címke alapján hozza létre.

  1. Hozzon létre egy másik új, NotificationsController nevű vezérlőt. Ennek során ugyanúgy járjon el, mint az előző szakaszban a RegisterController vezérlő esetében.

  2. Adja hozzá a következő using-utasításokat a NotificationsController.cs fájlhoz:

    using AppBackend.Models;
using System.Threading.Tasks;
using System.Web;

  3. Adja hozzá a következő metódust a NotificationsController osztályhoz:

    Ez a kód egy értesítéstípust fog küldeni a platformértesítési szolgáltatás (PNS) pns paramétere alapján. A(z) to_tag értékét a rendszer az üzenet felhasználónév-címkéjének beállítására használja. A címkének egyeznie kell egy aktív értesítésiközpont-regisztráció felhasználónév-címkéjével. Az értesítési üzenetet a rendszer a POST-kérés törzséből nyeri ki, és a cél PNS-nek megfelelően formázza.

    A támogatott eszközök által az értesítések fogadására használt PNS-től függően az értesítések különböző formátumok használatával támogatottak. Windows rendszerű eszközökön például használhat bejelentési értesítéseket a WNS formátummal, amelyet egy másik PNS nem támogat közvetlenül. Ebben az esetben a háttérrendszernek a támogatni kívánt eszközök PNS-e által támogatott formátum szerint kell formáznia az értesítést. Ezt követően használja a megfelelő küldési API-t a NotificationHubClient osztályon.

    public async Task<HttpResponseMessage> Post(string pns, [FromBody]string message, string to_tag)
{
    var user = HttpContext.Current.User.Identity.Name;
    string[] userTag = new string[2];
    userTag[0] = "username:" + to_tag;
    userTag[1] = "from:" + user;

    Microsoft.Azure.NotificationHubs.NotificationOutcome outcome = null;
    HttpStatusCode ret = HttpStatusCode.InternalServerError;

    switch (pns.ToLower())
    {
        case "wns":
            // Windows 8.1 / Windows Phone 8.1
            var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">" + 
                        "From " + user + ": " + message + "</text></binding></visual></toast>";
            outcome = await Notifications.Instance.Hub.SendWindowsNativeNotificationAsync(toast, userTag);
            break;
        case "apns":
            // iOS
            var alert = "{\"aps\":{\"alert\":\"" + "From " + user + ": " + message + "\"}}";
            outcome = await Notifications.Instance.Hub.SendAppleNativeNotificationAsync(alert, userTag);
            break;
        case "fcm":
            // Android
            var notif = "{ \"data\" : {\"message\":\"" + "From " + user + ": " + message + "\"}}";
            outcome = await Notifications.Instance.Hub.SendFcmNativeNotificationAsync(notif, userTag);
            break;
    }

    if (outcome != null)
    {
        if (!((outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Abandoned) ||
            (outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Unknown)))
        {
            ret = HttpStatusCode.OK;
        }
    }

    return Request.CreateResponse(ret);
}

  4. Nyomja le az F5 billentyűt az alkalmazás futtatásához, valamint eddigi munkája pontosságának ellenőrzéséhez. Az alkalmazás megnyit egy webböngészőt, amelyen az ASP.NET kezdőlapja jelenik meg.

Az új WebAPI háttérrendszer közzététele

A következőkben üzembe fogja helyezni ezt az alkalmazást egy Azure-webhelyen, hogy minden eszközről elérhető legyen.

  1. Kattintson a jobb gombbal az AppBackend projektre, és válassza a Publish (Közzététel) lehetőséget.

  2. Közzétételi célként válassza a Microsoft Azure App Service lehetőséget, majd kattintson a \*\*Publish (Közzététel) gombra. Ekkor megnyílik a Create App Service (App Service létrehozása) ablak. Itt létrehozhatja az összes, az ASP.NET-webalkalmazás Azure-ban való futtatásához szükséges Azure-erőforrást.

    A Microsoft Azure App Service (Microsoft Azure App Service) csempe

  3. A Create App Service (App Service létrehozása) ablakban válassza ki az Azure-fiókját. Válassza a Típus> módosításawebalkalmazás lehetőséget. Tartsa meg az alapértelmezett webalkalmazásnevet, majd válassza a Subscription (Előfizetés), Resource Group (Erőforráscsoport) és App Service Plan (App Service-csomag) elemeket.

  4. Válassza a Létrehozás lehetőséget.

  5. Jegyezze fel a Summary (Összegzés) szakaszban lévő Site URL (Webhely URL-címe) tulajdonságot. Ezt az URL-címet az oktatóanyag későbbi részében fogja használni háttérvégpontként.

  6. Válassza a Közzététel lehetőséget.

Miután a varázsló befejeződött, közzéteszi az ASP.NET-webalkalmazást az Azure-on, majd megnyitja azt az alapértelmezett böngészőben. Az alkalmazását az Azure App Servicesben tekintheti meg.

Az URL-cím a korábban megadott webalkalmazásnevet használja http:// app_name.azurewebsites.net> formátumban<.

Az UWP-ügyfél kódjának frissítése

Ebben a szakaszban az Oktatóanyag: Értesítések küldése az Univerzális Windows-platformon alapuló alkalmazásoknak az Azure Notification Hubs használatával című oktatóanyag során létrehozott kódot fogja frissíteni. A projektnek már társítva kell lennie a Windows Áruházhoz. Emellett úgy kell konfigurálni, hogy az értesítési központot használja. Ebben a szakaszban olyan kódot fog hozzáadni, amely meghívja az új WebAPI háttérrendszert, majd az értesítések regisztrálásához és küldéséhez használja azt.

  1. A Visual Studióban nyissa meg az Oktatóanyag: Értesítések küldése az Univerzális Windows-platformon alapuló alkalmazásoknak az Azure Notification Hubs használatával című oktatóanyaghoz létrehozott megoldást.

  2. A Megoldáskezelő kattintson a jobb gombbal a Univerzális Windows-platform (UWP) projektre, majd kattintson a Manage NuGet Packages (NuGet-csomagok kezelése) elemre.

  3. A bal oldalon válassza a Tallózás lehetőséget.

  4. A Search (Keresés) mezőbe írja be a Http Client (HTTP-ügyfél) kifejezést.

  5. A találatok listájában kattintson a System.Net.Http elemre, majd az Install (Telepítés) parancsra. Fejezze be a telepítést.

  6. A NuGet Search (Keresés) mezőjébe írja be a Json.net kifejezést. Telepítse a Newtonsoft.json csomagot, majd zárja be a NuGet-csomagkezelő ablakát.

  7. A Megoldáskezelőben megnyitott WindowsApp projektben kattintson duplán a MainPage.xaml fájlra a Visual Studio-szerkesztőben való megnyitásához.

  8. MainPage.xaml A fájlban cserélje le a szakaszt a <Grid> következő kódra: Ez a kód hozzáad egy felhasználónevet és jelszót tartalmazó szövegmezőt, amellyel a felhasználó hitelesíti magát. Emellett szövegmezőket is hozzáad az értesítési üzenethez, valamint a felhasználónevet tartalmazó címkéhez, amely megkapja az értesítést:

    <Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto"/>
        <RowDefinition Height="*"/>
    </Grid.RowDefinitions>

    <TextBlock Grid.Row="0" Text="Notify Users" HorizontalAlignment="Center" FontSize="48"/>

    <StackPanel Grid.Row="1" VerticalAlignment="Center">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition></ColumnDefinition>
                <ColumnDefinition></ColumnDefinition>
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Row="0" Grid.ColumnSpan="3" Text="Username" FontSize="24" Margin="20,0,20,0"/>
            <TextBox Name="UsernameTextBox" Grid.Row="1" Grid.ColumnSpan="3" Margin="20,0,20,0"/>
            <TextBlock Grid.Row="2" Grid.ColumnSpan="3" Text="Password" FontSize="24" Margin="20,0,20,0" />
            <PasswordBox Name="PasswordTextBox" Grid.Row="3" Grid.ColumnSpan="3" Margin="20,0,20,0"/>

            <Button Grid.Row="4" Grid.ColumnSpan="3" HorizontalAlignment="Center" VerticalAlignment="Center"
                        Content="1. Login and register" Click="LoginAndRegisterClick" Margin="0,0,0,20"/>

            <ToggleButton Name="toggleWNS" Grid.Row="5" Grid.Column="0" HorizontalAlignment="Right" Content="WNS" IsChecked="True" />
            <ToggleButton Name="toggleFCM" Grid.Row="5" Grid.Column="1" HorizontalAlignment="Center" Content="FCM" />
            <ToggleButton Name="toggleAPNS" Grid.Row="5" Grid.Column="2" HorizontalAlignment="Left" Content="APNS" />

            <TextBlock Grid.Row="6" Grid.ColumnSpan="3" Text="Username Tag To Send To" FontSize="24" Margin="20,0,20,0"/>
            <TextBox Name="ToUserTagTextBox" Grid.Row="7" Grid.ColumnSpan="3" Margin="20,0,20,0" TextWrapping="Wrap" />
            <TextBlock Grid.Row="8" Grid.ColumnSpan="3" Text="Enter Notification Message" FontSize="24" Margin="20,0,20,0"/>
            <TextBox Name="NotificationMessageTextBox" Grid.Row="9" Grid.ColumnSpan="3" Margin="20,0,20,0" TextWrapping="Wrap" />
            <Button Grid.Row="10" Grid.ColumnSpan="3" HorizontalAlignment="Center" Content="2. Send push" Click="PushClick" Name="SendPushButton" />
        </Grid>
    </StackPanel>
</Grid>

  9. Az Megoldáskezelő nyissa meg a MainPage.xaml.cs(Windows 8.1) és (Windows Phone-telefon 8.1) projektek fájlját. Adja hozzá a következő using utasításokat mindkét fájl elejéhez:

    using System.Net.Http;
using Windows.Storage;
using System.Net.Http.Headers;
using Windows.Networking.PushNotifications;
using Windows.UI.Popups;
using System.Threading.Tasks;

  10. A MainPage.xaml.csWindowsApp projekt esetében adja hozzá a következő tagot az MainPage osztályhoz. Ne felejtse el az <Enter Your Backend Endpoint> karakterláncot a saját háttérrendszere korábban beszerzett végpontjára cserélni. Például: http://mybackend.azurewebsites.net.

    private static string BACKEND_ENDPOINT = "<Enter Your Backend Endpoint>";

  11. Adja hozzá az alábbi kódot a MainPage osztályhoz MainPage.xaml.cs a (Windows 8.1) és (Windows Phone-telefon 8.1) projektekben.

    A PushClick metódus a Send Push (Leküldéses értesítés küldése) gomb kattintáskezelője. A háttérrendszer meghívásával aktiválja egy értesítés küldését az összes olyan eszközre, amely a to_tag paraméterrel egyező felhasználónév-címkével rendelkezik. Az értesítési üzenet küldése a kérés törzsében található JSON-tartalomként történik.

    A LoginAndRegisterClick metódus a Login and register (Bejelentkezés és regisztráció) gomb kattintáskezelője. Az alapszintű hitelesítési jogkivonatot (a hitelesítési séma által használt bármely jogkivonatot képviseli) tárolja a helyi tárterületen, majd a RegisterClient használatával regisztrál értesítésekre a háttérrendszer használatával.

    private async void PushClick(object sender, RoutedEventArgs e)
{
    if (toggleWNS.IsChecked.Value)
    {
        await sendPush("wns", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);
    }
    if (toggleFCM.IsChecked.Value)
    {
        await sendPush("fcm", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);
    }
    if (toggleAPNS.IsChecked.Value)
    {
        await sendPush("apns", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);

    }
}

private async Task sendPush(string pns, string userTag, string message)
{
    var POST_URL = BACKEND_ENDPOINT + "/api/notifications?pns=" +
        pns + "&to_tag=" + userTag;

    using (var httpClient = new HttpClient())
    {
        var settings = ApplicationData.Current.LocalSettings.Values;
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string)settings["AuthenticationToken"]);

        try
        {
            await httpClient.PostAsync(POST_URL, new StringContent("\"" + message + "\"",
                System.Text.Encoding.UTF8, "application/json"));
        }
        catch (Exception ex)
        {
            MessageDialog alert = new MessageDialog(ex.Message, "Failed to send " + pns + " message");
            alert.ShowAsync();
        }
    }
}

private async void LoginAndRegisterClick(object sender, RoutedEventArgs e)
{
    SetAuthenticationTokenInLocalStorage();

    var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

    // The "username:<user name>" tag gets automatically added by the message handler in the backend.
    // The tag passed here can be whatever other tags you may want to use.
    try
    {
        // The device handle used is different depending on the device and PNS.
        // Windows devices use the channel uri as the PNS handle.
        await new RegisterClient(BACKEND_ENDPOINT).RegisterAsync(channel.Uri, new string[] { "myTag" });

        var dialog = new MessageDialog("Registered as: " + UsernameTextBox.Text);
        dialog.Commands.Add(new UICommand("OK"));
        await dialog.ShowAsync();
        SendPushButton.IsEnabled = true;
    }
    catch (Exception ex)
    {
        MessageDialog alert = new MessageDialog(ex.Message, "Failed to register with RegisterClient");
        alert.ShowAsync();
    }
}

private void SetAuthenticationTokenInLocalStorage()
{
    string username = UsernameTextBox.Text;
    string password = PasswordTextBox.Password;

    var token = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(username + ":" + password));
    ApplicationData.Current.LocalSettings.Values["AuthenticationToken"] = token;
}

  12. Nyissa meg App.xaml.cs és keresse meg a hívását InitNotificationsAsync() az OnLaunched() eseménykezelőben. Tegye megjegyzésbe vagy törölje az InitNotificationsAsync() meghívását. A gombkezelő inicializálja az értesítésregisztrációkat:

    protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    //InitNotificationsAsync();

  13. Kattintson a jobb gombbal a WindowsApp projektre, kattintson az Add (Hozzáadás) lehetőségre, majd a Class (Osztály) elemre. Adja a osztálynak RegisterClient.csa nevet, majd kattintson az OK gombra az osztály létrehozásához.

    Ez az osztály burkolja azon REST-hívásokat, amelyek az alkalmazás háttérrendszeréhez való kapcsolódáshoz szükségesek a leküldéses értesítésekre való regisztrálás érdekében. Emellett helyben tárolja az értesítési központ által a Regisztráció az alkalmazás háttérrendszeréből című szakaszban leírtak szerint létrehozott registrationIds fájlt. A helyi tárterületen tárolt hitelesítési jogkivonatot használ, amikor a Login and register (Bejelentkezés és regisztráció) gombra kattint.

  14. Adja hozzá a következő using utasításokat a RegisterClient.cs fájl elejéhez:

    using Windows.Storage;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using Newtonsoft.Json;
using System.Threading.Tasks;
using System.Linq;

  15. Adja hozzá a következő kódot az RegisterClient osztálydefinícióhoz:

    private string POST_URL;

private class DeviceRegistration
{
    public string Platform { get; set; }
    public string Handle { get; set; }
    public string[] Tags { get; set; }
}

public RegisterClient(string backendEndpoint)
{
    POST_URL = backendEndpoint + "/api/register";
}

public async Task RegisterAsync(string handle, IEnumerable<string> tags)
{
    var regId = await RetrieveRegistrationIdOrRequestNewOneAsync();

    var deviceRegistration = new DeviceRegistration
    {
        Platform = "wns",
        Handle = handle,
        Tags = tags.ToArray<string>()
    };

    var statusCode = await UpdateRegistrationAsync(regId, deviceRegistration);

    if (statusCode == HttpStatusCode.Gone)
    {
        // regId is expired, deleting from local storage & recreating
        var settings = ApplicationData.Current.LocalSettings.Values;
        settings.Remove("__NHRegistrationId");
        regId = await RetrieveRegistrationIdOrRequestNewOneAsync();
        statusCode = await UpdateRegistrationAsync(regId, deviceRegistration);
    }

    if (statusCode != HttpStatusCode.Accepted && statusCode != HttpStatusCode.OK)
    {
        // log or throw
        throw new System.Net.WebException(statusCode.ToString());
    }
}

private async Task<HttpStatusCode> UpdateRegistrationAsync(string regId, DeviceRegistration deviceRegistration)
{
    using (var httpClient = new HttpClient())
    {
        var settings = ApplicationData.Current.LocalSettings.Values;
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string) settings["AuthenticationToken"]);

        var putUri = POST_URL + "/" + regId;

        string json = JsonConvert.SerializeObject(deviceRegistration);
                        var response = await httpClient.PutAsync(putUri, new StringContent(json, Encoding.UTF8, "application/json"));
        return response.StatusCode;
    }
}

private async Task<string> RetrieveRegistrationIdOrRequestNewOneAsync()
{
    var settings = ApplicationData.Current.LocalSettings.Values;
    if (!settings.ContainsKey("__NHRegistrationId"))
    {
        using (var httpClient = new HttpClient())
        {
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string)settings["AuthenticationToken"]);

            var response = await httpClient.PostAsync(POST_URL, new StringContent(""));
            if (response.IsSuccessStatusCode)
            {
                string regId = await response.Content.ReadAsStringAsync();
                regId = regId.Substring(1, regId.Length - 2);
                settings.Add("__NHRegistrationId", regId);
            }
            else
            {
                throw new System.Net.WebException(response.StatusCode.ToString());
            }
        }
    }
    return (string)settings["__NHRegistrationId"];

}

  16. Mentse az összes módosítást.

Az alkalmazás tesztelése

  1. Indítsa el az alkalmazást mindkét Windows-rendszeren.

  2. Adjon meg egy felhasználónevet és jelszót az alábbi képen látható módon. A Windows Phone rendszeren megadott felhasználónévtől és jelszótól eltérőnek kell lenniük.

  3. Kattintson a Login and register (Bejelentkezés és regisztráció) gombra, és ellenőrizze, hogy a párbeszédpanel megjeleníti-e a sikeres bejelentkezés tényét. Ez a kód engedélyezi a Send Push (Leküldéses értesítés küldése) gombot is.

    Képernyőkép a Notification Hubs alkalmazásról, amelyen a felhasználónév és a jelszó ki van töltve.

  4. Ezt követően adja meg a regisztrált felhasználónevet a Recipient Username Tag (Címzett felhasználónév-címke) mezőben. Adjon meg egy értesítési üzenetet, és kattintson a Send Push (Leküldéses értesítés küldése) gombra.

  5. Csak az egyező felhasználónév-címkével regisztrált eszközök kapják meg az értesítési üzenetet.

    Képernyőkép a Notification Hubs alkalmazásról, amelyen a leküldéses üzenet látható.

Következő lépések

Ebben az oktatóanyagban elsajátította, hogy hogyan küldhet leküldéses értesítéseket olyan adott felhasználóknak, akik a regisztrációjukhoz társított címkével rendelkeznek. Ha szeretné megtudni, hogy hogyan küldhet helyalapú értesítéseket, lépjen tovább a következő oktatóanyagra:

Helyalapú leküldéses értesítések küldése