Lägga till push-meddelanden i Xamarin.Android-appen

2019-06-25

Översikt

I den här handledningen lägger du till push-meddelanden i Xamarin.Android-projektet så att ett push-meddelande skickas till enheten varje gång en post läggs till.

Om du inte använder det nedladdade snabbstartsserverprojektet behöver du paketet med push-meddelandetillägget. Mer information finns i Work with the .NET backend server SDK for Azure Mobile Apps guide.

Förutsättningar

Den här handledningen kräver att åtgärder vidtas.

Ett aktivt Google-konto. Du kan registrera dig för ett Google-konto på accounts.google.com.
Klientkomponent för Google Cloud Messaging.

Konfigurera en meddelandehubb

Funktionen Mobile Apps i Azure App Service använder Azure Notification Hubs för att skicka push-meddelanden, så du konfigurerar en meddelandehubb för din mobilapp.

I Azure-portalengår du till App Servicesoch väljer sedan appens serverdel. Under Inställningarväljer du Push.
Om du vill lägga till en meddelandehubbresurs i appen väljer du Anslut. Du kan antingen skapa en hubb eller ansluta till en befintlig.

Nu har du anslutit en meddelandehubb till ditt Mobile Apps-backend-projekt. Senare konfigurerar du den här meddelandehubben för att ansluta till ett plattformsmeddelandesystem (PNS) för att skicka till enheter.

Aktivera Firebase Cloud Messaging

Logga in på Firebase-konsolen. Skapa ett nytt Firebase-projekt om du inte redan har ett.
När du har skapat ett projekt väljer du Lägg till Firebase till din Android-app.
På sidan Lägg till Firebase i din Android-app utför du följande steg:
1. För Android-paketnamn kopierar du värdet för ditt applicationId i programmets build.gradle-fil. I det här exemplet är det com.fabrikam.fcmtutorial1app.
2. Välj Registrera app.
Välj Ladda ned google-services.json, spara filen i appmappen för projektet och välj sedan Nästa.
Gör följande konfigurationsändringar i projektet i Android Studio.
1. I din build.gradle-fil på projektnivå (<project>/build.gradle) lägger du till följande sats i avsnittet beroenden.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. I filen build.gradle på appens nivå (<project>/<app-module>/build.gradle) lägger du till följande uttalanden i avsnittet dependencies.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Lägg till följande rad i slutet av filen build.gradle på appnivå efter avsnittet beroenden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Välj Synkronisera nu i verktygsfältet.
Välj Nästa.
Välj Hoppa över det här steget.
Välj kugghjulet för ditt projekt i Firebase-konsolen. Välj sedan Projektinställningar.
Om du inte har laddat ned google-services.json-filen till appmappen för ditt Android Studio-projekt kan du göra det på den här sidan.
Växla till fliken Cloud Messaging längst upp.
Kopiera och spara servernyckeln för senare användning. Du använder det här värdet för att konfigurera din hubb.

Konfigurera Azure för att skicka push-begäranden

I Azure-portalenklickar du på Bläddra>App-tjänsteroch klickar sedan på Mobile Apps-serverdelen. Under Inställningarklickar du på App Service Pushoch klickar sedan på namnet på meddelandehubben.
Gå till Google (GCM), ange värdet servernyckel som du hämtade från Firebase i föregående procedur och klicka sedan på Spara.

Mobile Apps-serverdelen är nu konfigurerad för att använda Firebase Cloud Messaging. På så sätt kan du skicka push-meddelanden till din app som körs på en Android-enhet med hjälp av meddelandehubben.

Uppdatera serverprojektet för att skicka push-meddelanden

I det här avsnittet uppdaterar du koden i ditt befintliga Mobile Apps-backend-projekt för att skicka ett push-meddelande varje gång ett nytt objekt läggs till. Den här processen drivs av -mallen funktion i Azure Notification Hubs, som möjliggör plattformsoberoende push-överföring. De olika klienterna registreras för push-meddelanden med hjälp av mallar, och en enda universell push-överföring kan komma till alla klientplattformar.

