Aggiungere notifiche push all'app Android

Panoramica

In questa esercitazione vengono aggiunte notifiche push al progetto avvio rapido di Android, in modo che una notifica push venga inviata al dispositivo a ogni inserimento di record.

Se non si usa il progetto server di avvio rapido scaricato, è necessario aggiungere il pacchetto di estensione di notifica 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, in base al back-end del progetto:

  • Android 2.3 o versione successiva, Google Repository 27 o versione 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 supporta Google Cloud Messaging

  1. Accedere alla console di Firebase. Creare un nuovo progetto Firebase se non è già disponibile.
  2. Dopo aver creato il progetto, fare clic su Add Firebase to your Android app (Aggiungi Firebase all'app Android) e seguire le istruzioni fornite.

  3. Nella console di Firebase fare clic sul file cog per il progetto e quindi fare clic su Impostazioni progetto.

  4. Fare clic sulla scheda Cloud Messaging nelle impostazioni del progetto e copiare il valore di Chiave server e ID mittente. Questi valori verranno usati in un secondo momento per configurare i criteri di accesso dell'hub di notifica de e il gestore delle notifiche nell'app.

Configurare un hub di notifica

Poiché le funzioni delle app per dispositivi mobili del Servizio app di Azure usano Hub di notifica di Azure per inviare push, si dovrà configurare un hub di notifica per l'app per dispositivi mobili.

  1. Nel Portale di Azure andare in Servizi app, quindi fare clic sul back-end dell'app. In Impostazioni fare clic su Push.
  2. Fare clic su Connetti per aggiungere una risorsa dell'hub di notifica all'app. È possibile creare un hub o connettersi a uno esistente.

A questo punto un hub di notifica è stato connesso al progetto di back-end dell'app per dispositivi mobili. In seguito si configurerà l'hub di notifica per la connessione a un Platform Notification System (PNS) per effettuare il push ai dispositivi.

Configurare Azure per l'invio di notifiche push

  1. Nel Portale di Azure fare clic su Browse All (Esplora tutto) > Servizi app e quindi scegliere il back-end dell'app per dispositivi mobili. In Impostazioni fare clic su App Service Push (Push servizio app), quindi fare clic sul nome dell'hub di notifica.
  2. Passare a Google (GCM), immettere il valore Chiave server ottenuto da Firebase nella procedura precedente, quindi fare clic su Salva.

    Impostare la chiave API di GCM nel portale

Il back-end dell'app per dispositivi mobili è ora configurato per l'uso di Firebase Cloud Messaging. Questo consente di inviare notifiche push all'app in esecuzione su un dispositivo Android usando l'hub di notifica.

Abilitare le notifiche push per il progetto server

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

Progetto di back-end .NET

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto server, quindi scegliere Gestisci pacchetti NuGet. Cercare Microsoft.Azure.NotificationHubs, quindi fare clic su Installa. Verrà installata la libreria client dell'Hub di notifica.
  2. Nella cartella Controller aprire TodoItemController.cs e aggiungere le istruzioni using seguenti:

     using Microsoft.Azure.Mobile.Server.Config;
     using Microsoft.Azure.NotificationHubs;
    
  3. 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);
     }
    
  4. Pubblicare di nuovo il progetto server.

Progetto di back-end Node.js

  1. Scaricare il progetto di avvio rapido, se non è ancora stato scaricato, oppure usare l'editor online del Portale di Azure.
  2. Sostituire il codice esistente nel file todoitem.js file 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 http://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;  
    

    Ogni volta che viene inserito un nuovo elemento Todo, viene inviata una notifica GCM contenente l'elemento item.text.

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

Aggiungere notifiche push all'app

In questa sezione l'app del client Android viene aggiornata in modo da gestire le notifiche push.

Verificare la versione di Android SDK

Poiché lo sviluppo è ancora in corso, la versione di Android SDK installata in Android Studio potrebbe non corrispondere a quella del codice. In questa esercitazione si fa riferimento alla versione 23 di Android SDK, ovvero la più recente al momento della stesura di questo documento. Il numero di versione dell'SDK può aumentare nel corso del tempo ed è consigliabile usare la versione più recente disponibile.

