Dodawanie powiadomień wypychanych do aplikacji platformy Xamarin.Android

Artykuł
06/25/2019

Omówienie

W tym samouczku dodasz powiadomienia wypychane do projektu szybkiego startu platformy Xamarin.Android , aby powiadomienie wypychane było wysyłane do urządzenia za każdym razem, gdy rekord zostanie wstawiony.

Jeśli nie używasz pobranego projektu serwera szybkiego startu, potrzebny będzie pakiet rozszerzenia powiadomień wypychanych. Aby uzyskać więcej informacji, zobacz przewodnik Work with the .NET backend server SDK for Azure Mobile Apps (Praca z zestawem SDK serwera zaplecza platformy .NET dla usługi Azure Mobile Apps ).

Wymagania wstępne

Ten samouczek wymaga konfiguracji:

Aktywne konto Google. Konto Google można zarejestrować w accounts.google.com.
Składnik klienta usługi Google Cloud Messaging.

Konfigurowanie centrum powiadomień

Funkcja Mobile Apps Azure App Service używa usługi Azure Notification Hubs do wysyłania wypychań, dlatego skonfigurujesz centrum powiadomień dla aplikacji mobilnej.

W Azure Portal przejdź do usługi App Services, a następnie wybierz zaplecze aplikacji. W obszarze Ustawienia wybierz pozycję Wypychanie.
Aby dodać zasób centrum powiadomień do aplikacji, wybierz pozycję Połącz. Możesz utworzyć koncentrator lub połączyć się z istniejącym.

Teraz połączono centrum powiadomień z projektem zaplecza usługi Mobile Apps. Później skonfigurujesz to centrum powiadomień, aby nawiązać połączenie z systemem powiadomień platformy (PNS) w celu wypychania do urządzeń.

Włączanie usługi Firebase Cloud Messaging

Zaloguj się do konsoli Firebase. Utwórz nowy projekt Firebase, jeśli jeszcze go nie masz.
Po utworzeniu projektu wybierz pozycję Dodaj Firebase do swojej aplikacji dla systemu Android.
Na stronie Dodawanie aplikacji Firebase do aplikacji systemu Android wykonaj następujące kroki:
1. W polu Nazwa pakietu systemu Android skopiuj wartość identyfikatora applicationId w pliku build.gradle aplikacji. W tym przykładzie jest com.fabrikam.fcmtutorial1appto .
2. Wybierz pozycję Zarejestruj aplikację.
Wybierz pozycję Pobierz plik google-services.json, zapisz plik w folderze aplikacji projektu, a następnie wybierz pozycję Dalej.
Wprowadź następujące zmiany konfiguracji w projekcie w programie Android Studio.
1. W pliku build.gradle na poziomie projektu (<project>/build.gradle) dodaj następującą instrukcję do sekcji zależności .
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. W pliku build.gradle na poziomie aplikacji (<project>/<app-module>/build.gradle) dodaj następujące instrukcje do sekcji zależności.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Dodaj następujący wiersz na końcu pliku build.gradle na poziomie aplikacji po sekcji zależności.
```
apply plugin: 'com.google.gms.google-services'
```
4. Wybierz pozycję Synchronizuj teraz na pasku narzędzi.
Wybierz opcję Dalej.
Wybierz pozycję Pomiń ten krok.
W konsoli usługi Firebase wybierz koło zębate dla projektu. Następnie wybierz pozycję Ustawienia projektu.
Jeśli plik google-services.json nie został pobrany do folderu aplikacji projektu programu Android Studio, możesz to zrobić na tej stronie.
Przejdź do karty Cloud Messaging (Obsługa komunikatów w chmurze ) u góry.
Skopiuj i zapisz klucz serwera do późniejszego użycia. Ta wartość służy do konfigurowania centrum.

Konfigurowanie platformy Azure do wysyłania żądań wypychania

W Azure Portal kliknij pozycję Przeglądaj wszystkie>usługi App Services, a następnie kliknij zaplecze usługi Mobile Apps. W obszarze Ustawienia kliknij pozycję App Service Wypychanie, a następnie kliknij nazwę centrum powiadomień.
Przejdź do pozycji Google (GCM) i wprowadź wartość klucza serwera uzyskaną z bazy firebase w poprzedniej procedurze, a następnie kliknij przycisk Zapisz.

Zaplecze usługi Mobile Apps jest teraz skonfigurowane do korzystania z usługi Firebase Cloud Messaging. Dzięki temu można wysyłać powiadomienia wypychane do aplikacji uruchomionej na urządzeniu z systemem Android przy użyciu centrum powiadomień.

Aktualizowanie projektu serwera w celu wysyłania powiadomień wypychanych

W tej sekcji zaktualizujesz kod w istniejącym projekcie zaplecza usługi Mobile Apps, aby wysyłać powiadomienie wypychane za każdym razem, gdy zostanie dodany nowy element. Ten proces jest obsługiwany przez funkcję szablonu usługi Azure Notification Hubs, która umożliwia wypychanie międzyplatformowe. Różni klienci są zarejestrowani pod kątem powiadomień wypychanych przy użyciu szablonów, a pojedyncze uniwersalne wypychanie może zostać wyświetlone na wszystkich platformach klienckich.

