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

Článek
06/25/2019

Přehled

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

Pokud stažený projekt rychlého startu nepoužíváte, potřebujete balíček rozšíření nabízených oznámení. Další informace najdete v tématu Práce se sadou SDK back-endového serveru .NET pro Azure Mobile Apps.

Požadavky

Potřebujete následující:

Integrované vývojové prostředí (IDE) v závislosti na back-endu projektu:
- Android Studio , pokud má tato aplikace Node.js back-end.
- Visual Studio Community 2013 nebo novější, pokud má tato aplikace back-end Microsoft .NET.
Android 2.3 nebo novější, Google Repository revision 27 nebo novější a Google Play Services 9.0.2 nebo novější pro Firebase Cloud Messaging.
Dokončete rychlý start pro Android.

Vytvoření projektu, který podporuje službu 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 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í.

Konfigurace Azure pro odesílání nabízených oznámení

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

Povolení nabízených oznámení pro serverový projekt

Použijte 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 na projekt serveru a klikněte na Spravovat balíčky NuGet. Vyhledejte Microsoft.Azure.NotificationHubspoložku a potom klepněte na tlačítko Nainstalovat. Tím se nainstaluje klientská knihovna Notification Hubs.
Ve složce Controllers otevřete TodoItemController.cs a přidejte následující using příkazy:
```
using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;
```

Nahraďte metodu PostTodoItem následujícím kódem:

public async Task<IHttpActionResult> PostTodoItem(TodoItem item)
{
    TodoItem current = await InsertAsync(item);
    // 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);

    // Android payload
    var androidNotificationPayload = "{ \"data\" : {\"message\":\"" + item.Text + "\"}}";

    try
    {
        // Send the push notification and log the results.
        var result = await hub.SendGcmNativeNotificationAsync(androidNotificationPayload);

        // 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");
    }
    return CreatedAtRoute("Tables", new { id = current.Id }, current);
}

Znovu publikujte projekt serveru.

Node.js back-endový projekt

Nastavte back-endový projekt.