Välj någon av följande procedurer som matchar din typ av backend-projekt – antingen .NET-serverdel eller Node.js serverdel.

.NET-backend-projekt

Högerklicka på serverprojektet i Visual Studio. Välj sedan Hantera NuGet-paket. Sök efter Microsoft.Azure.NotificationHubsoch välj sedan Installera. Den här processen installerar Notification Hubs-biblioteket för att skicka meddelanden från serverdelen.

I serverprojektet öppnar du Controllers>TodoItemController.cs. Lägg sedan till följande using-direktiv:

using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;

I metoden PostTodoItem lägger du till följande kod efter anropet till InsertAsync:

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

Den här processen skickar ett mallmeddelande som innehåller objektet. Text när ett nytt objekt infogas.

Återpublicera serverprojektet.

Node.js backend-projekt

Konfigurera ditt backend-projekt.

Ersätt den befintliga koden i todoitem.js med följande kod:

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;

Den här processen skickar ett mallmeddelande som innehåller item.text när ett nytt objekt infogas.

När du redigerar filen på den lokala datorn publicerar du serverprojektet igen.

Konfigurera klientprojektet för push-meddelanden

I lösningsvyn (eller Solution Explorer i Visual Studio) högerklickar du på mappen Components, klickar på Hämta fler komponenter..., söker efter komponenten Google Cloud Messaging Client och lägger till den i projektet.
Öppna ToDoActivity.cs-projektfilen och lägg till följande using-förklaring i klassen:
```
using Gcm.Client;
```

I klassen ToDoActivity lägger du till följande nya kod:

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

På så sätt kan du komma åt den mobila klientinstansen från push-hanteringstjänsten.

Lägg till följande kod i metoden OnCreate när MobileServiceClient- har skapats:

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

Din ToDoActivity- är nu förberedd för att lägga till push-meddelanden.

Lägga till kod för push-meddelanden i din app

Skapa en ny klass i projektet med namnet ToDoBroadcastReceiver.

Lägg till följande användningsinstruktioner i ToDoBroadcastReceiver-klass:

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

Lägg till följande behörighetsbegäranden mellan using-satser och namnområdesdeklarationen:

[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")]

Ersätt den befintliga klassdefinitionen ToDoBroadcastReceiver med följande:

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

I koden ovan måste du ersätta <PROJECT_NUMBER> med det projektnummer som tilldelats av Google när du etablerade appen i Googles utvecklarportal.

I ToDoBroadcastReceiver.cs-projektfilen lägger du till följande kod som definierar klassen PushHandlerService:
```
// 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) { }
}
```
Observera att den här klassen härleds från GcmServiceBase- och att attributet Service måste tillämpas på den här klassen.

Anmärkning

Klassen GcmServiceBase implementerar OnRegistered(), OnUnRegistered(), OnMessage() och OnError() metoder. Du måste åsidosätta dessa metoder i klassen PushHandlerService.

Lägg till följande kod i klassen PushHandlerService som åsidosätter händelsehanteraren OnRegistered.

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

Den här metoden använder det returnerade GCM-registrerings-ID:t för att registrera med Azure för push-meddelanden. Taggar kan bara läggas till i registreringen när den har skapats. För mer information, se Hur du lägger till taggar i en enhetsinstallation för att aktivera push-to-tags.

Åsidosätt metoden OnMessage i PushHandlerService med följande kod:

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

    }
}

Åsidosätt metoderna OnUnRegistered() och OnError() med följande kod.

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

Testa push-meddelanden i din app

Du kan testa appen med hjälp av en virtuell enhet i emulatorn. Det finns ytterligare konfigurationssteg som krävs när du kör en emulator.

Den virtuella enheten måste ha Google API:er inställda som mål i AVD-hanteraren (Android Virtual Device).
Lägg till ett Google-konto på Android-enheten genom att klicka på Appar>Inställningar>Lägg till kontooch följ sedan anvisningarna.
Kör todolist-appen som tidigare och infoga ett nytt att göra-objekt. Den här gången visas en meddelandeikon i meddelandefältet. Du kan öppna meddelandelådan för att visa hela texten i meddelandet.

Dela via