Due sintomi di una mancata corrispondenza delle versioni sono i seguenti:

  • Quando si compila o ricompila il progetto, è possibile che vengano visualizzati messaggi di errore Gradle come "impossibile trovare la destinazione Google Inc.:API Google:n".
  • Gli oggetti Android standard nel codice che dovrebbero risolversi in base a istruzioni import potrebbero generare messaggi di errore.

Se si manifesta uno di questi sintomi, la versione di Android SDK installata in Android Studio potrebbe non corrispondere alla destinazione dell'SDK del progetto scaricato. Per verificare la versione, apportare le modifiche seguenti:

  1. In Android Studio fare clic su Tools (Strumenti) > Android > SDK Manager. Se la versione più recente della piattaforma SDK non è installata, fare clic per installarla. Prendere nota del numero di versione.
  2. Nella scheda Esplora progetti in Gradle Scripts (Script Gradle) aprire il file build.gradle (modeule: app). Assicurarsi che i valori di compileSdkVersion e buildToolsVersion siano impostati sull'ultima versione dell'SDK installata. I tag potrebbero avere questo aspetto:

          compileSdkVersion 'Google Inc.:Google APIs:23'
         buildToolsVersion "23.0.2"
    
  3. In Esplora progetti di Android Studio fare clic con il pulsante destro del mouse sul nodo del progetto, scegliere Proprietà e fare clic su Android nella colonna a sinistra. Assicurarsi che il valore di Project Build Target (Destinazione build progetto) sia impostato sulla stessa versione dell'SDK di targetSdkVersion.

A differenza di quanto avviene in Eclipse, in Android Studio il file manifesto non consente di specificare l'SDK di destinazione e la versione minima dell'SDK.

Il passaggio successivo comporta l'installazione di Google Play Services. Google Cloud Messaging prevede alcuni requisiti minimi a livello di API per lo sviluppo e i test. È necessario che la proprietà minSdkVersion nel file manifesto sia conforme a tali requisiti.

Se il test viene eseguito con un dispositivo meno recente, vedere Set Up Google Play Services SDK per determinare il livello minimo su cui è possibile impostare tale valore.

Aggiungere Google Play Services al progetto

  1. Aprire Android SDK Manager facendo clic sull'icona della barra degli strumenti di Android Studio o su Strumenti > Android > SDK Manager nel menu. Fare clic sul collegamento Launch Standalone SDK Manager (Lancia SDK Manager autonomo).
  2. Trovare la versione di destinazione di Android SDK che viene usata nel progetto e aprirla. Se Google API non è già installato, selezionarlo e premere Install packages... (Installa pacchetti...).
  3. In Android Studio scegliere File > Struttura progetto. Premere Notifiche, selezionare Google Cloud Messaging e quindi premere OK.

