Aggiungi notifiche push alla tua app Android

Androide
Cordova
Ios
Finestre
Xamarin.Android
Xamarin.iOS
Xamarin.Forms

Informazioni generali

In questa esercitazione si aggiungono notifiche push al progetto di avvio rapido di Android in modo che venga inviata una notifica push al dispositivo ogni volta che viene inserito un record.

Se non si usa il progetto server di avvio rapido scaricato, è necessario il pacchetto di estensione per le notifiche push. Per altre informazioni, vedere Usare l'SDK del server back-end .NET per App per dispositivi mobili di Azure.

Prerequisiti

Sono necessari gli elementi seguenti:

Un IDE, a seconda del back-end del progetto:
- Android Studio se l'app ha un backend Node.js.
- visual Studio Community 2013 o versione successiva se l'app dispone di un back-end Microsoft .NET.
Android 2.3 o versione successiva, Google Repository versione 27 o successiva e Google Play Services 9.0.2 o versione successiva per Firebase Cloud Messaging.
Completare l'avvio rapido di Android.

Creare un progetto che supporti Firebase Cloud Messaging

Accedere alla console di Firebase. Crea un nuovo progetto Firebase se non ne hai già uno.
Dopo aver creato il progetto, selezionare Add Firebase to your Android app (Aggiungi Firebase all'app Android).
Nella pagina Aggiungere Firebase all'app Android seguire questa procedura:
1. Per Android package name (Nome pacchetto Android), copiare il valore di applicationId nel file build.gradle dell'applicazione. In questo esempio, è com.fabrikam.fcmtutorial1app.
2. Selezionare Registra l'app.
Selezionare Download google-services.json (Scarica google-services.json), salvare il file nella cartella app del progetto e quindi selezionare Avanti.
Apportare le seguenti modifiche di configurazione al progetto in Android Studio.
1. Nel file project-level build.gradle (<project>/build.gradle) aggiungere l'istruzione seguente alla sezione dependencies.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Nel file build.gradle a livello di app (<progetto>/<app-module>/build.gradle), aggiungere le istruzioni seguenti alla sezione dependencies .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Aggiungere la riga seguente alla fine del file app-level build.gradle dopo la sezione dependencies.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selezionare Sincronizza ora sulla barra degli strumenti.
Seleziona Avanti.
Selezionare Ignora questo passaggio.
Nella console di Firebase, selezionare l'ingranaggio per il proprio progetto. Selezionare quindi Project Settings (Impostazioni progetto).
Se il file google-services.json non è stato scaricato nella cartella app del progetto di Android Studio, è possibile eseguire questa operazione in questa pagina.
Passare alla scheda Cloud Messaging in alto.
Copiare e salvare la Chiave server per utilizzi futuri. Questo valore viene usato per configurare l'hub.

Configurare un hub di notifica

La funzionalità App per dispositivi mobili del servizio app di Azure usa Hub di notifica di Azure per inviare push, quindi si configurerà un hub di notifica per l'app per dispositivi mobili.

Nel portale di Azure , vai a App servicese quindi seleziona il back-end della tua app. Nelle Impostazioni, selezionare Push.
Per aggiungere una risorsa hub di notifica all'app, selezionare Connetti. È possibile creare un hub o connettersi a un hub esistente.

A questo punto è stato connesso un hub di notifica al progetto back-end di App per dispositivi mobili. Successivamente si configura questo hub di notifica per connettersi a un sistema di notifica della piattaforma (PNS) per eseguire il push nei dispositivi.

Configurare Azure per l'invio di notifiche push

Nel portale di Azure , fare clic su Sfoglia Tutti i Servizi App>, e quindi sul back-end delle app per dispositivi mobili. Nelle Impostazioni, fai clic su Servizio app pushe quindi clicca sul nome dell'hub di notifica.
Passare a Google (GCM), immettere il valore Server Key ottenuto da Firebase nella precedente procedura e quindi fare clic su Salva.

Il back-end di App per dispositivi mobili è ora configurato per l'uso di Firebase Cloud Messaging. In questo modo è possibile inviare notifiche push all'app in esecuzione in un dispositivo Android usando l'hub di notifica.

Abilitare le notifiche push per il progetto server

Usare la procedura corrispondente al tipo di progetto back-end, back-end .NET o Node.js back-end.

Progetto .NET back-end

In Visual Studio fare clic con il pulsante destro del mouse sul progetto server e scegliere Gestisci pacchetti NuGet. Cercare Microsoft.Azure.NotificationHubse quindi fare clic su Installa. Questo installa la libreria client di Hub di notifica.
Nella cartella Controllers aprire TodoItemController.cs e aggiungere le istruzioni using seguenti:
```
using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;
```

Sostituire il metodo PostTodoItem con il codice seguente:

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

Ripubblica il progetto del server.

Node.js progetto back-end

Configurare il progetto backend.

Sostituire il codice esistente nel file todoitem.js con il codice seguente:

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;

Viene inviata una notifica GCM contenente il file item.text quando viene inserito un nuovo elemento todo.

Quando si modifica il file nel computer locale, ripubblicare il progetto sul server.

Aggiungi notifiche push all'app

In questa sezione si aggiorna l'app Android client per gestire le notifiche push.

Verificare la versione di Android SDK

A causa dello sviluppo in corso, la versione di Android SDK installata in Android Studio potrebbe non corrispondere alla versione nel codice. Android SDK a cui si fa riferimento in questa esercitazione è la versione 26, la più recente al momento della scrittura. Il numero di versione può aumentare man mano che vengono visualizzate nuove versioni dell'SDK ed è consigliabile usare la versione più recente disponibile.

Due sintomi di mancata corrispondenza della versione sono:

Quando si compila o si ricompila il progetto, è possibile che vengano visualizzati messaggi di errore Gradle come Gradle sync failed: Failed to find target with hash string 'android-XX'.
Gli oggetti Android standard nel codice che devono essere risolti in base alle istruzioni import possono generare messaggi di errore.

Se viene visualizzata una di queste, la versione di Android SDK installata in Android Studio potrebbe non corrispondere alla destinazione SDK del progetto scaricato. Per verificare la versione, apportare le modifiche seguenti:

In Android Studio fare clic su Strumenti di >Android>SDK Manager. Se non è stata installata la versione più recente della piattaforma SDK, fare clic per installarla. Prendere nota del numero di versione.
Nella scheda Esplora progetti, in Gradle Scriptsaprire il file build.gradle (Module: app). Assicurarsi che il compileSdkVersion e targetSdkVersion siano impostati sulla versione più recente dell'SDK installata. Il build.gradle potrebbe apparire così:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

Il passaggio successivo consiste nell'installare i servizi Google Play. Firebase Cloud Messaging ha alcuni requisiti minimi a livello di API per lo sviluppo e il test, a cui la proprietà minSdkVersion nel manifesto deve essere conforme.

Se si esegue il test con un dispositivo meno recente, consultare Aggiungi Firebase al progetto Android per determinare quanto basso è possibile impostare questo valore e impostarlo in modo appropriato.

Aggiungere Firebase Cloud Messaging al progetto

Aggiungere Firebase al progetto Android
In Android Studio scegliere File>Struttura progetto. Selezionare Notifications, selezionare Firebase Cloud Messaginge quindi fare clic su OK.

Aggiungi codice

Nel progetto dell'app , apri il file AndroidManifest.xml. Aggiungere il codice seguente dopo il tag di apertura 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>

Aprire il file ToDoActivity.javae apportare le modifiche seguenti:

Aggiungere l'istruzione import:

import com.google.firebase.iid.FirebaseInstanceId;

Modificare la definizione di MobileServiceClient da privato a statico privato, in modo che ora sia simile al seguente:
```
private static MobileServiceClient mClient;
```

Aggiungere registerPush metodo:

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

Aggiornare il metodo onCreate della classe ToDoActivity. Assicurarsi di aggiungere questo codice dopo l'inizializzazione del MobileServiceClient.
```
registerPush();
```

Aggiungere una nuova classe per gestire le notifiche. In Esplora risorse, apri i nodi dell'app >java>dello spazio dei nomi del tuo progetto, e fai clic con il pulsante destro del mouse sul nodo del nome del pacchetto. Fare clic su Nuovoe quindi su classe Java. In Nome digitare ToDoMessagingServicee quindi fare clic su OK. Sostituire quindi la dichiarazione di classe con:

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

Aggiungere un'altra classe per gestire gli aggiornamenti dei token. Creare ToDoInstanceIdService classe Java e sostituire la dichiarazione di classe con:

import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

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

L'app è ora aggiornata per supportare le notifiche push.

Testare l'app sul servizio mobile pubblicato

È possibile testare l'app collegando direttamente un telefono Android con un cavo USB o usando un dispositivo virtuale nell'emulatore.

Passaggi successivi

Dopo aver completato questa esercitazione, è consigliabile continuare con una delle esercitazioni seguenti:

Aggiungere l'autenticazione all'app Android. Informazioni su come aggiungere l'autenticazione al progetto di avvio rapido todolist in Android usando un provider di identità supportato.
Abilitare la sincronizzazione offline per l'app Android. Informazioni su come aggiungere il supporto offline all'app usando un back-end di App per dispositivi mobili. Con la sincronizzazione offline, gli utenti possono interagire con un'app per dispositivi mobili, visualizzando, aggiungendo o modificando i dati, anche quando non è presente alcuna connessione di rete.

Last updated on 2019-06-25

Condividi tramite