Wybierz jedną z poniższych procedur pasujących do typu projektu zaplecza — zaplecza platformy .NET lub Node.js zaplecza.

Projekt zaplecza platformy .NET

W programie Visual Studio kliknij prawym przyciskiem myszy projekt serwera. Następnie wybierz pozycję Zarządzaj pakietami NuGet. Wyszukaj ciąg Microsoft.Azure.NotificationHubs, a następnie wybierz pozycję Zainstaluj. Ten proces instaluje bibliotekę usługi Notification Hubs na potrzeby wysyłania powiadomień z zaplecza.

W projekcie serwera otwórz plik Controllers>TodoItemController.cs. Następnie dodaj następujące instrukcje using:

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

W metodzie PostTodoItem dodaj następujący kod po wywołaniu metody 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");
}

Ten proces wysyła powiadomienie o szablonie zawierające element. Tekst po wstawieniu nowego elementu.

Opublikuj ponownie projekt serwera.

Node.js projekt zaplecza

Skonfiguruj projekt zaplecza.

Zastąp istniejący kod w todoitem.js następującym kodem:

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;

Ten proces wysyła powiadomienie o szablonie zawierające element.text po wstawieniu nowego elementu.

Podczas edytowania pliku na komputerze lokalnym ponownie opublikuj projekt serwera.

Konfigurowanie projektu klienta pod kątem powiadomień wypychanych

W widoku Rozwiązania (lub Eksplorator rozwiązań w programie Visual Studio) kliknij prawym przyciskiem myszy folder Components, kliknij pozycję Pobierz więcej składników..., wyszukaj składnik Klienta usługi Google Cloud Messaging i dodaj go do projektu.
Otwórz plik projektu ToDoActivity.cs i dodaj następującą instrukcję using do klasy:
```
using Gcm.Client;
```

W klasie ToDoActivity dodaj następujący nowy 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;
    }
}

Umożliwia to dostęp do wystąpienia klienta mobilnego z procesu obsługi wypychanej.

Dodaj następujący kod do metody OnCreate po utworzeniu klasy MobileServiceClient :

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

Funkcja ToDoActivity jest teraz przygotowana do dodawania powiadomień wypychanych.

Dodawanie kodu powiadomień wypychanych do aplikacji

Utwórz nową klasę w projekcie o nazwie ToDoBroadcastReceiver.

Dodaj następujące instrukcje using do klasy ToDoBroadcastReceiver :

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

Dodaj następujące żądania uprawnień między instrukcjami using i deklaracją przestrzeni nazw :

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

Zastąp istniejącą definicję klasy ToDoBroadcastReceiver następującymi elementami:

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

W powyższym kodzie należy zastąpić <PROJECT_NUMBER> ciąg numerem projektu przypisanym przez firmę Google podczas aprowizowania aplikacji w portalu deweloperów Google.

W pliku projektu ToDoBroadcastReceiver.cs dodaj następujący kod definiujący klasę 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) { }
}
```
Należy pamiętać, że ta klasa pochodzi z bazy danych GcmServiceBase i że do tej klasy należy zastosować atrybut Service .

Uwaga

Klasa GcmServiceBase implementuje metody OnRegistered(), OnUnRegistered(), OnMessage() i OnError(). Należy zastąpić te metody w klasie PushHandlerService .

Dodaj następujący kod do klasy PushHandlerService , która zastępuje procedurę obsługi zdarzeń 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));
    }
}

Ta metoda używa zwróconego identyfikatora rejestracji usługi GCM do zarejestrowania się na platformie Azure na potrzeby powiadomień wypychanych. Tagi można dodawać tylko do rejestracji po jej utworzeniu. Aby uzyskać więcej informacji, zobacz How to: Add tags to a device installation to enable push-to-tags (Instrukcje: dodawanie tagów do instalacji urządzenia w celu włączenia tagów wypychanych do tagów).

Zastąp metodę OnMessage w metodzie PushHandlerService następującym kodem:

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

    }
}

Zastąpij metody OnUnRegistered() i OnError() przy użyciu następującego kodu.

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

Testowanie powiadomień wypychanych w aplikacji

Aplikację można przetestować przy użyciu urządzenia wirtualnego w emulatorze. Podczas uruchamiania w emulatorze są wymagane dodatkowe kroki konfiguracji.

Urządzenie wirtualne musi mieć ustawione interfejsy API Google jako element docelowy w menedżerze urządzenia wirtualnego z systemem Android (AVD).
Dodaj konto Google na urządzeniu z systemem Android, klikając pozycjęUstawienia>aplikacji>Dodaj konto, a następnie postępuj zgodnie z monitami.
Uruchom aplikację todolist tak jak wcześniej i wstaw nowy element do wykonania. Tym razem w obszarze powiadomień zostanie wyświetlona ikona powiadomienia. Możesz otworzyć szufladę powiadomień, aby wyświetlić pełny tekst powiadomienia.