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

Android
Cordova
Ios
Windows
Xamarin.Android
Xamarin.iOS
Xamarin.Forms

Přehled

V tomto kurzu přidáte push notifikace do projektu Android rychlý start, aby se oznámení odeslalo do zařízení pokaždé, když je vložen nový záznam.

Pokud nepoužíváte stažený projekt serveru rychlý start, potřebujete balíček rozšíření pro push oznámení. Další informace najdete v tématu Práce se sadou SDK pro .NET backend server 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ším, pokud má tato aplikace back-end Microsoft .NET.
Android 2.3 nebo novější, úložiště Google revize 27 nebo novější a služby Google Play 9.0.2 nebo novější pro Službu 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 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ší.
V Android Studiu proveďte následující konfigurační změny.
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 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í.

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

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

Povolit push oznámení pro serverový projekt

Použijte postup, který odpovídá typu vašeho projektu – buď pro rozhraní .NET back-end , nebo pro Node.js back-end.

Back-endový projekt .NET

V aplikaci Visual Studio klikněte pravým tlačítkem na projekt serveru a klikněte na Spravovat balíčky NuGet. Vyhledejte Microsoft.Azure.NotificationHubsa klikněte na Nainstalovat. Tím se nainstaluje klientská knihovna Notification Hubs.
Ve složce Kontrolery otevřete TodoItemController.cs a přidejte následující příkazy using:
```
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 item.text při vložení nové položky úkolu.

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

Přidejte push notifikace do vaší aplikace

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

Ověření verze sady Android SDK

Vzhledem k probíhajícímu vývoji nemusí verze sady Android SDK nainstalovaná v android Studiu odpovídat verzi v kódu. Sada Android SDK, na kterou odkazuje tento kurz, je ve verzi 26, nejnovější 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 mohou zobrazit chybové zprávy Gradle, jako je Gradle sync failed: Failed to find target with hash string 'android-XX'.
Standardní objekty Androidu v kódu, které by se měly vyhodnotit na základě příkazů import, mohou generovat chybové zprávy.

Pokud se zobrazí některé z těchto možností, verze sady Android SDK nainstalovaná v android Studiu nemusí 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 Tools>Android>SDK Manager. Pokud jste nenainstalovali nejnovější verzi platformy sady SDK, klikněte na ni a nainstalujte ji. Poznamenejte si číslo verze.
Na kartě Project Explorer otevřete v oddílu Gradle Scriptssoubor build.gradle (Module: app). Ujistěte se, že compileSdkVersion a targetSdkVersion jsou nastavené na nejnovější nainstalovanou verzi sady SDK. build.gradle může vypadat takto:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

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

Pokud testujete pomocí staršího zařízení, obraťte se na Přidat Firebase do vašeho Android projektu, 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 zvolte File>Project Structure. Vyberte Oznámení, zvolte Firebase Cloud Messaginga klikněte na OK.

Přidání kódu

V aplikaci projektu otevřete soubor AndroidManifest.xml. Za počáteční značku application 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 MobileServiceClient z privátního na privátní statické, takže teď vypadá takto:
```
private static MobileServiceClient mClient;
```

Přidat metodu registerPush:

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 onCreate třídy ToDoActivity. Nezapomeňte přidat tento kód po vytvoření instance MobileServiceClient.
```
registerPush();
```

Přidejte novou třídu pro zpracování oznámení. V Project Exploreru otevřete aplikaci >java>uzly oboru názvů projektu a klikněte pravým tlačítkem na uzel názvu balíčku. Klepněte na tlačítko Novýa poté klepněte na tlačítko třídy Java. Do pole Název zadejte ToDoMessagingServicea klepněte na tlačítko OK. Pak nahraďte deklaraci třídy:

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 je teď aktualizovaná 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 jednom z následujících kurzů:

Přidat ověřování do aplikace pro Android. Zjistěte, jak přidat ověřování do projektu rychlého startu todolist v Androidu pomocí podporovaného zprostředkovatele identity.
Povolit 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 není k dispozici.

Last updated on 2019-06-25

Sdílet prostřednictvím