Leküldéses értesítések hozzáadása Xamarin.Android-alkalmazáshoz

Cikk
06/25/2019

Áttekintés

Ebben az oktatóanyagban leküldéses értesítéseket ad hozzá a Xamarin.Android gyorsindítási projekthez, így a rendszer minden rekord beszúrásakor leküldéses értesítést küld az eszköznek.

Ha nem használja a letöltött gyorsindítási kiszolgálóprojektet, szüksége lesz a leküldéses értesítési bővítménycsomagra. További információ: A .NET háttérkiszolgálói SDK használata az Azure Mobile Appshez című útmutatóban.

Előfeltételek

Ehhez az oktatóanyaghoz a következő beállítások szükségesek:

Aktív Google-fiók. A Google-fiókra a accounts.google.com regisztrálhat.
A Google Cloud Messaging ügyfélösszetevője.

Értesítési központ konfigurálása

A Azure App Service Mobile Apps szolgáltatása az Azure Notification Hubs használatával küld leküldéseket, így egy értesítési központot fog konfigurálni a mobilalkalmazáshoz.

A Azure Portal nyissa meg az App Servicest, majd válassza ki az alkalmazás háttérrendszerét. A Beállítások területen válassza a Leküldés lehetőséget.
Ha értesítési központ-erőforrást szeretne hozzáadni az alkalmazáshoz, válassza a Csatlakozás lehetőséget. Létrehozhat egy központot, vagy csatlakozhat egy meglévőhöz.

Most már csatlakoztatott egy értesítési központot a Mobile Apps háttérprojektjéhez. Később ezt az értesítési központot úgy konfigurálja, hogy egy platformértesítési rendszerhez (PNS) csatlakozzon az eszközökre való leküldéshez.

A Firebase Cloud Messaging engedélyezése

Jelentkezzen be a Firebase konzoljába. Hozzon létre egy új Firebase-projektet, ha nem rendelkezik még ilyennel.
A projekt létrehozása után válassza az Add Firebase to your Android app (A Firebase hozzáadása az Android-alkalmazáshoz) lehetőséget.
A Firebase hozzáadása androidos alkalmazáshoz lapon hajtsa végre a következő lépéseket:
1. Android-csomagnév esetén másolja az applicationId értékét az alkalmazás build.gradle fájljában. Ebben a példában ez a következő com.fabrikam.fcmtutorial1app: .
2. Válassza az Alkalmazás regisztrálása lehetőséget.
Válassza a Google-services.json letöltése lehetőséget, mentse a fájlt a projekt alkalmazásmappájába , majd válassza a Tovább gombot.
Végezze el a következő konfigurációs módosításokat a projekten az Android Studióban.
1. A projektszintű build.gradle fájlban (<project>/build.gradle) adja hozzá a következő utasítást a függőségek szakaszhoz.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Az alkalmazásszintű build.gradle fájlban (<project>/<app-module>/build.gradle) adja hozzá a következő utasításokat a függőségek szakaszhoz.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Adja hozzá a következő sort az alkalmazásszintű build.gradle fájl végéhez a függőségek szakasz után.
```
apply plugin: 'com.google.gms.google-services'
```
4. Válassza a Szinkronizálás gombot az eszköztáron.
Kattintson a Tovább gombra.
Válassza a Lépés kihagyása lehetőséget.
A Firebase konzolján kattintson a projektjéhez tartozó fogaskerékre. Ezután kattintson a Project Settings (Projektbeállítások) elemre.
Ha még nem töltötte le a google-services.json fájlt az Android Studio-projekt alkalmazásmappájába , ezt ezen az oldalon teheti meg.
Váltson a felhőbeli üzenetkezelés lapra a lap tetején.
Másolja és mentse a kiszolgálókulcsot későbbi használatra. Ezzel az értékkel konfigurálhatja a központot.

Az Azure konfigurálása leküldéses kérelmek küldésére