Aggiungere codice

  1. Nel progetto di app aprire il file AndroidManifest.xml. Nel codice per i due passaggi successivi sostituire `my_app_package` con il nome del pacchetto dell'app per il progetto. Si tratta del valore dell'packageattributo del manifest tag.
  2. Aggiungere le nuove autorizzazioni seguenti dopo l'elemento uses-permission esistente:

     <permission android:name="**my_app_package**.permission.C2D_MESSAGE"
         android:protectionLevel="signature" />
     <uses-permission android:name="**my_app_package**.permission.C2D_MESSAGE" />
     <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
    
  3. Aggiungere il codice seguente dopo il tag di apertura application :

     <receiver android:name="com.microsoft.windowsazure.notifications.NotificationsBroadcastReceiver"
                                      android:permission="com.google.android.c2dm.permission.SEND">
         <intent-filter>
             <action android:name="com.google.android.c2dm.intent.RECEIVE" />
             <category android:name="**my_app_package**" />
         </intent-filter>
     </receiver>
    
  4. Aprire il file ToDoActivity.java, quindi aggiungere l'istruzione import seguente:

     import com.microsoft.windowsazure.notifications.NotificationsManager;
    
  5. Aggiungere la variabile privata seguente alla classe. Sostituire <PROJECT_NUMBER> con il numero di progetto assegnato da Google all'app nella procedura precedente.

     public static final String SENDER_ID = "<PROJECT_NUMBER>";
    
  6. Modificare la definizione di MobileServiceClient da private a public static, in modo che sia simile alla seguente:

     public static MobileServiceClient mClient;
    
  7. Aggiungere una nuova classe per gestire le notifiche. In Esplora progetti aprire i nodi src > main > java e fare clic con il pulsante destro del mouse sul nodo del nome del pacchetto. Fare clic su Nuovo e quindi su Java Class (Classe Java).
  8. In Nome digitare MyHandler, quindi fare clic su OK.

  9. Nel file MyHandler sostituire la dichiarazione di classe con:

     public class MyHandler extends NotificationsHandler {
    
  10. Aggiungere le istruzioni import seguenti per la classe MyHandler :

    import com.microsoft.windowsazure.notifications.NotificationsHandler;
    import android.app.NotificationManager;
    import android.app.PendingIntent;
    import android.content.Context;
    import android.content.Intent;
    import android.os.AsyncTask;
    import android.os.Bundle;
    import android.support.v4.app.NotificationCompat;
    
  11. Aggiungere quindi questo membro alla classe MyHandler :

    public static final int NOTIFICATION_ID = 1;
    
  12. Nella classe MyHandler aggiungere il codice seguente per eseguire l'override del metodo onRegistered che registra il dispositivo nell'hub di notifica del servizio mobile.

    @Override
    public void onRegistered(Context context,  final String gcmRegistrationId) {
       super.onRegistered(context, gcmRegistrationId);
    
       new AsyncTask<Void, Void, Void>() {
    
           protected Void doInBackground(Void... params) {
               try {
                   ToDoActivity.mClient.getPush().register(gcmRegistrationId);
                   return null;
               }
               catch(Exception e) {
                   // handle error                
               }
               return null;              
           }
       }.execute();
    

    }

  13. Nella classe MyHandler aggiungere il codice seguente per eseguire l'override del metodo onReceive , che determina la visualizzazione della notifica al momento della ricezione.

    @Override
    public void onReceive(Context context, Bundle bundle) {
           String msg = bundle.getString("message");
    
           PendingIntent contentIntent = PendingIntent.getActivity(context,
                   0, // requestCode
                   new Intent(context, ToDoActivity.class),
                   0); // flags
    
           Notification notification = new NotificationCompat.Builder(context)
                   .setSmallIcon(R.drawable.ic_launcher)
                   .setContentTitle("Notification Hub Demo")
                   .setStyle(new NotificationCompat.BigTextStyle().bigText(msg))
                   .setContentText(msg)
                   .setContentIntent(contentIntent)
                   .build();
    
           NotificationManager notificationManager = (NotificationManager)
                   context.getSystemService(Context.NOTIFICATION_SERVICE);
           notificationManager.notify(NOTIFICATION_ID, notification);
    

    }

  14. Nel file TodoActivity.java, aggiornare il metodo onCreate della classe ToDoActivity per registrare la classe del gestore di notifica. Assicurarsi di aggiungere il codice dopo la creazione di un'istanza di MobileServiceClient .

    NotificationsManager.handleNotifications(this, SENDER_ID, MyHandler.class);
    

    L'app è ora aggiornata per il supporto delle notifiche push.

Eseguire il test dell'app sul servizio mobile pubblicato

È possibile eseguire il test dell'app collegando direttamente un telefono Android con un cavo USB oppure usando un dispositivo virtuale nell'emulatore.

Passaggi successivi

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

  • Aggiungere l'autenticazione all'app Android. Questa esercitazione spiega come aggiungere l'autenticazione al progetto introduttivo TodoList in Android tramite un provider di identità supportato.
  • Attivare la sincronizzazione offline per l'app Android. Informazioni su come aggiungere il supporto offline all'app usando il back-end di App per dispositivi mobili. Con la sincronizzazione offline è possibile interagire con un'app per dispositivi mobili —visualizzando, aggiungendo e modificando i dati— anche quando non è disponibile una connessione di rete.