Pushmeldingen toevoegen aan uw Android-app

2019-06-25

Overzicht

In deze zelfstudie voegt u pushmeldingen toe aan de Aan de slag met Android project, zodat een pushmelding naar het apparaat wordt verzonden telkens wanneer een record wordt ingevoegd.

Als u het gedownloade snelstartserverproject niet gebruikt, hebt u het pakket voor pushmeldingen nodig. Zie Werken met de SDK voor de .NET-back-endserver voor Azure Mobile Appsvoor meer informatie.

Benodigdheden

U hebt het volgende nodig:

Een IDE, afhankelijk van de back-end van uw project:
- Android Studio als deze app een Node.js back-end heeft.
- Visual Studio Community 2013 of hoger als deze app een Microsoft .NET-back-end heeft.
Android 2.3 of hoger, Google Repository revisie 27 of hoger en Google Play Services 9.0.2 of hoger voor Firebase Cloud Messaging.
Voltooi de Android snelstart .

Een project maken dat ondersteuning biedt voor Firebase Cloud Messaging

Meld u aan bij de Firebase-console. Maak een nieuw Firebase-project als u er nog geen hebt.
Nadat u uw project hebt gemaakt, selecteert u Firebase toevoegen aan uw Android-app.
Voer de volgende stappen uit op de pagina Firebase toevoegen aan uw Android-app:
1. Voor Android-pakketnaam kopieert u de waarde van uw applicationId in het bestand build.gradle van uw toepassing. In dit voorbeeld is het com.fabrikam.fcmtutorial1app.
2. Selecteer App registreren.
Selecteer google-services.json downloaden, sla het bestand op in de map app van uw project, en selecteer Volgende.
Breng de volgende configuratiewijzigingen aan in uw project in Android Studio.
1. Voeg in het bestand build.gradle op projectniveau (<project>/build.gradle) de volgende instructie toe aan de sectie dependencies (afhankelijkheden).
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Voeg in het build.gradle-bestand op app-niveau (<project>/<app-module>/build.gradle) de volgende instructies toe aan de sectie afhankelijkheden .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Voeg de volgende regel toe aan het einde van het build.gradle-bestand op app-niveau na de sectie met afhankelijkheden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selecteer Nu synchroniseren op de werkbalk.
Kies Volgende.
Selecteer Deze stap overslaan.
Selecteer in de Firebase-console het tandwiel van uw project. Selecteer vervolgens Projectinstellingen.
Als u het bestand google-services.json niet hebt gedownload in de map app van uw Android Studio-project, kunt u dat op deze pagina doen.
Ga naar Cloud Messaging bovenaan op het tabblad.
Kopieer de Serversleutel en sla deze op voor later gebruik. U gebruikt deze waarde om uw hub te configureren.

Een Notification Hub configureren

De functie Mobile Apps van Azure App Service maakt gebruik van Azure Notification Hubs om pushes te verzenden, zodat u een Notification Hub configureert voor uw mobiele app.

Ga in de Azure Portalnaar App Services-en selecteer vervolgens de back-end van uw app. Selecteer onder Instellingende optie Push.
Om een meldingshubbron aan de app toe te voegen, selecteert u Verbinding maken. U kunt een hub maken of verbinding maken met een bestaande hub.

U hebt nu een Notification Hub verbonden met uw back-endproject voor Mobiele apps. Later configureert u deze Notification Hub om verbinding te maken met een platformmeldingssysteem (PNS) om naar apparaten te pushen.

Azure configureren voor het verzenden van pushmeldingen

Klik in het Azure-portaalop Browse All>App Servicesen klik vervolgens op de back-end van je mobiele apps. Klik onder Instellingenop App Service Push-en klik vervolgens op de naam van de Notification Hub.
Ga naar Google (GCM), voer de serversleutel waarde in die u in de vorige procedure hebt verkregen bij Firebase en klik vervolgens op Opslaan.

De back-end van Mobile Apps is nu geconfigureerd voor het gebruik van Firebase Cloud Messaging. Hiermee kunt u pushmeldingen verzenden naar uw app die wordt uitgevoerd op een Android-apparaat met behulp van de Notification Hub.

Pushmeldingen inschakelen voor het serverproject

Gebruik de procedure die overeenkomt met het type back-endproject: .NET-back-end of Node.js back-end.

.NET back-end project

Klik in Visual Studio met de rechtermuisknop op het serverproject en klik op NuGet-pakketten beheren. Zoek naar Microsoft.Azure.NotificationHubsen klik daarna op Installeren. Hiermee wordt de Notification Hubs-clientbibliotheek geïnstalleerd.
Open TodoItemController.cs in de map Controllers en voeg de volgende using-instructies toe:
```
using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;
```

Vervang de PostTodoItem methode door de volgende code:

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

Publiceer het serverproject opnieuw.

Node.js back-end project

Stel uw back-endproject in.

