Pushmeldingen toevoegen aan uw Android-app

Artikel
06/25/2019

Overzicht

In deze zelfstudie voegt u pushmeldingen toe aan het Android Quick Start-project , zodat er telkens wanneer een record wordt ingevoegd, een pushmelding naar het apparaat wordt verzonden.

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

Vereisten

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 snelstartgids voor Android.

Een project maken dat Firebase Cloud Messaging ondersteunt

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.
Selecteer Next.
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. U gaat dus een Notification Hub configureren voor uw mobiele app.

Ga in de Azure Portal naar App Services en selecteer vervolgens de back-end van uw app. Selecteer Push onder Instellingen.
Als u een Notification Hub-resource aan de app wilt toevoegen, 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 van Mobile Apps. Later configureert u deze Notification Hub om verbinding te maken met een PNS (Platform Notification System) om naar apparaten te pushen.

Azure configureren voor het verzenden van pushmeldingen

Klik in de Azure Portal op Alle>App Services bladeren en klik vervolgens op de back-end van uw Mobiele apps. Klik onder Instellingen op App Service Push en klik vervolgens op de naam van de Notification Hub.
Ga naar Google (GCM) en voer de serversleutelwaarde in die u in de vorige procedure hebt verkregen van Firebase en klik vervolgens op Opslaan.

De back-end van Mobile Apps is nu geconfigureerd voor het gebruik van Firebase Cloud Messaging. Hierdoor 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 uw back-endprojecttype, ofwel .NET-back-end of Node.js back-end.

.NET-back-endproject

Klik in Visual Studio met de rechtermuisknop op het serverproject en klik op NuGet-pakketten beheren. Microsoft.Azure.NotificationHubsZoek en klik vervolgens 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-endproject

Stel uw back-endproject in.

Vervang de bestaande code in het todoitem.js-bestand 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 item.text bevat wanneer een nieuw taakitem wordt ingevoegd.

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 in Android Studio is geïnstalleerd mogelijk niet overeen met de versie in de code. De Android SDK waarnaar in deze zelfstudie wordt verwezen, is versie 26, de meest recente versie op het moment van schrijven. Het versienummer kan toenemen naarmate er nieuwe releases van de SDK worden weergegeven. U wordt aangeraden de meest recente 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 omgezet op import basis van instructies, kunnen foutberichten genereren.

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

Klik in Android Studio op Extra>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 Scripts, de file build.gradle (Module: app). Zorg ervoor dat de compileSdkVersion en targetSdkVersion zijn ingesteld op de nieuwste SDK-versie die is geïnstalleerd. Het build.gradle kan er als volgt uitzien:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

De volgende stap is het installeren van Google Play-services. Firebase Cloud Messaging heeft enkele minimale VEREISTEN op API-niveau 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 deoptie Bestandsprojectstructuur>. Selecteer Meldingen, selecteer Firebase Cloud Messaging en klik vervolgens op OK.

Code toevoegen

Open het bestand in uw app-projectAndroidManifest.xml. Voeg de volgende code toe na de application openingstag:

<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 MobileServiceClientprivé naar privé statisch, dus deze ziet er nu als volgt uit:
```
private static MobileServiceClient mClient;
```

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

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

Voeg een nieuwe klasse toe om meldingen te verwerken. Open in Projectverkenner de app>java>your-project-namespace nodes en klik met de rechtermuisknop op het pakketnaamknooppunt. Klik op Nieuw en klik vervolgens op Java Class. 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. Java-klasse maken ToDoInstanceIdService en de klassedeclaratie vervangen 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 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, zoals het weergeven, toevoegen of wijzigen van gegevens, zelfs als er geen netwerkverbinding is.

Delen via