A Azure Portal kattintson az Összes >App Servicestallózásaelemre, majd a Mobile Apps háttérrendszerére. A Beállítások területen kattintson a App Service Leküldés, majd az értesítési központ nevére.
Nyissa meg a Google-t (GCM), adja meg a Firebase-ből az előző eljárásban beszerzett kiszolgálókulcs-értéket , majd kattintson a Mentés gombra.

A Mobile Apps háttérrendszere mostantól a Firebase Cloud Messaging használatára van konfigurálva. Ez lehetővé teszi, hogy leküldéses értesítéseket küldjön az Android-eszközön futó alkalmazásnak az értesítési központ használatával.

A kiszolgálóprojekt frissítése leküldéses értesítések küldéséhez

Ebben a szakaszban a meglévő Mobile Apps-háttérprojekt kódját frissítve küld leküldéses értesítést minden új elem hozzáadásakor. Ezt a folyamatot az Azure Notification Hubs sablonfunkciója működteti, amely platformfüggetlen leküldéseket tesz lehetővé. A különböző ügyfelek sablonokkal vannak regisztrálva leküldéses értesítésekhez, és egyetlen univerzális leküldés minden ügyfélplatformra elérhető.

Válasszon a háttérprojekt típusának megfelelő alábbi eljárások közül – akár .NET-háttérrendszert , akárNode.js háttérrendszert.

.NET-háttérprojekt

A Visual Studióban kattintson a jobb gombbal a kiszolgálóprojektre. Ezután válassza a NuGet-csomagok kezelése lehetőséget. Keressen rá Microsoft.Azure.NotificationHubs, majd válassza a Telepítés lehetőséget. Ez a folyamat telepíti a Notification Hubs-kódtárat, amely értesítéseket küld a háttérrendszerből.
A kiszolgálóprojektben nyissa meg a Controllers>TodoItemController.cs fájlt. Ezután adja hozzá a következő using utasításokat:
```
using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;
```

A PostTodoItem metódusban adja hozzá a következő kódot az InsertAsync hívása után:

// Get the settings for the server project.
HttpConfiguration config = this.Configuration;
MobileAppSettingsDictionary settings =
    this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();

// Get the Notification Hubs credentials for the mobile app.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
    .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

// Create a new Notification Hub client.
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

// Send the message so that all template registrations that contain "messageParam"
// receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
Dictionary<string,string> templateParams = new Dictionary<string,string>();
templateParams["messageParam"] = item.Text + " was added to the list.";

try
{
    // Send the push notification and log the results.
    var result = await hub.SendTemplateNotificationAsync(templateParams);

    // Write the success result to the logs.
    config.Services.GetTraceWriter().Info(result.State.ToString());
}
catch (System.Exception ex)
{
    // Write the failure result to the logs.
    config.Services.GetTraceWriter()
        .Error(ex.Message, null, "Push.SendAsync Error");
}

Ez a folyamat egy sablonértesítést küld, amely tartalmazza az elemet. Új elem beszúrásakor megjelenő szöveg.

Tegye közzé újra a kiszolgálóprojektet.

Node.js háttérprojekt

Állítsa be a háttérprojektet.

Cserélje le a todoitem.js meglévő kódját a következő kódra:

var azureMobileApps = require('azure-mobile-apps'),
promises = require('azure-mobile-apps/src/utilities/promises'),
logger = require('azure-mobile-apps/src/logger');

var table = azureMobileApps.table();

table.insert(function (context) {
// For more information about the Notification Hubs JavaScript SDK,
// see https://aka.ms/nodejshubs.
logger.info('Running TodoItem.insert');

// Define the template payload.
var payload = '{"messageParam": "' + context.item.text + '" }';  

// Execute the insert. The insert returns the results as a promise.
// Do the push as a post-execute action within the promise flow.
return context.execute()
    .then(function (results) {
        // Only do the push if configured.
        if (context.push) {
            // Send a template notification.
            context.push.send(null, payload, function (error) {
                if (error) {
                    logger.error('Error while sending push notification: ', error);
                } else {
                    logger.info('Push notification sent successfully!');
                }
            });
        }
        // Don't forget to return the results from the context.execute().
        return results;
    })
    .catch(function (error) {
        logger.error('Error while running context.execute: ', error);
    });
});