Vervang de bestaande code in het bestand todoitem.js door het volgende:

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;

Hiermee wordt een GCM-melding verzonden die de tekst van het item bevat wanneer een nieuw taakitem wordt toegevoegd.

Wanneer u het bestand op uw lokale computer bewerkt, publiceert u het serverproject opnieuw.

Pushmeldingen toevoegen aan uw app

In deze sectie werkt u de Android-client-app bij om pushmeldingen te verwerken.

Android SDK-versie controleren

Vanwege de voortdurende ontwikkeling komt de Android SDK-versie die is geïnstalleerd in Android Studio mogelijk niet overeen met de versie in de code. De Android SDK waarnaar in deze zelfstudie wordt verwezen, is versie 26, de laatste op het moment van schrijven. Het versienummer kan toenemen naarmate er nieuwe versies van de SDK worden weergegeven. We raden u aan de nieuwste beschikbare versie te gebruiken.

Twee symptomen van niet-overeenkomende versie zijn:

Wanneer u het project bouwt of herbouwt, krijgt u mogelijk Gradle-foutberichten zoals Gradle sync failed: Failed to find target with hash string 'android-XX'.
Standaard Android-objecten in code die moeten worden opgelost op basis van import instructies, kunnen foutberichten genereren.

Als een van deze wordt weergegeven, komt de versie van de Android SDK die is geïnstalleerd in Android Studio mogelijk niet overeen met het SDK-doel van het gedownloade project. Als u de versie wilt controleren, moet u de volgende wijzigingen aanbrengen:

Klik in Android Studio op Tools>Android>SDK Manager. Als u de nieuwste versie van het SDK-platform niet hebt geïnstalleerd, klikt u erop om deze te installeren. Noteer het versienummer.
Open op het tabblad Projectverkenner onder Gradle-scriptshet bestand build.gradle (Module: app). Zorg ervoor dat de compileSdkVersion- en targetSdkVersion- zijn ingesteld op de nieuwste SDK-versie. De build.gradle ziet er mogelijk als volgt uit:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

De volgende stap is het installeren van Google Play-services. Firebase Cloud Messaging heeft enkele minimale API-niveauvereisten voor ontwikkeling en testen, waaraan de eigenschap minSdkVersion in het manifest moet voldoen.

Als u met een ouder apparaat test, raadpleegt u Firebase toevoegen aan uw Android-project om te bepalen hoe laag u deze waarde kunt instellen en deze op de juiste manier kunt instellen.

Firebase Cloud Messaging toevoegen aan het project

Firebase toevoegen aan uw Android-project
Kies in Android Studio File>Project Structure. Selecteer Meldingen, selecteer Firebase Cloud Messagingen klik vervolgens op OK.

Code toevoegen

Open in uw app project het bestand AndroidManifest.xml. Voeg de volgende code toe na de application opening-tag:

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

Open het bestand ToDoActivity.javaen breng de volgende wijzigingen aan:

Voeg de importinstructie toe:

import com.google.firebase.iid.FirebaseInstanceId;

Wijzig de definitie van MobileServiceClient van privé- naar statisch , zodat de definitie er nu als volgt uitziet:
```
private static MobileServiceClient mClient;
```

Methode registerPush toevoegen:

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

Werk de methode onCreate van de klasse ToDoActivity bij. Zorg ervoor dat u deze code toevoegt nadat de MobileServiceClient is geïnstantieerd.
```
registerPush();
```

Voeg een nieuwe klasse toe om meldingen te verwerken. Open in Projectverkenner de -app>java>-knooppunten van uw projectnaamruimte en klik met de rechtermuisknop op de knoop met de pakketnaam. Klik op Nieuween klik vervolgens op Java-klasse. Typ ToDoMessagingServicein Naam en klik op OK. Vervang vervolgens de klassedeclaratie door:

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

Voeg nog een klasse toe om tokenupdates te verwerken. Maak ToDoInstanceIdService Java-klasse en vervang de klassedeclaratie door:

import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

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

Uw app is nu bijgewerkt ter ondersteuning van pushmeldingen.

De app testen op basis van de gepubliceerde mobiele service

U kunt de app testen door een Android-telefoon rechtstreeks aan te koppelen met een USB-kabel of door een virtueel apparaat in de emulator te gebruiken.

Volgende stappen

Nu u deze zelfstudie hebt voltooid, kunt u doorgaan met een van de volgende zelfstudies:

Verificatie toevoegen aan uw Android-app. Meer informatie over het toevoegen van verificatie aan het snelstartproject todolist op Android met behulp van een ondersteunde id-provider.
offlinesynchronisatie inschakelen voor uw Android-app. Meer informatie over het toevoegen van offlineondersteuning aan uw app met behulp van een back-end van Mobile Apps. Met offlinesynchronisatie kunnen gebruikers communiceren met een mobiele app( gegevens weergeven, toevoegen of wijzigen), zelfs als er geen netwerkverbinding is.

Delen via