Lägga till push-meddelanden i din Android-app

2019-06-25

Översikt

I den här handledningen lägger du till push-meddelanden i Androids snabbstartprojekt så att ett push-meddelande skickas till enheten varje gång en post läggs till.

Om du inte använder det nedladdade snabbstartsserverprojektet behöver du paketet med push-meddelandetillägget. Mer information finns i arbeta med .NET-backendserverns SDK för Azure Mobile Apps.

Förutsättningar

Du behöver följande:

En IDE, beroende på ditt projektets backend:
- Android Studio om den här appen har en Node.js backend.
- Visual Studio Community 2013 eller senare om den här appen har en Microsoft .NET-serverdel.
Android 2.3 eller senare, Google Repository revision 27 eller senare och Google Play Services 9.0.2 eller senare för Firebase Cloud Messaging.
Slutför Android-snabbstarten.

Skapa ett projekt som stöder Firebase Cloud Messaging

Logga in på Firebase-konsolen. Skapa ett nytt Firebase-projekt om du inte redan har ett.
När du har skapat ett projekt väljer du Lägg till Firebase till din Android-app.
På sidan Lägg till Firebase i din Android-app utför du följande steg:
1. För Android-paketnamn kopierar du värdet för ditt applicationId i programmets build.gradle-fil. I det här exemplet är det com.fabrikam.fcmtutorial1app.
2. Välj Registrera app.
Välj Ladda ned google-services.json, spara filen i appmappen för projektet och välj sedan Nästa.
Gör följande konfigurationsändringar i projektet i Android Studio.
1. I din build.gradle-fil på projektnivå (<project>/build.gradle) lägger du till följande sats i avsnittet beroenden.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. I filen build.gradle på appens nivå (<project>/<app-module>/build.gradle) lägger du till följande uttalanden i avsnittet dependencies.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Lägg till följande rad i slutet av filen build.gradle på appnivå efter avsnittet beroenden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Välj Synkronisera nu i verktygsfältet.
Välj Nästa.
Välj Hoppa över det här steget.
Välj kugghjulet för ditt projekt i Firebase-konsolen. Välj sedan Projektinställningar.
Om du inte har laddat ned google-services.json-filen till appmappen för ditt Android Studio-projekt kan du göra det på den här sidan.
Växla till fliken Cloud Messaging längst upp.
Kopiera och spara servernyckeln för senare användning. Du använder det här värdet för att konfigurera din hubb.

Konfigurera en meddelandehubb

Funktionen Mobile Apps i Azure App Service använder Azure Notification Hubs för att skicka push-meddelanden, så du konfigurerar en meddelandehubb för din mobilapp.

I Azure-portalengår du till App Servicesoch väljer sedan appens serverdel. Under Inställningarväljer du Push.
Om du vill lägga till en meddelandehubbresurs i appen väljer du Anslut. Du kan antingen skapa en hubb eller ansluta till en befintlig.

Nu har du anslutit en meddelandehubb till ditt Mobile Apps-backend-projekt. Senare konfigurerar du den här meddelandehubben för att ansluta till ett plattformsmeddelandesystem (PNS) för att skicka till enheter.

Konfigurera Azure för att skicka push-meddelanden

I Azure-portalenklickar du på Bläddra>App-tjänsteroch klickar sedan på Mobile Apps-serverdelen. Under Inställningarklickar du på App Service Pushoch klickar sedan på namnet på meddelandehubben.
Gå till Google (GCM), ange värdet servernyckel som du hämtade från Firebase i föregående procedur och klicka sedan på Spara.

Mobile Apps-serverdelen är nu konfigurerad för att använda Firebase Cloud Messaging. På så sätt kan du skicka push-meddelanden till din app som körs på en Android-enhet med hjälp av meddelandehubben.

Aktivera push-meddelanden för serverprojektet

Använd proceduren som matchar din typ av backend-projekt – antingen .NET-serverdel eller Node.js serverdel.

.NET-backend-projekt

Högerklicka på serverprojektet i Visual Studio och klicka på Hantera NuGet-paket. Sök efter Microsoft.Azure.NotificationHubs och klicka sedan på Installera. Detta installerar Notification Hubs-klientbiblioteket.
Öppna TodoItemController.cs i mappen Controllers och lägg till följande using instruktioner:
```
using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;
```

Ersätt metoden PostTodoItem med följande kod:

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

Återpublicera serverprojektet.