module.exports = table;

Ez a folyamat egy sablonértesítést küld, amely tartalmazza az item.text szöveget egy új elem beszúrásakor.

Amikor szerkeszti a fájlt a helyi számítógépen, tegye közzé újra a kiszolgálóprojektet.

Az ügyfélprojekt konfigurálása leküldéses értesítésekhez

A Megoldás nézetben (vagy a Visual Studióban Megoldáskezelő) kattintson a jobb gombbal az Összetevők mappára, válassza a További összetevők lekérése parancsot..., keresse meg a Google Cloud Messaging Client összetevőt, és adja hozzá a projekthez.
Nyissa meg a ToDoActivity.cs projektfájlt, és adja hozzá a következő using utasítást az osztályhoz:
```
using Gcm.Client;
```

A ToDoActivity osztályban adja hozzá a következő új kódot:

// Create a new instance field for this activity.
static ToDoActivity instance = new ToDoActivity();

// Return the current activity instance.
public static ToDoActivity CurrentActivity
{
    get
    {
        return instance;
    }
}
// Return the Mobile Services client.
public MobileServiceClient CurrentClient
{
    get
    {
        return client;
    }
}

Ez lehetővé teszi a mobil ügyfélpéldány elérését a leküldéses kezelő szolgáltatás folyamatából.

Adja hozzá a következő kódot az OnCreate metódushoz a MobileServiceClient létrehozása után:

// Set the current instance of TodoActivity.
instance = this;

// Make sure the GCM client is set up correctly.
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);

// Register the app for push notifications.
GcmClient.Register(this, ToDoBroadcastReceiver.senderIDs);

A ToDoActivity most már készen áll leküldéses értesítések hozzáadására.

Leküldéses értesítési kód hozzáadása az alkalmazáshoz

Hozzon létre egy új osztályt a projektben ToDoBroadcastReceiver.

Adja hozzá a következő using utasításokat a ToDoBroadcastReceiver osztályhoz:

using Gcm.Client;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;

Adja hozzá a következő engedélykérelmeket a using utasítások és a névtér deklarációja között:

[assembly: Permission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
[assembly: UsesPermission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
[assembly: UsesPermission(Name = "com.google.android.c2dm.permission.RECEIVE")]
//GET_ACCOUNTS is only needed for android versions 4.0.3 and below
[assembly: UsesPermission(Name = "android.permission.GET_ACCOUNTS")]
[assembly: UsesPermission(Name = "android.permission.INTERNET")]
[assembly: UsesPermission(Name = "android.permission.WAKE_LOCK")]

Cserélje le a meglévő ToDoBroadcastReceiver osztálydefiníciót a következőre:

[BroadcastReceiver(Permission = Gcm.Client.Constants.PERMISSION_GCM_INTENTS)]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_MESSAGE }, 
    Categories = new string[] { "@PACKAGE_NAME@" })]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_REGISTRATION_CALLBACK }, 
    Categories = new string[] { "@PACKAGE_NAME@" })]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_LIBRARY_RETRY }, 
Categories = new string[] { "@PACKAGE_NAME@" })]
public class ToDoBroadcastReceiver : GcmBroadcastReceiverBase<PushHandlerService>
{
    // Set the Google app ID.
    public static string[] senderIDs = new string[] { "<PROJECT_NUMBER>" };
}

A fenti kódban a Google által hozzárendelt projektszámra kell cserélnie <PROJECT_NUMBER> az alkalmazást a Google fejlesztői portálon való kiépítésekor.

A ToDoBroadcastReceiver.cs projektfájlban adja hozzá a következő kódot, amely meghatározza a PushHandlerService osztályt:
```
// The ServiceAttribute must be applied to the class.
[Service]
public class PushHandlerService : GcmServiceBase
{
    public static string RegistrationID { get; private set; }
    public PushHandlerService() : base(ToDoBroadcastReceiver.senderIDs) { }
}
```
Vegye figyelembe, hogy ez az osztály a GcmServiceBase-ből származik, és hogy a Service attribútumot kell alkalmazni erre az osztályra.