Nahraďte existující kód v souboru 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 GCM payload.
var payload = {
    "data": {
        "message": 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 GCM native notification.
            context.push.gcm.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;

Tím se odešle oznámení GCM, které obsahuje položku.text při vložení nové položky úkolu.

Při úpravě souboru v místním počítači znovu publikujte serverový projekt.

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

V této části aktualizujete klientskou aplikaci pro Android tak, aby zpracovávala nabízená oznámení.

Ověření verze sady Android SDK

Kvůli probíhajícímu vývoji nemusí verze sady Android SDK nainstalovaná v Android Studiu odpovídat verzi v kódu. Sada Android SDK odkazovaná v tomto kurzu je verze 26, nejpozději v době psaní. Číslo verze se může zvýšit, jakmile se zobrazí nové verze sady SDK, a doporučujeme použít nejnovější dostupnou verzi.

Mezi dva příznaky neshody verzí patří:

Při sestavování nebo opětovném sestavení projektu se můžou zobrazit chybové zprávy Gradle, jako Gradle sync failed: Failed to find target with hash string 'android-XX'je .
Standardní objekty Androidu v kódu, které by se měly vyřešit na import základě příkazů, můžou generovat chybové zprávy.

Pokud se zobrazí některý z těchto nástrojů, nemusí verze sady Android SDK nainstalovaná v Android Studiu odpovídat cíli sady SDK staženého projektu. Pokud chcete ověřit verzi, proveďte následující změny:

V Android Studiu klikněte na Nástroje Android>>SDK Manager. Pokud jste nenainstalovali nejnovější verzi platformy sady SDK, klikněte na ni. Poznamenejte si číslo verze.
Na kartě Průzkumník projektu otevřete v části Gradle Scripts soubor build.gradle (modul: aplikace). Ujistěte se, že jsou kompilátorYdkVersion a targetSdkVersion nastavené na nejnovější nainstalovanou verzi sady SDK. Může build.gradle vypadat takto:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

Dalším krokem je instalace služeb Google Play. Firebase Cloud Messaging má určité minimální požadavky na úroveň rozhraní API pro vývoj a testování, které vlastnost minSdkVersion v manifestu musí odpovídat.

Pokud testujete se starším zařízením, obraťte se na add Firebase do vašeho Android Projectu , abyste zjistili, jak nízkou hodnotu můžete nastavit, a nastavte ji odpovídajícím způsobem.

Přidání služby Firebase Cloud Messaging do projektu

Přidání Firebase do projektu Androidu
V Android Studiu zvolteStruktura projektusouborů>. Vyberte Oznámení, vyberte Firebase Cloud Messaging a potom klepněte na tlačítko OK.

Přidání kódu

V projektu aplikace otevřete soubor AndroidManifest.xml. Za levou application značku přidejte následující kód:

<service android:name=".ToDoMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>
<service android:name=".ToDoInstanceIdService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service>

Otevřete soubor ToDoActivity.javaa proveďte následující změny:

Přidejte příkaz importu:

import com.google.firebase.iid.FirebaseInstanceId;

Změňte definici privátní na MobileServiceClientsoukromou statickou, takže teď vypadá takto:
```
private static MobileServiceClient mClient;
```

Přidat registerPush metodu:

public static void registerPush() {
    final String token = FirebaseInstanceId.getInstance().getToken();
    if (token != null) {
        new AsyncTask<Void, Void, Void>() {
            protected Void doInBackground(Void... params) {
                mClient.getPush().register(token);
                return null;
            }
        }.execute();
    }
}

Aktualizujte metodu ToDoActivityonCreate třídy. Po vytvoření instance nezapomeňte tento kód MobileServiceClient přidat.
```
registerPush();
```

Přidejte novou třídu pro zpracování oznámení. V Průzkumníku projektů otevřete aplikaci>java>uzly oboru názvů projektu a klikněte pravým tlačítkem myši na uzel názvu balíčku. Klepněte na tlačítko Nový a potom klepněte na položku Třída Java. Do pole Název zadejte ToDoMessagingServicea klepněte na tlačítko OK. Potom deklaraci třídy nahraďte:

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class ToDoMessagingService extends FirebaseMessagingService {

    private static final int NOTIFICATION_ID = 1;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        String message = remoteMessage.getData().get("message");
        if (message != null) {
            sendNotification("Notification Hub Demo", message);
        }
    }

    private void sendNotification(String title, String messageBody) {
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, ToDoActivity.class), 0);
        Notification.Builder notificationBuilder = new Notification.Builder(this)
                .setSmallIcon(R.drawable.ic_launcher)
                .setContentTitle(title)
                .setContentText(messageBody)
                .setContentIntent(contentIntent);
        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        if (notificationManager != null) {
            notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
        }
    }
}

Přidejte další třídu pro zpracování aktualizací tokenů. Vytvořte ToDoInstanceIdService třídu Java a nahraďte deklaraci třídy:

import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

    @Override
    public void onTokenRefresh() {
        ToDoActivity.registerPush();
    }
}

Vaše aplikace se teď aktualizuje tak, aby podporovala nabízená oznámení.

Otestování aplikace proti publikované mobilní službě

Aplikaci můžete otestovat tak, že přímo připojíte telefon s Androidem pomocí kabelu USB nebo pomocí virtuálního zařízení v emulátoru.

Další kroky

Teď, když jste dokončili tento kurz, zvažte pokračování v některém z následujících kurzů:

Přidejte ověřování do aplikace pro Android. Zjistěte, jak přidat ověřování do projektu rychlý start todolist v Androidu pomocí podporovaného zprostředkovatele identity.
Povolte offline synchronizaci pro aplikaci pro Android. Zjistěte, jak do aplikace přidat offline podporu pomocí back-endu Mobile Apps. Při offline synchronizaci můžou uživatelé pracovat s mobilní aplikací – prohlížením, přidáváním nebo úpravou dat – i v případě, že připojení k síti neexistuje.

Share via