Node.js backend-projekt

Konfigurera ditt backend-projekt.

Ersätt den befintliga koden i filen todoitem.js med följande:

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;

Detta skickar ett GCM-meddelande som innehåller item.text när ett nytt att göra-objekt infogas.

När du redigerar filen på den lokala datorn publicerar du serverprojektet igen.

Lägga till push-meddelanden i din app

I det här avsnittet uppdaterar du din android-klientapp för att hantera push-meddelanden.

Verifiera Android SDK-versionen

På grund av pågående utveckling kanske Android SDK-versionen som är installerad i Android Studio inte matchar versionen i koden. Android SDK som refereras i den här självstudien är version 26, den senaste i skrivande stund. Versionsnumret kan öka när nya versioner av SDK visas, och vi rekommenderar att du använder den senaste tillgängliga versionen.

Två symtom på versionsfel är:

När du skapar eller återskapar projektet kan du få Gradle-felmeddelanden som Gradle sync failed: Failed to find target with hash string 'android-XX'.
Android-standardobjekt i kod som ska matchas baserat på import instruktioner kan generera felmeddelanden.

Om någon av dessa visas kanske inte versionen av Android SDK som är installerad i Android Studio matchar SDK-målet för det nedladdade projektet. Kontrollera versionen genom att göra följande ändringar:

I Android Studio klickar du på Verktyg>Android>SDK Manager. Om du inte har installerat den senaste versionen av SDK-plattformen klickar du på för att installera den. Anteckna versionsnumret.
Öppna filen build.gradle (Modul: app) under Gradle-skript på fliken Projektutforskaren. Kontrollera att compileSdkVersion och targetSdkVersion är inställda på den senaste SDK-versionen installerad. Kan build.gradle se ut så här:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

Nästa steg är att installera Google Play-tjänster. Firebase Cloud Messaging har vissa minimikrav på API-nivå för utveckling och testning, som egenskapen minSdkVersion i manifestet måste överensstämma med.

Om du testar med en äldre enhet läser du Lägg till Firebase i Ditt Android-projekt för att avgöra hur lågt du kan ange det här värdet och ange det på rätt sätt.

Lägga till Firebase Cloud Messaging i projektet

Lägga till Firebase i ditt Android-projekt
I Android Studio väljer duFilprojektstruktur>. Välj Meddelanden, välj Firebase Cloud Messaging och klicka sedan på OK.

Lägg till kod

Öppna filen AndroidManifest.xmli ditt appprojekt. Lägg till följande kod efter den inledande taggen application :

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

Öppna filen ToDoActivity.javaoch gör följande ändringar:

Lägg till import-instruktionen:

import com.google.firebase.iid.FirebaseInstanceId;

Ändra definitionen av MobileServiceClient från privat till privat statisk, så att den nu ser ut så här:
```
private static MobileServiceClient mClient;
```

Lägg till registerPush metod:

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

Uppdatera metoden onCreate för ToDoActivity klassen. Se till att lägga till den här koden när den MobileServiceClient har instansierats.
```
registerPush();
```

Lägg till en ny klass för att hantera meddelanden. I Project Explorer öppnar du noderna java>>your-project-namespace och högerklickar på noden paketnamn. Klicka på Ny och sedan på Java-klass. I Namn skriver du ToDoMessagingServiceoch klickar sedan på OK. Ersätt sedan klassdeklarationen med:

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

Lägg till en annan klass för att hantera tokenuppdateringar. Skapa ToDoInstanceIdService java-klass och ersätt klassdeklarationen med:

import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

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

Appen har nu uppdaterats för att stödja push-meddelanden.

Testa appen mot den publicerade mobiltjänsten

Du kan testa appen genom att direkt ansluta en Android-telefon med en USB-kabel eller med hjälp av en virtuell enhet i emulatorn.

Nästa steg

Nu när du har slutfört den här självstudien kan du överväga att fortsätta till någon av följande självstudier:

Lägg till autentisering i din Android-app. Lär dig hur du lägger till autentisering i snabbstartsprojektet för todolist på Android med hjälp av en identitetsprovider som stöds.
Aktivera offlinesynkronisering för din Android-app. Lär dig hur du lägger till offlinestöd till din app med hjälp av en mobile apps-serverdel. Med offlinesynkronisering kan användarna interagera med en mobilapp – visa, lägga till eller ändra data – även om det inte finns någon nätverksanslutning.

Dela via