Megjegyzés

A GcmServiceBase osztály az OnRegistered(), OnUnRegistered(), OnMessage() és OnError() metódusokat implementálja. Ezeket a metódusokat felül kell bírálnia a PushHandlerService osztályban.

Adja hozzá a következő kódot a PushHandlerService osztályhoz, amely felülbírálja az OnRegistered eseménykezelőt .

protected override void OnRegistered(Context context, string registrationId)
{
    System.Diagnostics.Debug.WriteLine("The device has been registered with GCM.", "Success!");

    // Get the MobileServiceClient from the current activity instance.
    MobileServiceClient client = ToDoActivity.CurrentActivity.CurrentClient;
    var push = client.GetPush();

    // Define a message body for GCM.
    const string templateBodyGCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";

    // Define the template registration as JSON.
    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
    {
        {"body", templateBodyGCM }
    };

    try
    {
        // Make sure we run the registration on the same thread as the activity, 
        // to avoid threading errors.
        ToDoActivity.CurrentActivity.RunOnUiThread(

            // Register the template with Notification Hubs.
            async () => await push.RegisterAsync(registrationId, templates));

        System.Diagnostics.Debug.WriteLine(
            string.Format("Push Installation Id", push.InstallationId.ToString()));
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(
            string.Format("Error with Azure push registration: {0}", ex.Message));
    }
}

Ez a metódus a visszaadott GCM regisztrációs azonosítóval regisztrál az Azure-ban leküldéses értesítésekhez. Címkék csak a létrehozásuk után vehetők fel a regisztrációba. További információ : Címkék hozzáadása eszköztelepítéshez a leküldéses címkék engedélyezéséhez.

Bírálja felül az OnMessage metódust a PushHandlerService szolgáltatásban a következő kóddal:

protected override void OnMessage(Context context, Intent intent)
{
    string message = string.Empty;

    // Extract the push notification message from the intent.
    if (intent.Extras.ContainsKey("message"))
    {
        message = intent.Extras.Get("message").ToString();
        var title = "New item added:";

        // Create a notification manager to send the notification.
        var notificationManager = 
            GetSystemService(Context.NotificationService) as NotificationManager;

        // Create a new intent to show the notification in the UI. 
        PendingIntent contentIntent =
            PendingIntent.GetActivity(context, 0,
            new Intent(this, typeof(ToDoActivity)), 0);

        // Create the notification using the builder.
        var builder = new Notification.Builder(context);
        builder.SetAutoCancel(true);
        builder.SetContentTitle(title);
        builder.SetContentText(message);
        builder.SetSmallIcon(Resource.Drawable.ic_launcher);
        builder.SetContentIntent(contentIntent);
        var notification = builder.Build();

        // Display the notification in the Notifications Area.
        notificationManager.Notify(1, notification);

    }
}

Felülbírálja az OnUnRegistered() és az OnError() metódusokat az alábbi kóddal.

protected override void OnUnRegistered(Context context, string registrationId)
{
    throw new NotImplementedException();
}

protected override void OnError(Context context, string errorId)
{
    System.Diagnostics.Debug.WriteLine(
        string.Format("Error occurred in the notification: {0}.", errorId));
}

Leküldéses értesítések tesztelése az alkalmazásban

Az alkalmazást tesztelheti egy virtuális eszközzel az emulátorban. Emulátoron való futtatáskor további konfigurációs lépések szükségesek.

A virtuális eszköznek meg kell adnia a Google API-kat célként az Android virtual Device (AVD) kezelőjében.
Ha Google-fiókot szeretne hozzáadni az Android-eszközhöz, kattintson az Alkalmazások>beállításai>fiók hozzáadása elemre, majd kövesse az utasításokat.
Futtassa a teendőlista-alkalmazást a korábbiakhoz hasonlóan, és szúrjon be egy új teendőelemet. Ezúttal egy értesítési ikon jelenik meg az értesítési területen. Az értesítési fiók megnyitásával megtekintheti az értesítés teljes szövegét.

Megosztás a következőn keresztül: