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

  • Artikel

Översikt

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

Om du inte använder det nedladdade snabbstartsserverprojektet behöver du paketet med push-meddelandetillägget. Mer information finns i guiden Arbeta med .NET-serverdelsserverns SDK för Azure Mobile Apps .

Förutsättningar

Den här självstudien kräver konfigurationen:

Konfigurera en meddelandehubb

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

  1. I Azure Portal går du till App Services och väljer sedan appens serverdel. Under Inställningar väljer du Push.

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

    Konfigurera en hubb

Nu har du anslutit en meddelandehubb till mobile apps-backend-projektet. 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

  1. Logga in på Firebase-konsolen. Skapa ett nytt Firebase-projekt om du inte redan har ett.

  2. När du har skapat ett projekt väljer du Lägg till Firebase till din Android-app.

    Lägg till Firebase till din Android-app

  3. 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 com.fabrikam.fcmtutorial1appdet .

      Ange paketnamnet

    2. Välj Registrera app.

  4. Välj Ladda ned google-services.json, spara filen i appmappen för projektet och välj sedan Nästa.

    Ladda ned google-services.json

  5. Gör följande konfigurationsändringar i projektet i Android Studio.

    1. I filen build.gradle på projektnivå (<project>/build.gradle) lägger du till följande instruktion i avsnittet beroenden .

      classpath 'com.google.gms:google-services:4.0.1'

    2. I filen build.gradle på appnivå (<project>/<app-module>/build.gradle) lägger du till följande instruktioner i avsnittet beroenden .

      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.

      konfigurationsändringar för build.gradle

  6. Välj Nästa.

  7. Välj Hoppa över det här steget.

    Hoppa över det sista steget

  8. Välj kugghjulet för ditt projekt i Firebase-konsolen. Välj sedan Projektinställningar.

    Välj Projektinställningar

  9. Om du inte har laddat ned filen google-services.json till appmappen för ditt Android Studio-projekt kan du göra det på den här sidan.

  10. Växla till fliken Cloud Messaging längst upp.

  11. Kopiera och spara servernyckeln för senare användning. Du använder det här värdet för att konfigurera hubben.

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

  1. I Azure Portal klickar du på Bläddra bland alla>App Services och klickar sedan på mobile apps-serverdelen. Under Inställningar klickar du på App Service Push och sedan på namnet på meddelandehubben.

  2. Gå till Google (GCM), ange det servernyckelvärde som du fick från Firebase i föregående procedur och klicka sedan på Spara.

    Ange API-nyckeln i portalen

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-serverdelsprojekt för att skicka ett push-meddelande varje gång ett nytt objekt läggs till. Den här processen drivs av mallfunktionen i Azure Notification Hubs, som möjliggör plattformsoberoende push-meddelanden. 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 serverdelsprojekttyp– antingen .NET-serverdel eller Node.js serverdel.

.NET-serverdelsprojekt

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

  2. Öppna Controllers>TodoItemController.cs i serverprojektet. Lägg sedan till följande using-instruktioner:

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

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

  4. Publicera om serverprojektet.

Node.js serverdelsprojekt

  1. Konfigurera serverdelsprojektet.

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

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

Konfigurera klientprojektet för push-meddelanden

  1. I lösningsvyn (eller Solution Explorer i Visual Studio) högerklickar du på mappen Komponenter, klickar på Hämta fler komponenter..., söker efter Klientkomponenten för Google Cloud Messaging och lägger till den i projektet.

  2. Öppna projektfilen ToDoActivity.cs och lägg till följande using-instruktion i klassen :

    using Gcm.Client;

  3. Lägg till följande nya kod i klassen ToDoActivity :

    // 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-hanterartjänstprocessen.

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

  1. Skapa en ny klass i projektet med namnet ToDoBroadcastReceiver.

  2. Lägg till följande using-instruktioner i klassen ToDoBroadcastReceiver :

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

  3. Lägg till följande behörighetsbegäranden mellan using-instruktionerna 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")]

  4. Ersätt den befintliga ToDoBroadcastReceiver-klassdefinitionen 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 din app i Google Developer Portal.

  5. I projektfilen ToDoBroadcastReceiver.cs 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.

    Anteckning

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

  6. 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. Mer information finns i Så här lägger du till taggar i en enhetsinstallation för att aktivera push-to-tags.

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

    }
}

  8. Å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 krävs ytterligare konfigurationssteg när du kör på en emulator.

  1. Den virtuella enheten måste ha Google-API:er angivna som mål i hanteraren för virtuell Android-enhet (AVD).

  2. Lägg till ett Google-konto på Android-enheten genom att klicka påInställningar> för appar>Lägg till konto och följ sedan anvisningarna.

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