Přidejte oznámení push do vaší aplikace Xamarin.Android

Přehled

V tomto kurzu přidáte push oznámení do projektu Xamarin.Android rychlý start, aby se při každém vložení záznamu odeslalo push oznámení do zařízení.

Pokud zapnutý projekt rychlého startu serveru nepoužíváte, budete potřebovat balíček rozšíření pro push oznámení. Další informace najdete v příručce Práce se sadou SDK back-endového serveru .NET pro Azure Mobile Apps .

Požadavky

Tento kurz vyžaduje nastavení:

Aktivní účet Google. Účet Google si můžete zaregistrovat na accounts.google.com.
Klientská komponenta služby Google Cloud Messaging

Konfigurace centra oznámení

Funkce Mobile Apps služby Azure App Service používá Azure Notification Hubs k odesílání nabízených oznámení, takže pro mobilní aplikaci nakonfigurujete centrum oznámení.

Na webu Azure Portalpřejděte na App Services a pak vyberte back-end vaší aplikace. V části Nastavenívyberte Push.
Chcete-li do aplikace přidat centrum oznámení, vyberte Připojit. Můžete buď vytvořit centrum, nebo se připojit k existujícímu.

centra

Teď jste připojili centrum oznámení k back-endovém projektu Mobile Apps. Později toto centrum oznámení nakonfigurujete tak, aby se připojilo k systému oznámení platformy (PNS) pro nabízení do zařízení.

Povolení služby Firebase Cloud Messaging

Přihlaste se ke konzole Firebase. Vytvořte nový projekt Firebase, pokud jej ještě nemáte.
Po vytvoření projektu vyberte Add Firebase to your Android app (Přidat Firebase do aplikace pro Android).
Na stránce Přidat Firebase na stránku aplikace pro Android proveďte následující kroky:
1. Jako název balíčku pro Android zkopírujte hodnotu applicationId v souboru build.gradle vaší aplikace. V tomto příkladu je to com.fabrikam.fcmtutorial1app.
2. Vyberte Zaregistrovat aplikaci.
Vyberte Stáhnout google-services.json, uložte soubor do složky aplikace projektu a pak vyberte Další.
Proveďte následující změny konfigurace ve vašem projektu v Android Studiu.
1. Do souboru build.gradle na úrovni projektu (<project>/build.gradle) přidejte do oddílu závislostí následující příkaz.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Do souboru build.gradle na úrovni aplikace (project/app-module</build.gradle) přidejte do oddílu >.<>
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Po sekci 'dependencies' přidejte následující řádek na konec souboru build.gradle na úrovni aplikace.
```
apply plugin: 'com.google.gms.google-services'
```
4. Na panelu nástrojů vyberte Synchronizovat .
Vyberte Další.
Vyberte Přeskočit tento krok.
V konzole Firebase vyberte kolečko pro váš projekt. Potom vyberte Project Settings (Nastavení projektu).
Pokud jste soubor google-services.json nestáhli do složky aplikace projektu Android Studio, můžete to udělat na této stránce.
V horní části přepněte na kartu Cloudové zasílání zpráv .
Zkopírujte a uložte klíč serveru pro pozdější použití. Tuto hodnotu použijete ke konfiguraci centra.

Konfigurace Azure pro odesílání nabízených požadavků

Na portálu Azureklikněte na Procházet všechny>App Services a potom klikněte na back-end Mobilní aplikace. V části Nastaveníklikněte na App Service Pusha potom klikněte na název vašeho centra oznámení.
Přejděte na Google (GCM), zadejte hodnotu Server Key, kterou jste získali z Firebase v předchozím postupu, a potom klikněte na Uložit.

Back-end Mobile Apps je teď nakonfigurovaný tak, aby používal službu Firebase Cloud Messaging. To vám umožňuje odesílat push oznámení do vaší aplikace spuštěné na zařízení s Androidem pomocí centra oznámení.

Aktualizujte serverový projekt tak, aby odesílal push oznámení

V této části aktualizujete kód v existujícím back-endovém projektu Mobile Apps tak, aby se při každém přidání nové položky odeslalo nabízené oznámení. Tento proces využívá funkci šablony služby Azure Notification Hubs, která umožňuje nabízení mezi platformami. Různí klienti jsou registrováni pro push oznámení pomocí šablon a jedno univerzální oznámení může dorazit na všechny klientské platformy.

