Přidání nabízených oznámení do aplikace Xamarin.Android

Článek
06/25/2019

Přehled

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

Pokud stažený projekt serveru rychlý start nepoužíváte, budete potřebovat balíček rozšíření nabízených oznámení. Další informace najdete v příručce Work with the .NET back-end server SDK for Azure Mobile Apps .

Požadavky

Tento kurz vyžaduje nastavení:

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

Konfigurace centra oznámení

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

V Azure Portal přejděte do App Services a pak vyberte back-end vaší aplikace. V části Nastavení vyberte Nabízená oznámení.
Pokud chcete do aplikace přidat prostředek centra oznámení, vyberte Připojit. Můžete buď vytvořit centrum, nebo se připojit k existujícímu.

Teď jste připojili centrum oznámení k back-endovém projektu Mobile Apps. Později nakonfigurujete toto centrum oznámení 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 com.fabrikam.fcmtutorial1appto .
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 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 závislostí následující příkazy .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Na konec souboru build.gradle na úrovni aplikace přidejte následující řádek za oddíl závislostí.
```
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 si 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 Cloud Messaging .
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 žádostí

V Azure Portal klikněte na Procházet všechny>služby App Services a potom klikněte na back-end Mobile Apps. V části Nastavení klikněte na App Service Nabízené oznámení a potom klikněte na název centra oznámení.
Přejděte na Google (GCM), zadejte hodnotu klíče serveru , 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. Díky tomu můžete odesílat nabízená oznámení do aplikace spuštěné na zařízení s Androidem pomocí centra oznámení.

Aktualizace projektu serveru tak, aby odesílala nabízená oznámení

V této části aktualizujete kód v existujícím back-endovém projektu Mobile Apps tak, aby se po 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 zaregistrovaní pro nabízená oznámení pomocí šablon a jedno univerzální nabízení se může dostat do všech klientských platforem.

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.NotificationHubsa pak vyberte Nainstalovat. Tento proces nainstaluje knihovnu Notification Hubs pro odesílání oznámení z back-endu.

V projektu serveru otevřete Controllers>TodoItemController.cs. Pak 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 oznámení šablony, které obsahuje položku. Text při vložení nové položky

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 Průzkumník řešení v sadě Visual Studio) klikněte pravým tlačítkem 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 přidejte do třídy 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 umožňuje přístup k instanci mobilního klienta z procesu služby obslužné rutiny nabízených oznámení.

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

// 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řidání kódu nabízených oznámení do 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;

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

[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> číslo projektu přiřazené 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 od GcmServiceBase a že service atribut musí být použit pro tuto třídu.

Poznámka

Třída GcmServiceBase implementuje metody 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 jenom po jeho vytvoření. Další informace najdete v tématu Postupy: Přidání značek do instalace zařízení pro povolení nabízených změn do značek.

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() následujícím 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í nabízených oznámení v aplikaci

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

Virtuální zařízení musí mít rozhraní GOOGLE API nastavená jako cíl ve správci virtuálního zařízení s Androidem (AVD).
Přidejte do zařízení s Androidem účet Google kliknutím naTlačítko Přidat nastavení>aplikací> a postupujte podle pokynů.
Spusťte aplikaci todolist jako předtím a vložte novou položku úkolu. Tentokrát se v oznamovací oblasti zobrazí ikona oznámení. Můžete otevřít zásuvku oznámení a zobrazit celý text oznámení.