Zvolte jeden z následujících postupů, který odpovídá vašemu typu back-endového projektu – back-endu .NET nebo Node.js back-endu.

Back-endový projekt .NET

V sadě Visual Studio klikněte pravým tlačítkem myši na projekt serveru. Pak vyberte Spravovat balíčky NuGet. Vyhledejte Microsoft.Azure.NotificationHubspoložku a pak vyberte Nainstalovat. Tento proces nainstaluje knihovnu Notification Hubs pro odesílání oznámení z back-endu.

V projektu serveru otevřete kontrolery>TodoItemController.cs. Dále přidejte následující příkazy using:

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

V PostTodoItem metoda přidejte následující kód za volání 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");
}

Tento proces odešle šablonové oznámení, které obsahuje položku textu, když je vložena nová položka.

Znovu publikujte projekt serveru.

Node.js back-endový projekt

Nastavte back-endový projekt.

Nahraďte existující kód v todoitem.js následujícím kódem:

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;

Tento proces odešle oznámení šablony, které obsahuje položku.text při vložení nové položky.

Při úpravě souboru na místním počítači znovu publikujte projekt serveru.

Konfigurace klientského projektu pro nabízená oznámení

V zobrazení řešení (nebo v Průzkumníku řešení v sadě Visual Studio) klikněte pravým tlačítkem myši na složku Součásti , klikněte na Tlačítko Získat další komponenty..., vyhledejte komponentu Klienta služby Google Cloud Messaging a přidejte ji do projektu.
Otevřete soubor projektu ToDoActivity.cs a do třídy přidejte následující příkaz using:
```
using Gcm.Client;
```

Do třídy ToDoActivity přidejte následující nový kód:

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

To vám umožňuje přístup k instanci mobilního klienta z procesu služby zpracovatele push.

Po vytvoření MobileServiceClient přidejte do metody OnCreate následující kód:

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

Vaše funkce ToDoActivity je teď připravená na přidání nabízených oznámení.

Přidejte kód pro push oznámení do vaší aplikace

Vytvořte v projektu novou třídu s názvem ToDoBroadcastReceiver.

Do třídy ToDoBroadcastReceiver přidejte následující příkazy using:

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

Mezi příkazy using a deklaraci oboru názvů přidejte následující žádosti o oprávnění:

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

Nahraďte existující definici třídy ToDoBroadcastReceiver následujícím kódem:

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

Ve výše uvedeném kódu je nutné nahradit <PROJECT_NUMBER> číslem projektu přiřazeným Googlem, když jste aplikaci zřídili na portálu pro vývojáře Google.

Do souboru projektu ToDoBroadcastReceiver.cs přidejte následující kód, který definuje třídu 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) { }
}
```
Všimněte si, že tato třída je odvozena z GcmServiceBase a že service atribut musí být použita pro tuto třídu.

Poznámka:

GcmServiceBase třída implementuje OnRegistered(), OnUnRegistered(), OnMessage() a OnError(). Tyto metody je nutné přepsat ve třídě PushHandlerService .

Do třídy PushHandlerService , která přepíše obslužnou rutinu události OnRegistered , přidejte následující kód.

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

Tato metoda používá vrácené ID registrace GCM k registraci v Azure pro nabízená oznámení. Značky je možné přidat do registrace pouze po jeho vytvoření. Další informace najdete v tématu Postup: Přidání značek do instalace zařízení pro aktivaci push-to-tags.

Přepište metodu OnMessage v PushHandlerService následujícím kódem:

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

    }
}

Přepište metody OnUnRegistered() a OnError() tímto kódem.

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

Testování push oznámení ve vaší aplikaci

Aplikaci můžete otestovat pomocí virtuálního zařízení v emulátoru. Při spuštění v emulátoru jsou vyžadovány další kroky konfigurace.

Virtuální zařízení musí mít Google API nastavená jako cíl ve správci Android Virtual Device (AVD).
Přidejte do zařízení s Androidem účet Google kliknutím na Aplikace>Nastavení>Přidat účet, a postupujte podle pokynů.
Spusťte aplikaci seznamu úkolů jako předtím a vložte novou položku úkolu. Tentokrát se v oznamovací oblasti zobrazí ikona oznámení. Pokud chcete zobrazit celý text oznámení, můžete otevřít zásuvku oznámení.

Last updated on 2019-06-25

Sdílet prostřednictvím